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

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

@@ -1,254 +0,0 @@
-import {type DocumentHandle} from '@sanity/sdk'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {renderHook} from '../../../test/test-utils'
-import {useDispatchIntent} from './useDispatchIntent'
-
-// Mock the useWindowConnection hook
-const mockSendMessage = vi.fn()
-vi.mock('../comlink/useWindowConnection', () => ({
-  useWindowConnection: vi.fn(() => ({
-    sendMessage: mockSendMessage,
-  })),
-}))
-
-describe('useDispatchIntent', () => {
-  const mockDocumentHandle: DocumentHandle = {
-    documentId: 'test-document-id',
-    documentType: 'test-document-type',
-    resource: {projectId: 'test-project-id', dataset: 'test-dataset'},
-  }
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    // Reset mock implementation to default behavior
-    mockSendMessage.mockImplementation(() => {})
-  })
-
-  it('should return dispatchIntent function', () => {
-    const {result} = renderHook(() =>
-      useDispatchIntent({action: 'edit', documentHandle: mockDocumentHandle}),
-    )
-
-    expect(result.current).toEqual({
-      dispatchIntent: expect.any(Function),
-    })
-  })
-
-  it('should throw error when neither action nor intentId is provided', () => {
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-    const {result} = renderHook(() => useDispatchIntent({documentHandle: mockDocumentHandle}))
-
-    expect(() => result.current.dispatchIntent()).toThrow(
-      'useDispatchIntent: Either `action` or `intentId` must be provided.',
-    )
-    consoleErrorSpy.mockRestore()
-  })
-
-  it('should handle errors gracefully', () => {
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-    mockSendMessage.mockImplementation(() => {
-      throw new Error('Test error')
-    })
-
-    const {result} = renderHook(() =>
-      useDispatchIntent({action: 'edit', documentHandle: mockDocumentHandle}),
-    )
-
-    expect(() => result.current.dispatchIntent()).toThrow('Test error')
-    expect(consoleErrorSpy).toHaveBeenCalledWith('Failed to dispatch intent:', expect.any(Error))
-
-    consoleErrorSpy.mockRestore()
-  })
-
-  it('should use memoized dispatchIntent function', () => {
-    const params = {action: 'edit' as const, documentHandle: mockDocumentHandle}
-    const {result, rerender} = renderHook(
-      ({params: hookParams}: {params: typeof params}) => useDispatchIntent(hookParams),
-      {
-        initialProps: {params},
-      },
-    )
-
-    const firstDispatchIntent = result.current.dispatchIntent
-
-    // Rerender with the same params
-    rerender({params: {action: 'edit' as const, documentHandle: mockDocumentHandle}})
-
-    expect(result.current.dispatchIntent).toBe(firstDispatchIntent)
-  })
-
-  it('should create new dispatchIntent function when documentHandle changes', () => {
-    const {result, rerender} = renderHook(
-      (params: {action: 'edit'; documentHandle: DocumentHandle}) => useDispatchIntent(params),
-      {
-        initialProps: {action: 'edit' as const, documentHandle: mockDocumentHandle},
-      },
-    )
-
-    const firstDispatchIntent = result.current.dispatchIntent
-
-    const newDocumentHandle: DocumentHandle = {
-      documentId: 'new-document-id',
-      documentType: 'new-document-type',
-      resource: {projectId: 'new-project-id', dataset: 'new-dataset'},
-    }
-
-    rerender({action: 'edit' as const, documentHandle: newDocumentHandle})
-
-    expect(result.current.dispatchIntent).not.toBe(firstDispatchIntent)
-  })
-
-  it('should warn if both action and intentId are provided', () => {
-    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    const {result} = renderHook(() =>
-      useDispatchIntent({
-        action: 'edit' as const,
-        intentId: 'custom-intent' as never, // test runtime error when both are provided
-        documentHandle: mockDocumentHandle,
-      }),
-    )
-    result.current.dispatchIntent()
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      'useDispatchIntent: Both `action` and `intentId` were provided. Using `intentId` and ignoring `action`.',
-    )
-    consoleWarnSpy.mockRestore()
-  })
-
-  it('should send intent message with action and params when both are provided', () => {
-    const intentParams = {view: 'editor', tab: 'content'}
-    const {result} = renderHook(() =>
-      useDispatchIntent({
-        action: 'edit',
-        documentHandle: mockDocumentHandle,
-        parameters: intentParams,
-      }),
-    )
-
-    result.current.dispatchIntent()
-
-    expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
-      action: 'edit',
-      document: {
-        id: 'test-document-id',
-        type: 'test-document-type',
-      },
-      resource: {
-        id: 'test-project-id.test-dataset',
-      },
-      parameters: intentParams,
-    })
-  })
-
-  it('should send intent message with intentId and params when both are provided', () => {
-    const intentParams = {view: 'editor', tab: 'content'}
-    const {result} = renderHook(() =>
-      useDispatchIntent({
-        intentId: 'custom-intent',
-        documentHandle: mockDocumentHandle,
-        parameters: intentParams,
-      }),
-    )
-
-    result.current.dispatchIntent()
-
-    expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
-      intentId: 'custom-intent',
-      document: {
-        id: 'test-document-id',
-        type: 'test-document-type',
-      },
-      resource: {
-        id: 'test-project-id.test-dataset',
-      },
-      parameters: intentParams,
-    })
-  })
-
-  it('should send intent message with media library resource', () => {
-    const mockMediaLibraryHandle = {
-      documentId: 'test-asset-id',
-      documentType: 'sanity.asset',
-      resourceName: 'media-library',
-    } as const
-
-    const {result} = renderHook(() =>
-      useDispatchIntent({
-        action: 'edit',
-        documentHandle: mockMediaLibraryHandle,
-      }),
-    )
-
-    result.current.dispatchIntent()
-
-    expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
-      action: 'edit',
-      document: {
-        id: 'test-asset-id',
-        type: 'sanity.asset',
-      },
-      resource: {
-        id: 'media-library-id',
-        type: 'media-library',
-      },
-    })
-  })
-
-  it('should send intent message with canvas resource', () => {
-    const mockCanvasHandle = {
-      documentId: 'test-canvas-document-id',
-      documentType: 'sanity.canvas.document',
-      resourceName: 'canvas',
-    } as const
-
-    const {result} = renderHook(() =>
-      useDispatchIntent({
-        action: 'edit',
-        documentHandle: mockCanvasHandle,
-      }),
-    )
-
-    result.current.dispatchIntent()
-
-    expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
-      action: 'edit',
-      document: {
-        id: 'test-canvas-document-id',
-        type: 'sanity.canvas.document',
-      },
-      resource: {
-        id: 'canvas-id',
-        type: 'canvas',
-      },
-    })
-  })
-
-  describe('default resource fallback', () => {
-    it('should use default resource from context when handle has no explicit targeting', () => {
-      const minimalHandle = {
-        documentId: 'test-document-id',
-        documentType: 'test-document-type',
-      }
-
-      const {result} = renderHook(() =>
-        useDispatchIntent({
-          action: 'edit',
-          documentHandle: minimalHandle as unknown as DocumentHandle,
-        }),
-      )
-
-      result.current.dispatchIntent()
-
-      expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
-        action: 'edit',
-        document: {
-          id: 'test-document-id',
-          type: 'test-document-type',
-        },
-        resource: {
-          id: 'test.test',
-        },
-      })
-    })
-  })
-})

