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

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

@@ -1,107 +0,0 @@
-import {describe, expect, it} from 'vitest'
-
-import {renderHook} from '../../../../test/test-utils'
-import {useResourceIdFromDocumentHandle} from './useResourceIdFromDocumentHandle'
-
-describe('getResourceIdFromDocumentHandle', () => {
-  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',
-        resource: {projectId: 'test-project-id', dataset: 'test-dataset'},
-      }
-
-      const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
-
-      expect(result.current).toEqual({
-        id: 'test-project-id.test-dataset',
-        type: undefined,
-      })
-    })
-  })
-
-  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',
-        resourceName: 'media-library',
-      } as const
-
-      const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
-
-      expect(result.current).toEqual({
-        id: 'media-library-id',
-        type: 'media-library',
-      })
-    })
-
-    it('should use resourceName when provided', () => {
-      const documentHandle = {
-        documentId: 'test-asset-id',
-        documentType: 'sanity.asset',
-        resourceName: 'media-library',
-      }
-
-      const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
-
-      expect(result.current).toEqual({
-        id: 'media-library-id',
-        type: 'media-library',
-      })
-    })
-  })
-
-  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',
-        resourceName: 'canvas',
-      }
-
-      const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
-
-      expect(result.current).toEqual({
-        id: 'canvas-id',
-        type: 'canvas',
-      })
-    })
-  })
-
-  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',
-        resourceName: 'dataset',
-      }
-
-      const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
-
-      expect(result.current).toEqual({
-        id: 'source-project-id.source-dataset',
-        type: undefined,
-      })
-    })
-  })
-
-  describe('edge cases', () => {
-    it('should handle DocumentHandle with explicit resource and no resourceName', () => {
-      const documentHandle = {
-        documentId: 'test-document-id',
-        documentType: 'test-document-type',
-        resource: {projectId: 'test-project-id', dataset: 'test-dataset'},
-        resourceName: undefined,
-      }
-
-      const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
-
-      expect(result.current).toEqual({
-        id: 'test-project-id.test-dataset',
-        type: undefined,
-      })
-    })
-  })
-})

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

@@ -1,39 +0,0 @@
-import {isCanvasResource, isDatasetResource, isMediaLibraryResource} from '@sanity/sdk'
-
-import {type DocumentHandle} from '../../../config/handles'
-import {useNormalizedResourceOptions} from '../../helpers/useNormalizedResourceOptions'
-
-interface DashboardMessageResource {
-  id: string
-  type?: 'media-library' | 'canvas'
-}
-/** Currently only used for dispatching intents to the dashboard,
- * but could easily be extended to other dashboard hooks
- * @beta
- */
-export function useResourceIdFromDocumentHandle(
-  documentHandle: DocumentHandle,
-): DashboardMessageResource {
-  const options = useNormalizedResourceOptions(documentHandle)
-  const {resource} = options
-  let resourceId: string = ''
-  let resourceType: 'media-library' | 'canvas' | undefined
-
-  if (resource) {
-    if (isDatasetResource(resource)) {
-      resourceId = `${resource.projectId}.${resource.dataset}`
-      resourceType = undefined
-    } else if (isMediaLibraryResource(resource)) {
-      resourceId = resource.mediaLibraryId
-      resourceType = 'media-library'
-    } else if (isCanvasResource(resource)) {
-      resourceId = resource.canvasId
-      resourceType = 'canvas'
-    }
-  }
-
-  return {
-    id: resourceId,
-    type: resourceType,
-  }
-}

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

@@ -1,66 +0,0 @@
-import {getDatasetsState, type SanityInstance} from '@sanity/sdk'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
-
-// Mock dependencies
-vi.mock('@sanity/sdk', () => ({
-  getDatasetsState: vi.fn(() => ({
-    getCurrent: vi.fn(() => undefined),
-  })),
-  resolveDatasets: vi.fn(),
-}))
-vi.mock('../helpers/createStateSourceHook', () => ({
-  createStateSourceHook: vi.fn(),
-}))
-
-describe('useDatasets', () => {
-  beforeEach(() => {
-    vi.resetModules()
-    vi.mock('@sanity/sdk', () => ({
-      getDatasetsState: vi.fn(() => ({
-        getCurrent: vi.fn(() => undefined),
-      })),
-      resolveDatasets: vi.fn(),
-    }))
-    vi.mock('../helpers/createStateSourceHook', () => ({
-      createStateSourceHook: vi.fn(),
-    }))
-  })
-
-  it('should call createStateSourceHook with correct arguments on import', async () => {
-    await import('./useDatasets')
-
-    expect(createStateSourceHook).toHaveBeenCalled()
-    expect(createStateSourceHook).toHaveBeenCalledWith(
-      expect.objectContaining({
-        getState: expect.any(Function),
-        shouldSuspend: expect.any(Function),
-        suspender: expect.any(Function),
-      }),
-    )
-  })
-
-  it('shouldSuspend should call getDatasetsState and getCurrent', async () => {
-    await import('./useDatasets')
-
-    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
-
-    const mockInstance = {} as SanityInstance
-    const mockOptions = {projectId: 'test-project'}
-
-    const result = shouldSuspend(mockInstance, mockOptions)
-
-    const mockGetDatasetsState = getDatasetsState as ReturnType<typeof vi.fn>
-    expect(mockGetDatasetsState).toHaveBeenCalledWith(mockInstance, mockOptions)
-
-    expect(mockGetDatasetsState.mock.results.length).toBeGreaterThan(0)
-    const getDatasetsStateMockResult = mockGetDatasetsState.mock.results[0].value
-    expect(getDatasetsStateMockResult.getCurrent).toHaveBeenCalled()
-
-    expect(result).toBe(true)
-  })
-})

