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

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

@@ -1,251 +0,0 @@
-import {type DocumentHandle} from '@sanity/sdk'
-import {renderHook as reactRenderHook} from '@testing-library/react'
-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',
-    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',
-      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('error handling', () => {
-    it('should throw error when neither resource nor projectId/dataset is provided', () => {
-      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-      const invalidHandle = {
-        documentId: 'test-document-id',
-        documentType: 'test-document-type',
-      }
-
-      // Use a minimal wrapper with no resource context so the normalization has nothing to fall back to
-      const {result} = reactRenderHook(() =>
-        useDispatchIntent({
-          action: 'edit',
-          documentHandle: invalidHandle as unknown as DocumentHandle,
-        }),
-      )
-
-      expect(() => result.current.dispatchIntent()).toThrow(
-        'useDispatchIntent: Unable to determine resource. Either `resource`, `resourceName`, or both `projectId` and `dataset` must be provided in documentHandle.',
-      )
-      consoleErrorSpy.mockRestore()
-    })
-  })
-})

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: mediaLibrarySource('ml123')}` or `{documentId: '123', documentType: 'sanity.canvas.document', resource: canvasSource('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,128 +0,0 @@
-import {describe, expect, it} from 'vitest'
-
-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', () => {
-      const documentHandle = {
-        documentId: 'test-document-id',
-        documentType: 'test-document-type',
-        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 DocumentHandleWithSource - media library', () => {
-    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 prioritize resource over projectId/dataset when both are provided', () => {
-      const documentHandle = {
-        documentId: 'test-asset-id',
-        documentType: 'sanity.asset',
-        projectId: 'test-project-id',
-        dataset: 'test-dataset',
-        resourceName: 'media-library',
-      }
-
-      const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
-
-      expect(result.current).toEqual({
-        id: 'media-library-id',
-        type: 'media-library',
-      })
-    })
-  })
-
-  describe('with DocumentHandleWithSource - canvas', () => {
-    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 DocumentHandleWithSource - 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: 'resource-project-id.resource-dataset',
-        type: undefined,
-      })
-    })
-
-    it('should use dataset resource over projectId/dataset when both are provided', () => {
-      const documentHandle = {
-        documentId: 'test-document-id',
-        documentType: 'test-document-type',
-        projectId: 'test-project-id',
-        dataset: 'test-dataset',
-        resourceName: 'dataset',
-      }
-
-      const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
-
-      expect(result.current).toEqual({
-        id: 'resource-project-id.resource-dataset',
-        type: undefined,
-      })
-    })
-  })
-
-  describe('edge cases', () => {
-    it('should handle DocumentHandleWithSource with undefined resource', () => {
-      const documentHandle = {
-        documentId: 'test-document-id',
-        documentType: 'test-document-type',
-        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,42 +0,0 @@
-import {
-  type DocumentHandle,
-  isCanvasResource,
-  isDatasetResource,
-  isMediaLibraryResource,
-} from '@sanity/sdk'
-
-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,
-  }
-}