chore: support for sticky params in URL and intent ops

packages/sanity/src/router/RouterProvider.tsx

@@ -1,3 +1,4 @@
+import {partition} from 'lodash'
 import {type ReactElement, type ReactNode, useCallback, useMemo} from 'react'
 import {RouterContext} from 'sanity/_singletons'
 
@@ -94,10 +95,39 @@ export function RouterProvider(props: RouterProviderProps): ReactElement {
   )
 
   const resolvePathFromState = useCallback(
-    (nextState: Record<string, unknown>): string => {
-      return routerProp.encode(nextState)
+    (nextState: RouterState): string => {
+      const currentStateParams = state._searchParams || []
+      const nextStateParams = nextState._searchParams || []
+      const nextParams = STICKY.reduce((acc, param) => {
+        return replaceStickyParam(
+          acc,
+          param,
+          findParam(nextStateParams, param) ?? findParam(currentStateParams, param),
+        )
+      }, nextStateParams || [])
+
+      return routerProp.encode({
+        ...nextState,
+        _searchParams: nextParams,
+      })
     },
-    [routerProp],
+    [routerProp, state],
+  )
+
+  const handleNavigateStickyParam = useCallback(
+    (param: string, value: string | undefined, options: NavigateOptions = {}) => {
+      if (!STICKY.includes(param)) {
+        throw new Error('Parameter is not sticky')
+      }
+      onNavigate({
+        path: resolvePathFromState({
+          ...state,
+          _searchParams: [[param, value || '']],
+        }),
+        replace: options.replace,
+      })
+    },
+    [onNavigate, resolvePathFromState, state],
   )
 
   const navigate = useCallback(
@@ -114,17 +144,55 @@ export function RouterProvider(props: RouterProviderProps): ReactElement {
     [onNavigate, resolveIntentLink],
   )
 
+  const [routerState, stickyParams] = useMemo(() => {
+    if (!state._searchParams) {
+      return [state, null]
+    }
+    const {_searchParams, ...rest} = state
+    const [sticky, restParams] = partition(_searchParams, ([key]) => STICKY.includes(key))
+    if (sticky.length === 0) {
+      return [state, null]
+    }
+    return [{...rest, _searchParams: restParams}, sticky]
+  }, [state])
+
   const router: RouterContextValue = useMemo(
     () => ({
       navigate,
       navigateIntent,
+      navigateStickyParam: handleNavigateStickyParam,
       navigateUrl: onNavigate,
       resolveIntentLink,
       resolvePathFromState,
-      state,
+      state: routerState,
+      stickyParams: Object.fromEntries(stickyParams || []),
     }),
-    [navigate, navigateIntent, onNavigate, resolveIntentLink, resolvePathFromState, state],
+    [
+      handleNavigateStickyParam,
+      navigate,
+      navigateIntent,
+      onNavigate,
+      resolveIntentLink,
+      resolvePathFromState,
+      routerState,
+      stickyParams,
+    ],
   )
 
   return <RouterContext.Provider value={router}>{props.children}</RouterContext.Provider>
 }
+const STICKY: string[] = []
+
+function replaceStickyParam(
+  current: SearchParam[],
+  param: string,
+  value: string | undefined,
+): SearchParam[] {
+  const filtered = current.filter(([key]) => key !== param)
+  return value === undefined || value == '' ? filtered : [...filtered, [param, value]]
+}
+
+function findParam(searchParams: SearchParam[], key: string): string | undefined {
+  const entry = searchParams.find(([k]) => k === key)
+  return entry ? entry[1] : undefined
+}

packages/sanity/src/router/types.ts

@@ -264,6 +264,11 @@ export interface RouterContextValue {
    */
   navigateUrl: (opts: {path: string; replace?: boolean}) => void
 
+  /**
+   * Navigates to the current URL with the sticky url search param set to the given value
+   */
+  navigateStickyParam: (param: string, value: string, options?: NavigateOptions) => void
+
   /**
    * Navigates to the given router state.
    * See {@link RouterState} and {@link NavigateOptions}
@@ -280,4 +285,9 @@ export interface RouterContextValue {
    * The current router state. See {@link RouterState}
    */
   state: RouterState
+
+  /**
+   * The current router state. See {@link RouterState}
+   */
+  stickyParams: Record<string, string | undefined>
 }

packages/sanity/src/structure/components/IntentButton.tsx

@@ -23,7 +23,13 @@ export const IntentButton = forwardRef(function IntentButton(
         linkRef: ForwardedRef<HTMLAnchorElement>,
       ) {
         return (
-          <IntentLink {...linkProps} intent={intent.type} params={intent.params} ref={linkRef} />
+          <IntentLink
+            {...linkProps}
+            intent={intent.type}
+            params={intent.params}
+            ref={linkRef}
+            searchParams={intent.searchParams}
+          />
         )
       }),
     [intent],

packages/sanity/src/structure/structureBuilder/Intent.ts

@@ -1,3 +1,5 @@
+import {type SearchParam} from 'sanity/router'
+
 import {getTypeNamesFromFilter, type PartialDocumentList} from './DocumentList'
 import {type StructureNode} from './StructureNodes'
 
@@ -75,6 +77,8 @@ export interface Intent {
   /** Intent parameters. See {@link IntentParams}
    */
   params?: IntentParams
+
+  searchParams?: SearchParam[]
 }
 
 /**