@sanity/sdk-react 0.0.1 → 0.0.3

package/src/hooks/projection/{useProjection.test.tsx → useDocumentProjection.test.tsx}

@@ -8,7 +8,7 @@ import {act, render, screen} from '@testing-library/react'
 import {Suspense, useRef} from 'react'
 import {type Mock} from 'vitest'
 
-import {useProjection} from './useProjection'
+import {useDocumentProjection} from './useDocumentProjection'
 
 // Mock IntersectionObserver
 const mockIntersectionObserver = vi.fn()
@@ -61,7 +61,7 @@ function TestComponent({
   projection: ValidProjection
 }) {
   const ref = useRef(null)
-  const {data, isPending} = useProjection<ProjectionResult>({...document, projection, ref})
+  const {data, isPending} = useDocumentProjection<ProjectionResult>({...document, projection, ref})
 
   return (
     <div ref={ref}>
@@ -72,7 +72,7 @@ function TestComponent({
   )
 }
 
-describe('useProjection', () => {
+describe('useDocumentProjection', () => {
   let getCurrent: Mock
   let subscribe: Mock
 
@@ -228,7 +228,7 @@ describe('useProjection', () => {
       projection,
       ...docHandle
     }: DocumentHandle & {projection: ValidProjection}) {
-      const {data} = useProjection<ProjectionResult>({...docHandle, projection}) // No ref provided
+      const {data} = useDocumentProjection<ProjectionResult>({...docHandle, projection}) // No ref provided
       return (
         <div>
           <h1>{data.title}</h1>
@@ -261,7 +261,7 @@ describe('useProjection', () => {
       ...docHandle
     }: DocumentHandle & {projection: ValidProjection}) {
       const ref = useRef({}) // ref.current is not an HTML element
-      const {data} = useProjection<ProjectionResult>({...docHandle, projection, ref})
+      const {data} = useDocumentProjection<ProjectionResult>({...docHandle, projection, ref})
       return (
         <div>
           <h1>{data.title}</h1>

package/src/hooks/projection/{useProjection.ts → useDocumentProjection.ts}

@@ -14,7 +14,7 @@ import {useSanityInstance} from '../context/useSanityInstance'
  * @public
  * @category Types
  */
-export interface UseProjectionOptions<
+export interface useDocumentProjectionOptions<
   TProjection extends ValidProjection = ValidProjection,
   TDocumentType extends string = string,
   TDataset extends string = string,
@@ -32,7 +32,7 @@ export interface UseProjectionOptions<
  * @public
  * @category Types
  */
-export interface UseProjectionResults<TData> {
+export interface useDocumentProjectionResults<TData> {
   /** The projected data */
   data: TData
   /** True if the projection is currently being resolved */
@@ -59,7 +59,7 @@ export interface UseProjectionResults<TData> {
 
 // Overload 1: Relies on Typegen
 /**
- * @beta
+ * @public
  * Fetch a projection, relying on Typegen for the return type based on the handle and projection.
  *
  * @category Documents
@@ -69,7 +69,7 @@ export interface UseProjectionResults<TData> {
  * @example Using Typegen for a book preview
  * ```tsx
  * // ProjectionComponent.tsx
- * import {useProjection, type DocumentHandle} from '@sanity/sdk-react'
+ * import {useDocumentProjection, type DocumentHandle} from '@sanity/sdk-react'
  * import {useRef} from 'react'
  * import {defineProjection} from 'groq'
  *
@@ -90,7 +90,7 @@ export interface UseProjectionResults<TData> {
  *
  *   // Spread the doc handle into the options
  *   // Typegen infers the return type based on 'book' and the projection
- *   const { data } = useProjection({
+ *   const { data } = useDocumentProjection({
  *     ...doc, // Pass the handle properties
  *     ref,
  *     projection: myProjection,
@@ -114,18 +114,20 @@ export interface UseProjectionResults<TData> {
  * // </Suspense>
  * ```
  */
-export function useProjection<
+export function useDocumentProjection<
   TProjection extends ValidProjection = ValidProjection,
   TDocumentType extends string = string,
   TDataset extends string = string,
   TProjectId extends string = string,
 >(
-  options: UseProjectionOptions<TProjection, TDocumentType, TDataset, TProjectId>,
-): UseProjectionResults<SanityProjectionResult<TProjection, TDocumentType, TDataset, TProjectId>>
+  options: useDocumentProjectionOptions<TProjection, TDocumentType, TDataset, TProjectId>,
+): useDocumentProjectionResults<
+  SanityProjectionResult<TProjection, TDocumentType, `${TProjectId}.${TDataset}`>
+>
 
 // Overload 2: Explicit type provided
 /**
- * @beta
+ * @public
  * Fetch a projection with an explicitly defined return type `TData`.
  *
  * @param options - Options including the document handle properties (`documentId`, etc.) and the `projection`.
@@ -133,7 +135,7 @@ export function useProjection<
  *
  * @example Explicitly typing the projection result
  * ```tsx
- * import {useProjection, type DocumentHandle} from '@sanity/sdk-react'
+ * import {useDocumentProjection, type DocumentHandle} from '@sanity/sdk-react'
  * import {useRef} from 'react'
  *
  * interface SimpleBookPreview {
@@ -147,7 +149,7 @@ export function useProjection<
  *
  * function BookPreview({ doc }: BookPreviewProps) {
  *   const ref = useRef(null)
- *   const { data } = useProjection<SimpleBookPreview>({
+ *   const { data } = useDocumentProjection<SimpleBookPreview>({
  *     ...doc,
  *     ref,
  *     projection: `{ title, 'authorName': author->name }`
@@ -169,16 +171,16 @@ export function useProjection<
  * // </Suspense>
  * ```
  */
-export function useProjection<TData extends object>(
-  options: UseProjectionOptions, // Uses base options type
-): UseProjectionResults<TData>
+export function useDocumentProjection<TData extends object>(
+  options: useDocumentProjectionOptions, // Uses base options type
+): useDocumentProjectionResults<TData>
 
 // Implementation (no JSDoc needed here as it's covered by overloads)
-export function useProjection<TData extends object>({
+export function useDocumentProjection<TData extends object>({
   ref,
   projection,
   ...docHandle
-}: UseProjectionOptions): UseProjectionResults<TData> {
+}: useDocumentProjectionOptions): useDocumentProjectionResults<TData> {
   const instance = useSanityInstance()
   const stateSource = getProjectionState<TData>(instance, {...docHandle, projection})
 
@@ -228,5 +230,8 @@ export function useProjection<TData extends object>({
     [stateSource, ref],
   )
 
-  return useSyncExternalStore(subscribe, stateSource.getCurrent) as UseProjectionResults<TData>
+  return useSyncExternalStore(
+    subscribe,
+    stateSource.getCurrent,
+  ) as useDocumentProjectionResults<TData>
 }

package/src/hooks/query/useQuery.ts

@@ -12,7 +12,7 @@ import {useSanityInstance} from '../context/useSanityInstance'
 
 // Overload 1: Inferred Type (using Typegen)
 /**
- * @beta
+ * @public
  * Executes a GROQ query, inferring the result type from the query string and options.
  * Leverages Sanity Typegen if configured for enhanced type safety.
  *
@@ -74,14 +74,14 @@ export function useQuery<
   options: QueryOptions<TQuery, TDataset, TProjectId>,
 ): {
   /** The query result, typed based on the GROQ query string */
-  data: SanityQueryResult<TQuery, TDataset, TProjectId>
+  data: SanityQueryResult<TQuery, `${TProjectId}.${TDataset}`>
   /** True if a query transition is in progress */
   isPending: boolean
 }
 
 // Overload 2: Explicit Type Provided
 /**
- * @beta
+ * @public
  * Executes a GROQ query with an explicitly provided result type `TData`.
  *
  * @param options - Configuration for the query, including `query`, optional `params`, `projectId`, `dataset`, etc.
@@ -116,7 +116,7 @@ export function useQuery<TData>(options: QueryOptions): {
 }
 
 /**
- * @beta
+ * @public
  * Fetches data and subscribes to real-time updates using a GROQ query.
  *
  * @remarks
@@ -182,7 +182,7 @@ export function useQuery(options: QueryOptions): {data: unknown; isPending: bool
     //    the captured signal remains unchanged for this suspended render.
     // Thus, the promise thrown here uses a stable abort signal, ensuring correct behavior.
     const currentSignal = ref.current.signal
-    // eslint-disable-next-line react-compiler/react-compiler
+
     throw resolveQuery(instance, {...deferred, signal: currentSignal})
   }
 

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

@@ -1,85 +0,0 @@
-import {type Message, type Node, type Status} from '@sanity/comlink'
-import {getOrCreateNode} from '@sanity/sdk'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {act, renderHook} from '../../../test/test-utils'
-import {useRecordDocumentHistoryEvent} from './useRecordDocumentHistoryEvent'
-
-vi.mock(import('@sanity/sdk'), async (importOriginal) => {
-  const actual = await importOriginal()
-  return {
-    ...actual,
-    getOrCreateNode: vi.fn(),
-    releaseNode: vi.fn(),
-  }
-})
-
-describe('useRecordDocumentHistoryEvent', () => {
-  let node: Node<Message, Message>
-  let statusCallback: ((status: Status) => void) | null = null
-
-  const mockDocumentHandle = {
-    documentId: 'mock-id',
-    documentType: 'mock-type',
-    resourceType: 'studio' as const,
-    resourceId: 'mock-resource-id',
-  }
-
-  function createMockNode() {
-    return {
-      on: vi.fn(() => () => {}),
-      post: vi.fn(),
-      stop: vi.fn(),
-      onStatus: vi.fn((callback) => {
-        statusCallback = callback
-        return () => {}
-      }),
-    } as unknown as Node<Message, Message>
-  }
-
-  beforeEach(() => {
-    statusCallback = null
-    node = createMockNode()
-    vi.mocked(getOrCreateNode).mockReturnValue(node)
-  })
-
-  it('should initialize with correct connection status', () => {
-    const {result} = renderHook(() => useRecordDocumentHistoryEvent(mockDocumentHandle))
-
-    expect(result.current.isConnected).toBe(false)
-
-    act(() => {
-      statusCallback?.('connected')
-    })
-
-    expect(result.current.isConnected).toBe(true)
-  })
-
-  it('should send correct message when recording events', () => {
-    const {result} = renderHook(() => useRecordDocumentHistoryEvent(mockDocumentHandle))
-
-    result.current.recordEvent('viewed')
-
-    expect(node.post).toHaveBeenCalledWith('dashboard/v1/events/history', {
-      eventType: 'viewed',
-      document: {
-        id: 'mock-id',
-        type: 'mock-type',
-        resource: {
-          id: 'mock-resource-id',
-          type: 'studio',
-        },
-      },
-    })
-  })
-
-  it('should handle errors when sending messages', () => {
-    vi.mocked(node.post).mockImplementation(() => {
-      throw new Error('Failed to send message')
-    })
-
-    const {result} = renderHook(() => useRecordDocumentHistoryEvent(mockDocumentHandle))
-
-    expect(() => result.current.recordEvent('viewed')).toThrow('Failed to send message')
-  })
-})

package/src/hooks/comlink/useWindowConnection.test.ts

@@ -1,135 +0,0 @@
-import {type Message, type Node, type Status} from '@sanity/comlink'
-import {getOrCreateNode, releaseNode} from '@sanity/sdk'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {act, renderHook} from '../../../test/test-utils'
-import {useWindowConnection} from './useWindowConnection'
-
-vi.mock(import('@sanity/sdk'), async (importOriginal) => {
-  const actual = await importOriginal()
-  return {
-    ...actual,
-    getOrCreateNode: vi.fn(),
-    createNode: vi.fn(),
-    releaseNode: vi.fn(),
-  }
-})
-interface TestMessage {
-  type: 'TEST_MESSAGE'
-  data: {someData: string}
-}
-
-interface AnotherMessage {
-  type: 'ANOTHER_MESSAGE'
-  data: {otherData: number}
-}
-
-type TestMessages = TestMessage | AnotherMessage
-
-describe('useWindowConnection', () => {
-  let node: Node<Message, Message>
-  let statusCallback: ((status: Status) => void) | null = null
-
-  function createMockNode() {
-    return {
-      // return unsubscribe function
-      on: vi.fn(() => () => {}),
-      post: vi.fn(),
-      stop: vi.fn(),
-      onStatus: vi.fn((callback) => {
-        statusCallback = callback
-        return () => {}
-      }),
-    } as unknown as Node<Message, Message>
-  }
-
-  beforeEach(() => {
-    statusCallback = null
-    node = createMockNode()
-    vi.mocked(getOrCreateNode).mockReturnValue(node as unknown as Node<Message, Message>)
-  })
-
-  it('should call onStatus callback when status changes', () => {
-    const onStatusMock = vi.fn()
-    renderHook(() =>
-      useWindowConnection<TestMessages, TestMessages>({
-        name: 'test',
-        connectTo: 'window',
-        onStatus: onStatusMock,
-      }),
-    )
-
-    act(() => {
-      statusCallback?.('connected')
-    })
-    expect(onStatusMock).toHaveBeenCalledWith('connected')
-
-    act(() => {
-      statusCallback?.('disconnected')
-    })
-    expect(onStatusMock).toHaveBeenCalledWith('disconnected')
-  })
-
-  it('should not throw if onStatus is not provided', () => {
-    renderHook(() =>
-      useWindowConnection<TestMessages, TestMessages>({
-        name: 'test',
-        connectTo: 'window',
-      }),
-    )
-
-    expect(() => {
-      act(() => {
-        statusCallback?.('connected')
-      })
-    }).not.toThrow()
-  })
-
-  it('should register message handlers', () => {
-    const mockHandler = vi.fn()
-    const mockData = {someData: 'test'}
-
-    renderHook(() =>
-      useWindowConnection<TestMessages, TestMessages>({
-        name: 'test',
-        connectTo: 'window',
-        onMessage: {
-          TEST_MESSAGE: mockHandler,
-          ANOTHER_MESSAGE: vi.fn(),
-        },
-      }),
-    )
-
-    const onCallback = vi.mocked(node.on).mock.calls[0][1]
-    onCallback(mockData)
-
-    expect(mockHandler).toHaveBeenCalledWith(mockData)
-  })
-
-  it('should send messages through the node', () => {
-    const {result} = renderHook(() =>
-      useWindowConnection<TestMessages, TestMessages>({
-        name: 'test',
-        connectTo: 'window',
-      }),
-    )
-
-    result.current.sendMessage('TEST_MESSAGE', {someData: 'test'})
-    expect(node.post).toHaveBeenCalledWith('TEST_MESSAGE', {someData: 'test'})
-
-    result.current.sendMessage('ANOTHER_MESSAGE', {otherData: 123})
-    expect(node.post).toHaveBeenCalledWith('ANOTHER_MESSAGE', {otherData: 123})
-  })
-
-  it('should cleanup on unmount', () => {
-    const {unmount} = renderHook(() =>
-      useWindowConnection<TestMessages, TestMessages>({
-        name: 'test',
-        connectTo: 'window',
-      }),
-    )
-
-    unmount()
-    expect(releaseNode).toHaveBeenCalled()
-  })
-})