@sanity/sdk-react 2.8.0 → 3.0.0-rc.0

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

@@ -1,10 +1,16 @@
 import {type Message} from '@sanity/comlink'
-import {type FavoriteStatusResponse, getFavoritesState, resolveFavoritesState} from '@sanity/sdk'
-import {act, renderHook} from '@testing-library/react'
+import {
+  type FavoriteStatusResponse,
+  getFavoritesState,
+  resolveFavoritesState,
+  type SanityInstance,
+} from '@sanity/sdk'
 import {BehaviorSubject} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
+import {act, renderHook} from '../../../test/test-utils'
 import {ResourceProvider} from '../../context/ResourceProvider'
+import {useSanityInstance} from '../../hooks/context/useSanityInstance'
 import {useWindowConnection, type WindowConnection} from '../comlink/useWindowConnection'
 import {useManageFavorite} from './useManageFavorite'
 
@@ -21,6 +27,10 @@ vi.mock('../comlink/useWindowConnection', () => ({
   useWindowConnection: vi.fn(),
 }))
 
+vi.mock('../../hooks/context/useSanityInstance', () => ({
+  useSanityInstance: vi.fn(),
+}))
+
 describe('useManageFavorite', () => {
   let favoriteStatusSubject: BehaviorSubject<FavoriteStatusResponse>
   let mockFetch: ReturnType<typeof vi.fn>
@@ -30,6 +40,7 @@ describe('useManageFavorite', () => {
     documentId: 'mock-id',
     documentType: 'mock-type',
     resourceType: 'studio' as const,
+    resource: {projectId: 'test', dataset: 'test'},
   }
 
   beforeEach(() => {
@@ -67,31 +78,21 @@ describe('useManageFavorite', () => {
     })
   })
 
+  vi.mocked(useSanityInstance).mockImplementation(() => ({}) as unknown as SanityInstance)
+
   afterEach(() => {
     favoriteStatusSubject.complete()
     vi.clearAllMocks()
   })
 
   it('should initialize with default states', () => {
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
 
     expect(result.current.isFavorited).toBe(false)
   })
 
   it('should handle favorite action and update state', async () => {
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test" dataset="test" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
 
     expect(result.current.isFavorited).toBe(false)
 
@@ -120,13 +121,7 @@ describe('useManageFavorite', () => {
   })
 
   it('should handle unfavorite action and update state', async () => {
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test" dataset="test" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
 
     // Set initial state to favorited
     await act(async () => {
@@ -161,13 +156,7 @@ describe('useManageFavorite', () => {
   it('should not update state if favorite action fails', async () => {
     mockFetch.mockResolvedValueOnce({success: false})
 
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
 
     expect(result.current.isFavorited).toBe(false)
 
@@ -187,13 +176,7 @@ describe('useManageFavorite', () => {
       throw new Error(errorMessage)
     })
 
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
 
     await act(async () => {
       await expect(result.current.favorite()).rejects.toThrow(errorMessage)
@@ -210,7 +193,7 @@ describe('useManageFavorite', () => {
     consoleErrorSpy.mockRestore()
   })
 
-  it('should throw error when studio resource is missing projectId or dataset', () => {
+  it('should throw error when studio resource is missing resource', () => {
     const mockDocumentHandleWithoutProjectId = {
       documentId: 'mock-id',
       documentType: 'mock-type',
@@ -219,10 +202,8 @@ describe('useManageFavorite', () => {
 
     expect(() =>
       renderHook(() => useManageFavorite(mockDocumentHandleWithoutProjectId), {
-        wrapper: ({children}) => (
-          <ResourceProvider projectId={undefined} dataset={undefined} fallback={null}>
-            {children}
-          </ResourceProvider>
+        wrapper: ({children}: {children: React.ReactNode}) => (
+          <ResourceProvider fallback={null}>{children}</ResourceProvider>
         ),
       }),
     ).toThrow('projectId and dataset are required for studio resources')
@@ -234,17 +215,12 @@ describe('useManageFavorite', () => {
       documentType: 'mock-type',
       resourceType: 'media-library' as const,
       resourceId: undefined,
+      resource: {mediaLibraryId: 'media-library-id'},
     }
 
-    expect(() =>
-      renderHook(() => useManageFavorite(mockMediaDocumentHandle), {
-        wrapper: ({children}) => (
-          <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-            {children}
-          </ResourceProvider>
-        ),
-      }),
-    ).toThrow('resourceId is required for media-library and canvas resources')
+    expect(() => renderHook(() => useManageFavorite(mockMediaDocumentHandle))).toThrow(
+      'resourceId is required for media-library and canvas resources',
+    )
   })
 
   it('should include schemaName in payload when provided', async () => {
@@ -252,13 +228,7 @@ describe('useManageFavorite', () => {
       ...mockDocumentHandle,
       schemaName: 'testSchema',
     }
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandleWithSchema), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandleWithSchema))
 
     await act(async () => {
       await result.current.favorite()
@@ -271,7 +241,7 @@ describe('useManageFavorite', () => {
           id: 'mock-id',
           type: 'mock-type',
           resource: {
-            id: 'test-project.test-dataset',
+            id: 'test.test',
             type: 'studio',
             schemaName: 'testSchema',
           },
@@ -293,13 +263,7 @@ describe('useManageFavorite', () => {
       getCurrent: () => undefined,
       observable: favoriteStatusSubject.asObservable(),
     }))
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
     expect(result.current.isFavorited).toBe(false)
   })
 
@@ -308,13 +272,7 @@ describe('useManageFavorite', () => {
       fetch: undefined,
       sendMessage: mockSendMessage,
     } as unknown as WindowConnection<Message>)
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
     await act(async () => {
       await result.current.favorite()
       await result.current.unfavorite()
@@ -325,13 +283,7 @@ describe('useManageFavorite', () => {
   it('should do nothing if documentId is missing', async () => {
     const handle = {...mockDocumentHandle, documentId: undefined}
     // @ts-expect-error -- no access to ManageFavorite props type
-    const {result} = renderHook(() => useManageFavorite(handle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(handle))
     await act(async () => {
       await result.current.favorite()
       await result.current.unfavorite()
@@ -342,13 +294,7 @@ describe('useManageFavorite', () => {
   it('should do nothing if documentType is missing', async () => {
     const handle = {...mockDocumentHandle, documentType: undefined}
     // @ts-expect-error -- no access to ManageFavorite props type
-    const {result} = renderHook(() => useManageFavorite(handle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(handle))
     await act(async () => {
       await result.current.favorite()
       await result.current.unfavorite()
@@ -359,13 +305,7 @@ describe('useManageFavorite', () => {
   it('should do nothing if resourceType is missing', async () => {
     const handle = {...mockDocumentHandle, resourceType: undefined, resourceId: 'studio'}
     // @ts-expect-error -- no access to ManageFavorite props type
-    const {result} = renderHook(() => useManageFavorite(handle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useManageFavorite(handle))
     await act(async () => {
       await result.current.favorite()
       await result.current.unfavorite()

package/src/hooks/dashboard/useManageFavorite.ts

@@ -7,14 +7,16 @@ import {
   type StudioResource,
 } from '@sanity/message-protocol'
 import {
-  type DocumentHandle,
   type FavoriteStatusResponse,
   type FrameMessage,
   getFavoritesState,
+  isDatasetResource,
   resolveFavoritesState,
 } from '@sanity/sdk'
-import {useCallback, useMemo, useSyncExternalStore} from 'react'
+import {useCallback, useContext, useMemo, useSyncExternalStore} from 'react'
 
+import {type DocumentHandle} from '../../config/handles'
+import {ResourceContext} from '../../context/DefaultResourceContext'
 import {useWindowConnection} from '../comlink/useWindowConnection'
 import {useSanityInstance} from '../context/useSanityInstance'
 
@@ -82,8 +84,7 @@ interface UseManageFavoriteProps extends DocumentHandle {
 export function useManageFavorite({
   documentId,
   documentType,
-  projectId: paramProjectId,
-  dataset: paramDataset,
+  resource: paramResource,
   resourceId: paramResourceId,
   resourceType,
   schemaName,
@@ -93,11 +94,11 @@ export function useManageFavorite({
     connectTo: SDK_CHANNEL_NAME,
   })
   const instance = useSanityInstance()
-  const {config} = instance
-  const instanceProjectId = config?.projectId
-  const instanceDataset = config?.dataset
-  const projectId = paramProjectId ?? instanceProjectId
-  const dataset = paramDataset ?? instanceDataset
+  const contextResource = useContext(ResourceContext)
+  const resource = paramResource ?? contextResource
+  const datasetResource = resource && isDatasetResource(resource) ? resource : undefined
+  const projectId = datasetResource?.projectId
+  const dataset = datasetResource?.dataset
 
   if (resourceType === 'studio' && (!projectId || !dataset)) {
     throw new Error('projectId and dataset are required for studio resources')
@@ -110,16 +111,21 @@ export function useManageFavorite({
     throw new Error('resourceId is required for media-library and canvas resources')
   }
 
+  if (!resource) {
+    throw new Error('resource is required')
+  }
+
   // used for favoriteStore functions like getFavoritesState and resolveFavoritesState
   const context = useMemo(
     () => ({
       documentId,
       documentType,
+      resource,
       resourceId,
       resourceType,
       schemaName,
     }),
-    [documentId, documentType, resourceId, resourceType, schemaName],
+    [documentId, documentType, resource, resourceId, resourceType, schemaName],
   )
 
   // Get favorite status using StateSource

package/src/hooks/dashboard/useNavigateToStudioDocument.test.ts

@@ -33,8 +33,7 @@ describe('useNavigateToStudioDocument', () => {
   const mockDocumentHandle: DocumentHandle = {
     documentId: 'doc123',
     documentType: 'article',
-    projectId: 'project1',
-    dataset: 'dataset1',
+    resource: {projectId: 'project1', dataset: 'dataset1'},
   }
 
   const mockWorkspace = {
@@ -109,13 +108,13 @@ describe('useNavigateToStudioDocument', () => {
     consoleSpy.mockRestore()
   })
 
-  it('warns and does not navigate when projectId or dataset is missing', () => {
+  it('warns and does not navigate when resource is not a dataset resource', () => {
     const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
 
     const incompleteDocumentHandle: DocumentHandle = {
       documentId: 'doc123',
       documentType: 'article',
-      // missing projectId and dataset
+      resource: {mediaLibraryId: 'ml123'},
     }
 
     const {result} = renderHook(() => useNavigateToStudioDocument(incompleteDocumentHandle))
@@ -197,8 +196,11 @@ describe('useNavigateToStudioDocument', () => {
 
     result.current.navigateToStudioDocument()
 
+    const resource = mockDocumentHandle.resource
+    const projectId = 'projectId' in resource ? resource.projectId : undefined
+    const dataset = 'dataset' in resource ? resource.dataset : undefined
     expect(consoleSpy).toHaveBeenCalledWith(
-      `No workspace found for document with projectId: ${mockDocumentHandle.projectId} and dataset: ${mockDocumentHandle.dataset} or with preferred studio url: ${preferredUrl}`,
+      `No workspace found for document with projectId: ${projectId} and dataset: ${dataset} or with preferred studio url: ${preferredUrl}`,
     )
     expect(mockSendMessage).not.toHaveBeenCalled()
 

package/src/hooks/dashboard/useNavigateToStudioDocument.ts

@@ -1,7 +1,8 @@
 import {type Bridge, SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
-import {type DocumentHandle} from '@sanity/sdk'
+import {isDatasetResource} from '@sanity/sdk'
 import {useCallback} from 'react'
 
+import {type DocumentHandle} from '../../config/handles'
 import {useWindowConnection} from '../comlink/useWindowConnection'
 import {
   type DashboardResource,
@@ -71,7 +72,10 @@ export function useNavigateToStudioDocument(
   })
 
   const navigateToStudioDocument = useCallback(() => {
-    const {projectId, dataset} = documentHandle
+    const {resource} = documentHandle
+    const datasetResource = resource && isDatasetResource(resource) ? resource : undefined
+    const projectId = datasetResource?.projectId
+    const dataset = datasetResource?.dataset
 
     if (!projectId || !dataset) {
       // eslint-disable-next-line no-console

package/src/hooks/dashboard/useRecordDocumentHistoryEvent.test.ts

@@ -15,6 +15,7 @@ describe('useRecordDocumentHistoryEvent', () => {
     documentType: 'mock-type',
     resourceType: 'studio' as const,
     resourceId: 'mock-resource-id',
+    resource: {projectId: 'mock-project-id', dataset: 'mock-dataset'},
   }
 
   beforeEach(() => {
@@ -62,6 +63,7 @@ describe('useRecordDocumentHistoryEvent', () => {
       documentType: 'mock-type',
       resourceType: 'media-library' as const,
       resourceId: undefined,
+      resource: {mediaLibraryId: 'mock-media-library-id'},
     }
 
     expect(() => renderHook(() => useRecordDocumentHistoryEvent(mockMediaDocumentHandle))).toThrow(

package/src/hooks/dashboard/useRecordDocumentHistoryEvent.ts

@@ -6,9 +6,10 @@ import {
   SDK_NODE_NAME,
   type StudioResource,
 } from '@sanity/message-protocol'
-import {type DocumentHandle, type FrameMessage} from '@sanity/sdk'
+import {type FrameMessage} from '@sanity/sdk'
 import {useCallback} from 'react'
 
+import {type DocumentHandle} from '../../config/handles'
 import {useWindowConnection} from '../comlink/useWindowConnection'
 
 interface DocumentInteractionHistory {

package/src/hooks/dashboard/utils/useResourceIdFromDocumentHandle.test.ts

@@ -4,13 +4,12 @@ import {renderHook} from '../../../../test/test-utils'
 import {useResourceIdFromDocumentHandle} from './useResourceIdFromDocumentHandle'
 
 describe('getResourceIdFromDocumentHandle', () => {
-  describe('with traditional DocumentHandle (projectId/dataset)', () => {
-    it('should return resource ID from projectId and dataset', () => {
+  describe('with DocumentHandle using resource object', () => {
+    it('should return resource ID from resource object with projectId and dataset', () => {
       const documentHandle = {
         documentId: 'test-document-id',
         documentType: 'test-document-type',
-        projectId: 'test-project-id',
-        dataset: 'test-dataset',
+        resource: {projectId: 'test-project-id', dataset: 'test-dataset'},
       }
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
@@ -22,12 +21,12 @@ describe('getResourceIdFromDocumentHandle', () => {
     })
   })
 
-  describe('with DocumentHandleWithSource - media library', () => {
-    it('should return media library ID and resourceType when media library source is provided', () => {
+  describe('with DocumentHandle - media library resource', () => {
+    it('should return media library ID and resourceType when media library resource is provided', () => {
       const documentHandle = {
         documentId: 'test-asset-id',
         documentType: 'sanity.asset',
-        sourceName: 'media-library',
+        resourceName: 'media-library',
       } as const
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
@@ -38,13 +37,11 @@ describe('getResourceIdFromDocumentHandle', () => {
       })
     })
 
-    it('should prioritize source over projectId/dataset when both are provided', () => {
+    it('should use resourceName when provided', () => {
       const documentHandle = {
         documentId: 'test-asset-id',
         documentType: 'sanity.asset',
-        projectId: 'test-project-id',
-        dataset: 'test-dataset',
-        sourceName: 'media-library',
+        resourceName: 'media-library',
       }
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
@@ -56,12 +53,12 @@ describe('getResourceIdFromDocumentHandle', () => {
     })
   })
 
-  describe('with DocumentHandleWithSource - canvas', () => {
-    it('should return canvas ID and resourceType when canvas source is provided', () => {
+  describe('with DocumentHandle - canvas resource', () => {
+    it('should return canvas ID and resourceType when canvas resource is provided', () => {
       const documentHandle = {
         documentId: 'test-canvas-document-id',
         documentType: 'sanity.canvas.document',
-        sourceName: 'canvas',
+        resourceName: 'canvas',
       }
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
@@ -73,29 +70,12 @@ describe('getResourceIdFromDocumentHandle', () => {
     })
   })
 
-  describe('with DocumentHandleWithSource - dataset source', () => {
-    it('should return dataset resource ID when dataset source is provided', () => {
+  describe('with DocumentHandle - dataset resource', () => {
+    it('should return dataset resource ID when dataset resource is provided', () => {
       const documentHandle = {
         documentId: 'test-document-id',
         documentType: 'test-document-type',
-        sourceName: 'dataset',
-      }
-
-      const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
-
-      expect(result.current).toEqual({
-        id: 'source-project-id.source-dataset',
-        type: undefined,
-      })
-    })
-
-    it('should use dataset source over projectId/dataset when both are provided', () => {
-      const documentHandle = {
-        documentId: 'test-document-id',
-        documentType: 'test-document-type',
-        projectId: 'test-project-id',
-        dataset: 'test-dataset',
-        sourceName: 'dataset',
+        resourceName: 'dataset',
       }
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
@@ -108,13 +88,12 @@ describe('getResourceIdFromDocumentHandle', () => {
   })
 
   describe('edge cases', () => {
-    it('should handle DocumentHandleWithSource with undefined source', () => {
+    it('should handle DocumentHandle with explicit resource and no resourceName', () => {
       const documentHandle = {
         documentId: 'test-document-id',
         documentType: 'test-document-type',
-        projectId: 'test-project-id',
-        dataset: 'test-dataset',
-        sourceName: undefined,
+        resource: {projectId: 'test-project-id', dataset: 'test-dataset'},
+        resourceName: undefined,
       }
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))

package/src/hooks/dashboard/utils/useResourceIdFromDocumentHandle.ts

@@ -1,11 +1,7 @@
-import {
-  type DocumentHandle,
-  isCanvasSource,
-  isDatasetSource,
-  isMediaLibrarySource,
-} from '@sanity/sdk'
+import {isCanvasResource, isDatasetResource, isMediaLibraryResource} from '@sanity/sdk'
 
-import {useNormalizedSourceOptions} from '../../helpers/useNormalizedSourceOptions'
+import {type DocumentHandle} from '../../../config/handles'
+import {useNormalizedResourceOptions} from '../../helpers/useNormalizedResourceOptions'
 
 interface DashboardMessageResource {
   id: string
@@ -18,23 +14,20 @@ interface DashboardMessageResource {
 export function useResourceIdFromDocumentHandle(
   documentHandle: DocumentHandle,
 ): DashboardMessageResource {
-  const options = useNormalizedSourceOptions(documentHandle)
-  const {projectId, dataset, source} = options
+  const options = useNormalizedResourceOptions(documentHandle)
+  const {resource} = options
   let resourceId: string = ''
   let resourceType: 'media-library' | 'canvas' | undefined
-  if (projectId && dataset) {
-    resourceId = `${projectId}.${dataset}`
-  }
 
-  if (source) {
-    if (isDatasetSource(source)) {
-      resourceId = `${source.projectId}.${source.dataset}`
+  if (resource) {
+    if (isDatasetResource(resource)) {
+      resourceId = `${resource.projectId}.${resource.dataset}`
       resourceType = undefined
-    } else if (isMediaLibrarySource(source)) {
-      resourceId = source.mediaLibraryId
+    } else if (isMediaLibraryResource(resource)) {
+      resourceId = resource.mediaLibraryId
       resourceType = 'media-library'
-    } else if (isCanvasSource(source)) {
-      resourceId = source.canvasId
+    } else if (isCanvasResource(resource)) {
+      resourceId = resource.canvasId
       resourceType = 'canvas'
     }
   }

package/src/hooks/datasets/useDatasets.test.ts

@@ -1,4 +1,4 @@
-import {getDatasetsState, type ProjectHandle, type SanityInstance} from '@sanity/sdk'
+import {getDatasetsState, type SanityInstance} from '@sanity/sdk'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
@@ -6,7 +6,7 @@ import {createStateSourceHook} from '../helpers/createStateSourceHook'
 // Mock dependencies
 vi.mock('@sanity/sdk', () => ({
   getDatasetsState: vi.fn(() => ({
-    getCurrent: vi.fn(() => undefined), // Mocking getCurrent to satisfy the call within shouldSuspend
+    getCurrent: vi.fn(() => undefined),
   })),
   resolveDatasets: vi.fn(),
 }))
@@ -15,10 +15,8 @@ vi.mock('../helpers/createStateSourceHook', () => ({
 }))
 
 describe('useDatasets', () => {
-  // Use beforeEach to reset modules and ensure mocks are fresh for each test
   beforeEach(() => {
     vi.resetModules()
-    // Re-mock dependencies for each test after resetModules
     vi.mock('@sanity/sdk', () => ({
       getDatasetsState: vi.fn(() => ({
         getCurrent: vi.fn(() => undefined),
@@ -31,50 +29,38 @@ describe('useDatasets', () => {
   })
 
   it('should call createStateSourceHook with correct arguments on import', async () => {
-    // Dynamically import the hook *after* mocks are set up and modules reset
     await import('./useDatasets')
 
-    // Check if createStateSourceHook was called during the module evaluation (import)
     expect(createStateSourceHook).toHaveBeenCalled()
     expect(createStateSourceHook).toHaveBeenCalledWith(
       expect.objectContaining({
         getState: expect.any(Function),
         shouldSuspend: expect.any(Function),
-        suspender: expect.any(Function), // Actual function reference doesn't matter here as it's mocked
-        getConfig: expect.any(Function), // Actual function reference doesn't matter here
+        suspender: expect.any(Function),
       }),
     )
   })
 
   it('shouldSuspend should call getDatasetsState and getCurrent', async () => {
-    // Dynamically import the hook *after* mocks are set up and modules reset
     await import('./useDatasets')
 
-    // Get the arguments passed to createStateSourceHook
-    // Need to ensure createStateSourceHook mock is correctly typed for access
     const mockCreateStateSourceHook = createStateSourceHook as ReturnType<typeof vi.fn>
     expect(mockCreateStateSourceHook.mock.calls.length).toBeGreaterThan(0)
     const createStateSourceHookArgs = mockCreateStateSourceHook.mock.calls[0][0]
     const shouldSuspend = createStateSourceHookArgs.shouldSuspend
 
-    // Mock instance and projectHandle for the test call
-    const mockInstance = {} as SanityInstance // Use specific type
-    const mockProjectHandle = {} as ProjectHandle // Use specific type
+    const mockInstance = {} as SanityInstance
+    const mockOptions = {projectId: 'test-project'}
 
-    // Call the shouldSuspend function
-    const result = shouldSuspend(mockInstance, mockProjectHandle)
+    const result = shouldSuspend(mockInstance, mockOptions)
 
-    // Assert that getDatasetsState was called with the correct arguments
-    // Need to ensure getDatasetsState mock is correctly typed for access
     const mockGetDatasetsState = getDatasetsState as ReturnType<typeof vi.fn>
-    expect(mockGetDatasetsState).toHaveBeenCalledWith(mockInstance, mockProjectHandle)
+    expect(mockGetDatasetsState).toHaveBeenCalledWith(mockInstance, mockOptions)
 
-    // Assert that getCurrent was called on the result of getDatasetsState
     expect(mockGetDatasetsState.mock.results.length).toBeGreaterThan(0)
     const getDatasetsStateMockResult = mockGetDatasetsState.mock.results[0].value
     expect(getDatasetsStateMockResult.getCurrent).toHaveBeenCalled()
 
-    // Assert the result of shouldSuspend based on the mocked getCurrent value
-    expect(result).toBe(true) // Since getCurrent is mocked to return undefined
+    expect(result).toBe(true)
   })
 })