package/src/hooks/dashboard/useDispatchIntent.ts

@@ -1,157 +0,0 @@
-import {SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
-import {type FrameMessage} from '@sanity/sdk'
-import {useCallback} from 'react'
-
-import {type DocumentHandle} from '../../config/handles'
-import {useWindowConnection} from '../comlink/useWindowConnection'
-import {useResourceIdFromDocumentHandle} from './utils/useResourceIdFromDocumentHandle'
-
-/**
- * Message type for sending intents to the dashboard
- * @beta
- */
-interface IntentMessage {
-  type: 'dashboard/v1/events/intents/dispatch-intent'
-  data: {
-    action?: 'edit'
-    intentId?: string
-    document: {
-      id: string
-      type: string
-    }
-    resource?: {
-      id: string
-      type?: 'media-library' | 'canvas'
-    }
-    parameters?: Record<string, unknown>
-  }
-}
-
-/**
- * Return type for the useDispatchIntent hook
- * @beta
- */
-interface DispatchIntent {
-  dispatchIntent: () => void
-}
-
-/**
- * Parameters for the useDispatchIntent hook
- * @beta
- */
-interface UseDispatchIntentParams {
-  action?: 'edit'
-  intentId?: string
-  documentHandle: DocumentHandle
-  parameters?: Record<string, unknown>
-}
-
-/**
- * @beta
- *
- * A hook for dispatching intent messages to the Dashboard with a document handle.
- * This allows applications to signal their intent to pass the referenced document to other applications that have registered the ability to perform specific actions on that document.
- *
- * @param params - Object containing:
- *   - `action` - Action to perform (currently only 'edit' is supported). Will prompt a picker if multiple handlers are available.
- *   - `intentId` - Specific ID of the intent to dispatch. Either `action` or `intentId` is required.
- *   - `documentHandle` - The document handle containing document ID, type, and either:
- *     - `projectId` and `dataset` for traditional dataset resources, like `{documentId: '123', documentType: 'book', projectId: 'abc123', dataset: 'production'}`
- *     - `resource` for media library, canvas, or dataset resources, like `{documentId: '123', documentType: 'sanity.asset', resource: mediaLibraryResource('ml123')}` or `{documentId: '123', documentType: 'sanity.canvas.document', resource: canvasResource('canvas123')}`
- *   - `paremeters` - Optional parameters to include in the dispatch; will be passed to the resolved intent handler
- * @returns An object containing:
- * - `dispatchIntent` - Function to dispatch the intent message
- *
- * @example
- * ```tsx
- * import {useDispatchIntent} from '@sanity/sdk-react'
- * import {Button} from '@sanity/ui'
- * import {Suspense} from 'react'
- *
- * function DispatchIntentButton({documentId, documentType, projectId, dataset}) {
- *   const {dispatchIntent} = useDispatchIntent({
- *     action: 'edit',
- *     documentHandle: {documentId, documentType, projectId, dataset},
- *   })
- *
- *   return (
- *     <Button
- *       onClick={() => dispatchIntent()}
- *       text="Dispatch Intent"
- *     />
- *   )
- * }
- *
- * // Wrap the component with Suspense since the hook may suspend
- * function MyDocumentAction({documentId, documentType, projectId, dataset}) {
- *   return (
- *     <Suspense fallback={<Button text="Loading..." disabled />}>
- *       <DispatchIntentButton
- *         documentId={documentId}
- *         documentType={documentType}
- *         projectId={projectId}
- *         dataset={dataset}
- *       />
- *     </Suspense>
- *   )
- * }
- * ```
- */
-export function useDispatchIntent(params: UseDispatchIntentParams): DispatchIntent {
-  const {action, intentId, documentHandle, parameters} = params
-  const {sendMessage} = useWindowConnection<IntentMessage, FrameMessage>({
-    name: SDK_NODE_NAME,
-    connectTo: SDK_CHANNEL_NAME,
-  })
-
-  const resource = useResourceIdFromDocumentHandle(documentHandle)
-
-  const dispatchIntent = useCallback(() => {
-    try {
-      if (!action && !intentId) {
-        throw new Error('useDispatchIntent: Either `action` or `intentId` must be provided.')
-      }
-
-      if (action && intentId) {
-        // eslint-disable-next-line no-console -- warn if both action and intentId are provided
-        console.warn(
-          'useDispatchIntent: Both `action` and `intentId` were provided. Using `intentId` and ignoring `action`.',
-        )
-      }
-
-      // Validate that we have a resource ID (which is computed from resource/resourceName or projectId+dataset)
-      if (!resource.id) {
-        throw new Error(
-          'useDispatchIntent: Unable to determine resource. Either `resource`, `resourceName`, or both `projectId` and `dataset` must be provided in documentHandle.',
-        )
-      }
-
-      const message: IntentMessage = {
-        type: 'dashboard/v1/events/intents/dispatch-intent',
-        data: {
-          ...(action && !intentId ? {action} : {}),
-          ...(intentId ? {intentId} : {}),
-          document: {
-            id: documentHandle.documentId,
-            type: documentHandle.documentType,
-          },
-          resource: {
-            id: resource.id,
-            ...(resource.type ? {type: resource.type} : {}),
-          },
-          ...(parameters && Object.keys(parameters).length > 0 ? {parameters} : {}),
-        },
-      }
-
-      sendMessage(message.type, message.data)
-    } catch (error) {
-      // eslint-disable-next-line no-console
-      console.error('Failed to dispatch intent:', error)
-      throw error
-    }
-  }, [action, intentId, documentHandle, parameters, sendMessage, resource.id, resource.type])
-
-  return {
-    dispatchIntent,
-  }
-}

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})
-  })
-})