@sanity/sdk-react 3.0.0-rc.2 → 3.0.0

package/src/context/OrganizationResourcesProvider.tsx

@@ -1,8 +1,8 @@
 import {type DocumentResource, type SanityInstance} from '@sanity/sdk'
 import {type ReactElement, type ReactNode, use, useMemo} from 'react'
 
-import {useDashboardOrganizationId} from '../hooks/auth/useDashboardOrganizationId'
 import {useSanityInstance} from '../hooks/context/useSanityInstance'
+import {useOrganizationId} from '../hooks/dashboard/useOrganizationId'
 import {resolveOrgResources} from '../utils/resolveOrgResources'
 import {ResourcesContext} from './ResourcesContext'
 
@@ -91,7 +91,7 @@ export function OrganizationResourcesProvider({
   children: ReactNode
 }): ReactElement {
   const instance = useSanityInstance()
-  const orgId = useDashboardOrganizationId()
+  const orgId = useOrganizationId()
 
   if (!inferMediaLibraryAndCanvas || !orgId) {
     return (

package/src/context/{workbenchToken.ts → dashboardToken.ts}

@@ -1,13 +1,13 @@
 import {from, type Observable, of} from 'rxjs'
 import {catchError, switchMap} from 'rxjs/operators'
 
-// The workbench host installs its shared message bus on this well-known global
+// The dashboard host installs its shared message bus on this well-known global
 // symbol before it loads federated remotes. It must match the key used by
 // `@sanity/workbench` (`Symbol.for('sanity.os.bus')`).
 const OS_BUS_KEY = Symbol.for('sanity.os.bus')
 
 /**
- * Whether this app is running as a federated remote inside the workbench.
+ * Whether this app is running as a federated remote inside the dashboard.
  *
  * Federation shares the host's realm, so the installed bus is visible on
  * `globalThis`. This is `false` in a standalone app, where we must never import
@@ -18,16 +18,16 @@ const OS_BUS_KEY = Symbol.for('sanity.os.bus')
  *
  * @internal
  */
-export function isWorkbenchEnvironment(): boolean {
+export function isDashboardEnvironment(): boolean {
   return typeof globalThis === 'object' && OS_BUS_KEY in globalThis
 }
 
 /**
- * Observes the session token issued by the workbench "OS", tracking the OS auth
+ * Observes the session token issued by the dashboard "OS", tracking the OS auth
  * state over time.
  *
- * Returns `undefined` when the app is not embedded in the workbench, so the
- * caller uses its normal auth flow. Inside the workbench, subscribes to the
+ * Returns `undefined` when the app is not embedded in the dashboard, so the
+ * caller uses its normal auth flow. Inside the dashboard, subscribes to the
  * `auth.token` state topic, emitting the current token — or `null` when the OS
  * is signed out — and re-emitting as the OS auth state changes, so sign-in/out
  * propagates instead of being captured once. Any bus error is treated as "no
@@ -35,8 +35,8 @@ export function isWorkbenchEnvironment(): boolean {
  *
  * @internal
  */
-export function observeWorkbenchToken(): Observable<string | null> | undefined {
-  if (!isWorkbenchEnvironment()) return undefined
+export function observeDashboardToken(): Observable<string | null> | undefined {
+  if (!isDashboardEnvironment()) return undefined
 
   return from(import('@sanity/workbench')).pipe(
     switchMap(({os}) => os.subscribe('auth.token')),
@@ -46,15 +46,15 @@ export function observeWorkbenchToken(): Observable<string | null> | undefined {
 }
 
 /**
- * Asks the workbench "OS" to reissue the session token, e.g. after its current
+ * Asks the dashboard "OS" to reissue the session token, e.g. after its current
  * one was rejected with a 401. Fire-and-forget: the reissued token arrives via
- * the `auth.token` subscription in {@link observeWorkbenchToken}. No-op outside
- * the workbench.
+ * the `auth.token` subscription in {@link observeDashboardToken}. No-op outside
+ * the dashboard.
  *
  * @internal
  */
-export function refreshWorkbenchToken(): void {
-  if (!isWorkbenchEnvironment()) return
+export function refreshDashboardToken(): void {
+  if (!isDashboardEnvironment()) return
 
   void import('@sanity/workbench').then(
     ({os}) => os.emit('auth.token.refresh', undefined),

package/src/hooks/comlink/useWindowConnection.ts

@@ -66,7 +66,7 @@ const useNodeState = createStateSourceHook({
  * as well as sharing a single node between invocations if they share the same name.
  *
  * Generally not to be used directly, but to be used as a dependency of
- * Comlink-powered hooks like `useManageFavorite`.
+ * Comlink-powered hooks like `useStudioWorkspacesByProjectIdDataset`.
  */
 export function useWindowConnection<
   TWindowMessage extends WindowMessage,

package/src/hooks/{agent → dashboard}/useAgentResourceContext.ts

@@ -36,7 +36,7 @@ export interface AgentResourceContextOptions {
  *
  * @example
  * ```tsx
- * import {useAgentResourceContext} from '@sanity/sdk-react'
+ * import {useAgentResourceContext} from '@sanity/sdk-react/dashboard'
  *
  * function MyComponent() {
  *   const documentId = 'my-document-id'

package/src/hooks/dashboard/useFavorite.test.tsx

@@ -0,0 +1,101 @@
+import {favorites, type FavoriteStatusResponse, type StateSource} from '@sanity/sdk'
+import {type FetcherSnapshot} from '@sanity/sdk/_internal'
+import {renderHook} from '@testing-library/react'
+import {type ReactNode} from 'react'
+import {BehaviorSubject} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {useFavorite} from './useFavorite'
+
+vi.mock(import('@sanity/sdk'), async (importOriginal) => {
+  const actual = await importOriginal()
+  return {
+    ...actual,
+    favorites: {
+      getState: vi.fn(),
+      resolveState: vi.fn(),
+      refetch: vi.fn(),
+    },
+  } as unknown as typeof actual
+})
+
+describe('useFavorite', () => {
+  let subject: BehaviorSubject<FavoriteStatusResponse>
+
+  const handle = {
+    documentId: 'mock-id',
+    documentType: 'mock-type',
+    resourceType: 'studio' as const,
+  }
+
+  const toSnapshot = (value: FavoriteStatusResponse): FetcherSnapshot<FavoriteStatusResponse> => ({
+    status: 'success',
+    data: value,
+    error: undefined,
+    isFetching: false,
+    dataUpdatedAt: 1,
+  })
+
+  const wrapper = ({children}: {children: ReactNode}) => (
+    <ResourceProvider projectId="test" dataset="test" fallback={null}>
+      {children}
+    </ResourceProvider>
+  )
+
+  beforeEach(() => {
+    subject = new BehaviorSubject<FavoriteStatusResponse>({isFavorited: false})
+    vi.mocked(favorites.getState).mockImplementation(
+      () =>
+        ({
+          subscribe: (callback?: () => void) => {
+            if (!callback) return () => {}
+            const subscription = subject.subscribe(() => callback())
+            callback()
+            return () => subscription.unsubscribe()
+          },
+          getCurrent: () => toSnapshot(subject.getValue()),
+          observable: subject.asObservable(),
+        }) as unknown as StateSource<FetcherSnapshot<FavoriteStatusResponse>>,
+    )
+  })
+
+  afterEach(() => {
+    subject.complete()
+    vi.clearAllMocks()
+  })
+
+  it('returns false when the document is not favorited', () => {
+    const {result} = renderHook(() => useFavorite(handle), {wrapper})
+    expect(result.current).toBe(false)
+  })
+
+  it('reflects the favorited status from the store', () => {
+    subject.next({isFavorited: true})
+    const {result} = renderHook(() => useFavorite(handle), {wrapper})
+    expect(result.current).toBe(true)
+  })
+
+  it('suspends until the favorite status is available', () => {
+    const pending: FetcherSnapshot<FavoriteStatusResponse> = {
+      status: 'pending',
+      data: undefined,
+      error: undefined,
+      isFetching: true,
+      dataUpdatedAt: undefined,
+    }
+    vi.mocked(favorites.getState).mockImplementation(
+      () =>
+        ({
+          subscribe: () => () => {},
+          getCurrent: () => pending,
+          observable: subject.asObservable(),
+        }) as unknown as StateSource<FetcherSnapshot<FavoriteStatusResponse>>,
+    )
+    vi.mocked(favorites.resolveState).mockReturnValue(new Promise(() => {}))
+    const {result} = renderHook(() => useFavorite(handle), {wrapper})
+    // Suspended on the initial fetch — the ResourceProvider fallback renders instead.
+    expect(result.current).toBeNull()
+    expect(favorites.resolveState).toHaveBeenCalled()
+  })
+})

package/src/hooks/dashboard/useFavorite.ts

@@ -0,0 +1,34 @@
+import {favorites} from '@sanity/sdk'
+
+import {createFetcherHook} from '../helpers/createFetcherHook'
+import {useFavoriteContext, type UseFavoriteProps} from './useFavoriteContext'
+
+const useFavoriteStatus = createFetcherHook(favorites)
+
+/**
+ * @internal
+ *
+ * Reads whether a document is currently favorited. The write-side counterpart is
+ * {@link useUpdateFavorite}.
+ *
+ * The hook suspends until the first favorite status resolves, so wrap the
+ * component in a `<Suspense>` boundary.
+ *
+ * @param props - The document handle plus the resource it lives in.
+ * @returns `true` when the document is favorited, otherwise `false`.
+ *
+ * @example
+ * ```tsx
+ * function FavoriteLabel(props: DocumentActionProps) {
+ *   const {documentId, documentType} = props
+ *   const isFavorited = useFavorite({documentId, documentType, resourceType: 'studio'})
+ *
+ *   return <span>{isFavorited ? 'Favorited' : 'Not favorited'}</span>
+ * }
+ * ```
+ */
+export function useFavorite(props: UseFavoriteProps): boolean {
+  const context = useFavoriteContext(props)
+  const {data} = useFavoriteStatus(context)
+  return data.isFavorited
+}

package/src/hooks/dashboard/useFavoriteContext.ts

@@ -0,0 +1,61 @@
+import {
+  type CanvasResource,
+  type MediaResource,
+  type StudioResource,
+} from '@sanity/message-protocol'
+import {type DocumentHandle, type FavoriteDocumentContext} from '@sanity/sdk'
+import {useMemo} from 'react'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+
+/**
+ * Props shared by {@link useFavorite} and {@link useUpdateFavorite}: a document
+ * handle plus the resource it lives in.
+ *
+ * @internal
+ */
+export interface UseFavoriteProps extends DocumentHandle {
+  resourceId?: string
+  resourceType: StudioResource['type'] | MediaResource['type'] | CanvasResource['type']
+  /**
+   * The name of the schema collection this document belongs to.
+   * Typically is the name of the workspace when used in the context of a studio.
+   */
+  schemaName?: string
+}
+
+/**
+ * Resolves {@link UseFavoriteProps} into the {@link FavoriteDocumentContext}
+ * shared by the favorites fetcher and mutation, defaulting a studio `resourceId`
+ * from the instance's project and dataset.
+ *
+ * @internal
+ */
+export function useFavoriteContext({
+  documentId,
+  documentType,
+  projectId: paramProjectId,
+  dataset: paramDataset,
+  resourceId: paramResourceId,
+  resourceType,
+  schemaName,
+}: UseFavoriteProps): FavoriteDocumentContext {
+  const {config} = useSanityInstance()
+  const projectId = paramProjectId ?? config?.projectId
+  const dataset = paramDataset ?? config?.dataset
+
+  if (resourceType === 'studio' && (!projectId || !dataset)) {
+    throw new Error('projectId and dataset are required for studio resources')
+  }
+  const resourceId =
+    resourceType === 'studio' && !paramResourceId ? `${projectId}.${dataset}` : paramResourceId
+
+  if (!resourceId) {
+    throw new Error('resourceId is required for media-library and canvas resources')
+  }
+
+  return useMemo(
+    () => ({documentId, documentType, resourceId, resourceType, schemaName}),
+    [documentId, documentType, resourceId, resourceType, schemaName],
+  )
+}

package/src/hooks/dashboard/{useDashboardNavigate.test.ts → useNavigate.test.ts}

@@ -2,7 +2,7 @@ import {type PathChangeMessage} from '@sanity/message-protocol'
 import {renderHook} from '@testing-library/react'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {useDashboardNavigate} from './useDashboardNavigate'
+import {useNavigate} from './useNavigate'
 
 const mockOnMessage = vi.fn()
 let mockMessageHandler: ((data: PathChangeMessage['data']) => void) | undefined
@@ -22,7 +22,7 @@ vi.mock('../comlink/useWindowConnection', () => {
   }
 })
 
-describe('useDashboardNavigate', () => {
+describe('useNavigate', () => {
   const mockNavigateFn = vi.fn()
 
   beforeEach(() => {
@@ -31,7 +31,7 @@ describe('useDashboardNavigate', () => {
   })
 
   it('calls navigate function with correct data when message is received', () => {
-    renderHook(() => useDashboardNavigate(mockNavigateFn))
+    renderHook(() => useNavigate(mockNavigateFn))
 
     const mockNavigationData = {
       path: '/test-path',

package/src/hooks/dashboard/{useDashboardNavigate.ts → useNavigate.ts}

@@ -21,13 +21,13 @@ import {useWindowConnection} from '../comlink/useWindowConnection'
  *
  * @example
  * ```tsx
- * import {useDashboardNavigate} from '@sanity/sdk-react'
- * import {BrowserRouter, useNavigate} from 'react-router'
+ * import {useNavigate} from '@sanity/sdk-react/dashboard'
+ * import {BrowserRouter, useNavigate as useRouterNavigate} from 'react-router'
  * import {Suspense} from 'react'
  *
  * function DashboardNavigationHandler() {
- *   const navigate = useNavigate()
- *   useDashboardNavigate(({path, type}) => {
+ *   const navigate = useRouterNavigate()
+ *   useNavigate(({path, type}) => {
  *     navigate(path, {replace: type === 'replace'})
  *   })
  *   return null
@@ -45,7 +45,7 @@ import {useWindowConnection} from '../comlink/useWindowConnection'
  * }
  * ```
  */
-export function useDashboardNavigate(
+export function useNavigate(
   navigateFn: (options: PathChangeMessage['data']) => void,
 ): void {
   useWindowConnection<PathChangeMessage, never>({

package/src/hooks/dashboard/useNavigateToStudioDocument.ts

@@ -36,7 +36,8 @@ export interface NavigateToStudioResult {
  *
  * @example
  * ```tsx
- * import {useNavigateToStudioDocument, type DocumentHandle} from '@sanity/sdk-react'
+ * import {type DocumentHandle} from '@sanity/sdk-react'
+ * import {useNavigateToStudioDocument} from '@sanity/sdk-react/dashboard'
  * import {Button} from '@sanity/ui'
  * import {Suspense} from 'react'
  *

package/src/hooks/{auth/useDashboardOrganizationId.test.tsx → dashboard/useOrganizationId.test.tsx}

@@ -4,14 +4,14 @@ import {throwError} from 'rxjs'
 import {describe, expect, it, vi} from 'vitest'
 
 import {ResourceProvider} from '../../context/ResourceProvider'
-import {useDashboardOrganizationId} from './useDashboardOrganizationId'
+import {useOrganizationId} from './useOrganizationId'
 
 vi.mock('@sanity/sdk', async (importOriginal) => {
   const actual = await importOriginal()
   return {...(actual || {}), getDashboardOrganizationId: vi.fn()}
 })
 
-describe('useDashboardOrganizationId', () => {
+describe('useOrganizationId', () => {
   it('should return undefined when no organization ID is set', () => {
     const subscribe = vi.fn()
     vi.mocked(getDashboardOrganizationId).mockReturnValue({
@@ -20,7 +20,7 @@ describe('useDashboardOrganizationId', () => {
       observable: throwError(() => new Error('Unexpected usage of observable')),
     })
 
-    const {result} = renderHook(() => useDashboardOrganizationId(), {
+    const {result} = renderHook(() => useOrganizationId(), {
       wrapper: ({children}) => (
         <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
@@ -39,7 +39,7 @@ describe('useDashboardOrganizationId', () => {
       observable: throwError(() => new Error('Unexpected usage of observable')),
     })
 
-    const {result} = renderHook(() => useDashboardOrganizationId(), {
+    const {result} = renderHook(() => useOrganizationId(), {
       wrapper: ({children}) => (
         <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}

package/src/hooks/{auth/useDashboardOrganizationId.tsx → dashboard/useOrganizationId.tsx}

@@ -11,7 +11,7 @@ import {useSanityInstance} from '../context/useSanityInstance'
  * @example
  * ```tsx
  * function DashboardComponent() {
- *   const orgId = useDashboardOrganizationId()
+ *   const orgId = useOrganizationId()
  *
  *   if (!orgId) return null
  *
@@ -22,7 +22,7 @@ import {useSanityInstance} from '../context/useSanityInstance'
  * @category Dashboard
  * @returns The dashboard organization ID (string | undefined)
  */
-export function useDashboardOrganizationId(): string | undefined {
+export function useOrganizationId(): string | undefined {
   const instance = useSanityInstance()
   const {subscribe, getCurrent} = useMemo(() => getDashboardOrganizationId(instance), [instance])
 

package/src/hooks/dashboard/useUpdateFavorite.test.tsx

@@ -0,0 +1,146 @@
+import {type FavoriteStatusResponse, setFavorite} from '@sanity/sdk'
+import {type MutationResult} from '@sanity/sdk/_internal'
+import {act, renderHook, waitFor} from '@testing-library/react'
+import {type ReactNode} from 'react'
+import {afterEach, beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
+
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {useUpdateFavorite} from './useUpdateFavorite'
+
+vi.mock(import('@sanity/sdk'), async (importOriginal) => {
+  const actual = await importOriginal()
+  return {
+    ...actual,
+    setFavorite: vi.fn(),
+  }
+})
+
+type SetFavorite = typeof setFavorite
+
+describe('useUpdateFavorite', () => {
+  const mockSetFavorite = setFavorite as Mock
+
+  const handle = {
+    documentId: 'mock-id',
+    documentType: 'mock-type',
+    resourceType: 'studio' as const,
+  }
+
+  const makeWrapper = (projectId?: string, dataset?: string) => {
+    return function Wrapper({children}: {children: ReactNode}) {
+      return (
+        <ResourceProvider projectId={projectId} dataset={dataset} fallback={null}>
+          {children}
+        </ResourceProvider>
+      )
+    }
+  }
+  const wrapper = makeWrapper('test', 'test')
+
+  beforeEach(() => {
+    mockSetFavorite.mockImplementation((async (_instance, input) => ({
+      data: {isFavorited: input.isFavorited},
+      invalidated: Promise.resolve(),
+    })) as SetFavorite)
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('sends the added event with the resolved studio resourceId', async () => {
+    const {result} = renderHook(() => useUpdateFavorite(handle), {wrapper})
+
+    await act(async () => {
+      await result.current.favorite()
+    })
+
+    expect(setFavorite).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        documentId: 'mock-id',
+        documentType: 'mock-type',
+        resourceId: 'test.test',
+        resourceType: 'studio',
+        isFavorited: true,
+      }),
+    )
+  })
+
+  it('sends the removed event when unfavoriting', async () => {
+    const {result} = renderHook(() => useUpdateFavorite(handle), {wrapper})
+
+    await act(async () => {
+      await result.current.unfavorite()
+    })
+
+    expect(setFavorite).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({isFavorited: false}),
+    )
+  })
+
+  it('passes schemaName through when provided', async () => {
+    const {result} = renderHook(() => useUpdateFavorite({...handle, schemaName: 'testSchema'}), {
+      wrapper,
+    })
+
+    await act(async () => {
+      await result.current.favorite()
+    })
+
+    expect(setFavorite).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({schemaName: 'testSchema', isFavorited: true}),
+    )
+  })
+
+  it('tracks isPending across the mutation lifecycle', async () => {
+    let resolveMutation!: (value: MutationResult<FavoriteStatusResponse>) => void
+    mockSetFavorite.mockReturnValue(
+      new Promise<MutationResult<FavoriteStatusResponse>>((resolve) => {
+        resolveMutation = resolve
+      }),
+    )
+
+    const {result} = renderHook(() => useUpdateFavorite(handle), {wrapper})
+    expect(result.current.isPending).toBe(false)
+
+    act(() => {
+      void result.current.favorite()
+    })
+    expect(result.current.isPending).toBe(true)
+
+    await act(async () => {
+      resolveMutation({data: {isFavorited: true}, invalidated: Promise.resolve()})
+    })
+    expect(result.current.isPending).toBe(false)
+  })
+
+  it('surfaces mutation failures on error', async () => {
+    mockSetFavorite.mockRejectedValue(new Error('mutate failed'))
+
+    const {result} = renderHook(() => useUpdateFavorite(handle), {wrapper})
+
+    await act(async () => {
+      await expect(result.current.favorite()).rejects.toThrow('mutate failed')
+    })
+
+    await waitFor(() => expect(result.current.error).toBeInstanceOf(Error))
+  })
+
+  it('throws when a studio resource is missing projectId or dataset', () => {
+    expect(() =>
+      renderHook(() => useUpdateFavorite(handle), {wrapper: makeWrapper(undefined, undefined)}),
+    ).toThrow('projectId and dataset are required for studio resources')
+  })
+
+  it('throws when resourceId is missing for non-studio resources', () => {
+    expect(() =>
+      renderHook(
+        () => useUpdateFavorite({...handle, resourceType: 'media-library', resourceId: undefined}),
+        {wrapper},
+      ),
+    ).toThrow('resourceId is required for media-library and canvas resources')
+  })
+})

package/src/hooks/dashboard/useUpdateFavorite.ts

@@ -0,0 +1,74 @@
+import {type FavoriteStatusResponse, setFavorite} from '@sanity/sdk'
+import {useCallback} from 'react'
+
+import {createMutationHook} from '../helpers/createMutationHook'
+import {useFavoriteContext, type UseFavoriteProps} from './useFavoriteContext'
+
+const useSetFavorite = createMutationHook(setFavorite)
+
+/**
+ * The value returned by {@link useUpdateFavorite}.
+ *
+ * @internal
+ */
+export interface UpdateFavorite {
+  /** Adds the document to favorites. */
+  favorite: () => Promise<FavoriteStatusResponse>
+  /** Removes the document from favorites. */
+  unfavorite: () => Promise<FavoriteStatusResponse>
+  /** A favorite or unfavorite mutation is currently in flight. */
+  isPending: boolean
+  /** The most recent failure; cleared by the next call or `reset`. */
+  error: unknown
+  /** Clears error and pending state back to idle. */
+  reset: () => void
+}
+
+/**
+ * @internal
+ *
+ * Adds or removes a document from favorites. The read-side counterpart is
+ * {@link useFavorite}, which reflects the change once the mutation settles.
+ *
+ * Unlike {@link useFavorite}, this hook does not suspend.
+ *
+ * @param props - The document handle plus the resource it lives in.
+ * @returns `favorite`/`unfavorite` actions and the `{isPending, error, reset}`
+ *   mutation state.
+ *
+ * @example
+ * ```tsx
+ * function FavoriteButton(props: DocumentActionProps) {
+ *   const {documentId, documentType} = props
+ *   const handle = {documentId, documentType, resourceType: 'studio'} as const
+ *   const isFavorited = useFavorite(handle)
+ *   const {favorite, unfavorite, isPending} = useUpdateFavorite(handle)
+ *
+ *   return (
+ *     <Button
+ *       disabled={isPending}
+ *       onClick={() => (isFavorited ? unfavorite() : favorite())}
+ *       text={isFavorited ? 'Remove from favorites' : 'Add to favorites'}
+ *     />
+ *   )
+ * }
+ *
+ * // Wrap the component with Suspense since useFavorite suspends
+ * function MyDocumentAction(props: DocumentActionProps) {
+ *   return (
+ *     <Suspense fallback={<Button text="Loading..." disabled />}>
+ *       <FavoriteButton {...props} />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
+ */
+export function useUpdateFavorite(props: UseFavoriteProps): UpdateFavorite {
+  const context = useFavoriteContext(props)
+  const {mutate, isPending, error, reset} = useSetFavorite()
+
+  const favorite = useCallback(() => mutate({...context, isFavorited: true}), [mutate, context])
+  const unfavorite = useCallback(() => mutate({...context, isFavorited: false}), [mutate, context])
+
+  return {favorite, unfavorite, isPending, error, reset}
+}

package/src/hooks/dashboard/useWindowTitle.ts

@@ -42,7 +42,7 @@ function resolveAppTitle(resource: ContextResource): string | undefined {
  *
  * @example
  * ```tsx
- * import {useWindowTitle} from '@sanity/sdk-react'
+ * import {useWindowTitle} from '@sanity/sdk-react/dashboard'
  *
  * function MoviesList() {
  *   useWindowTitle('Movies')