package/src/hooks/helpers/useNormalizedResourceOptions.test.ts

@@ -1,65 +0,0 @@
-import {describe, expect, it} from 'vitest'
-
-import {normalizeResourceOptions} from './useNormalizedResourceOptions'
-
-describe('normalizeResourceOptions', () => {
-  it('throws when both resource and resourceName are provided together', () => {
-    const resource = {projectId: 'p', dataset: 'd'}
-
-    expect(() =>
-      normalizeResourceOptions(
-        {resource, resourceName: 'my-resource'},
-        {'my-resource': resource},
-        undefined,
-      ),
-    ).toThrow(/cannot be used together/)
-  })
-
-  it('throws when no resource can be resolved from any source', () => {
-    expect(() =>
-      normalizeResourceOptions(
-        {},
-        {}, // no named resources
-        undefined, // no context resource
-      ),
-    ).toThrow(/resource is required/)
-  })
-
-  it('uses explicit resource when provided', () => {
-    const resource = {projectId: 'project-a', dataset: 'staging'}
-
-    const normalized = normalizeResourceOptions(
-      {resource},
-      {},
-      {projectId: 'default', dataset: 'prod'},
-    )
-
-    expect(normalized).toEqual({resource: {projectId: 'project-a', dataset: 'staging'}})
-  })
-
-  it('resolves resource from resourceName', () => {
-    const resource = {projectId: 'p', dataset: 'd'}
-
-    const normalized = normalizeResourceOptions(
-      {resourceName: 'my-resource'},
-      {'my-resource': resource},
-      undefined,
-    )
-
-    expect(normalized).toEqual({resource})
-  })
-
-  it('throws when resourceName is not found in resources map', () => {
-    expect(() => normalizeResourceOptions({resourceName: 'missing'}, {}, undefined)).toThrow(
-      /no resource named/,
-    )
-  })
-
-  it('falls back to context resource when neither resource nor resourceName is provided', () => {
-    const contextResource = {projectId: 'default', dataset: 'prod'}
-
-    const normalized = normalizeResourceOptions({}, {}, contextResource)
-
-    expect(normalized).toEqual({resource: contextResource})
-  })
-})

package/src/hooks/projects/useProject.test.ts

@@ -1,79 +0,0 @@
-import {getProjectState, type ProjectHandle, type SanityInstance} from '@sanity/sdk'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
-
-// Mock dependencies
-vi.mock('@sanity/sdk', () => ({
-  getProjectState: vi.fn(() => ({
-    getCurrent: vi.fn(() => undefined), // Mocking getCurrent to satisfy the call within shouldSuspend
-  })),
-  resolveProject: vi.fn(),
-}))
-vi.mock('../helpers/createStateSourceHook', () => ({
-  createStateSourceHook: vi.fn(),
-}))
-
-describe('useProject', () => {
-  // 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', () => ({
-      getProjectState: vi.fn(() => ({
-        getCurrent: vi.fn(() => undefined),
-      })),
-      resolveProject: vi.fn(),
-    }))
-    vi.mock('../helpers/createStateSourceHook', () => ({
-      createStateSourceHook: vi.fn(),
-    }))
-  })
-
-  it('should call createStateSourceHook with correct arguments on import', async () => {
-    // Dynamically import the hook *after* mocks are set up and modules reset
-    await import('./useProject')
-
-    // 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),
-      }),
-    )
-  })
-
-  it('shouldSuspend should call getProjectState and getCurrent', async () => {
-    // Dynamically import the hook *after* mocks are set up and modules reset
-    await import('./useProject')
-
-    // 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
-
-    // Call the shouldSuspend function
-    const result = shouldSuspend(mockInstance, mockProjectHandle)
-
-    // Assert that getProjectState was called with the correct arguments
-    // Need to ensure getProjectState mock is correctly typed for access
-    const mockGetProjectState = getProjectState as ReturnType<typeof vi.fn>
-    expect(mockGetProjectState).toHaveBeenCalledWith(mockInstance, mockProjectHandle)
-
-    // Assert that getCurrent was called on the result of getProjectState
-    expect(mockGetProjectState.mock.results.length).toBeGreaterThan(0)
-    const getProjectStateMockResult = mockGetProjectState.mock.results[0].value
-    expect(getProjectStateMockResult.getCurrent).toHaveBeenCalled()
-
-    // Assert the result of shouldSuspend based on the mocked getCurrent value
-    expect(result).toBe(true) // Since getCurrent is mocked to return undefined
-  })
-})