@sanity/sdk-react 0.0.0-alpha.2 → 0.0.0-alpha.21

package/src/css/styles.css

@@ -1,11 +0,0 @@
-@import './paramour.css';
-
-body {
-  color-scheme: light dark;
-  color: light-dark(var(--gray-1), var(--gray-10));
-  background-color: light-dark(var(--gray-11), var(--gray-1));
-}
-
-.container-inline {
-  container-type: inline-size;
-}

package/src/hooks/auth/useHandleCallback.test.tsx

@@ -1,16 +0,0 @@
-import {handleCallback} from '@sanity/sdk'
-import {identity} from 'rxjs'
-import {describe, it} from 'vitest'
-
-import {createCallbackHook} from '../helpers/createCallbackHook'
-
-vi.mock('../helpers/createCallbackHook', () => ({createCallbackHook: vi.fn(identity)}))
-vi.mock('@sanity/sdk', () => ({handleCallback: vi.fn()}))
-
-describe('useHandleCallback', () => {
-  it('calls `createCallbackHook` with `handleCallback`', async () => {
-    const {useHandleCallback} = await import('./useHandleCallback')
-    expect(createCallbackHook).toHaveBeenCalledWith(handleCallback)
-    expect(useHandleCallback).toBe(handleCallback)
-  })
-})

package/src/hooks/client/useClient.test.tsx

@@ -1,130 +0,0 @@
-import {type SanityClient} from '@sanity/client'
-import {act} from '@testing-library/react'
-import type {Subscribable, Subscriber} from 'rxjs'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {renderHook} from '../../../test/test-utils'
-import {useClient} from './useClient'
-
-vi.mock(import('@sanity/sdk'), async (importOriginal) => {
-  const actual = await importOriginal()
-  return {
-    ...actual,
-    getClient: vi.fn(),
-    getSubscribableClient: vi.fn(),
-  }
-})
-
-const {getClient, getSubscribableClient} = await import('@sanity/sdk')
-
-describe('useClient', () => {
-  let subscribers: {next: (client: SanityClient) => void}[] = []
-  let currentClient: SanityClient
-
-  beforeEach(() => {
-    subscribers = []
-
-    currentClient = {
-      config: () => ({token: undefined, apiVersion: 'v2024-11-12'}),
-    } as unknown as SanityClient
-
-    // Create a subscribable interface directly
-    const createSubscribable = (): Subscribable<SanityClient> => ({
-      subscribe: (subscriber: {next: (client: SanityClient) => void}) => {
-        subscribers.push(subscriber)
-        subscriber.next(currentClient)
-        return {
-          unsubscribe: () => {
-            const index = subscribers.indexOf(subscriber)
-            if (index > -1) subscribers.splice(index, 1)
-          },
-        }
-      },
-    })
-
-    vi.mocked(getClient).mockReturnValue(currentClient)
-    vi.mocked(getSubscribableClient).mockImplementation(() => createSubscribable())
-  })
-  it('should return initial client', () => {
-    const {result} = renderHook(() => useClient({apiVersion: 'v2024-11-12'}))
-
-    expect(result.current.config().token).toBeUndefined()
-    expect(result.current.config().apiVersion).toBe('v2024-11-12')
-  })
-
-  it('should handle client update through authentication changes', async () => {
-    let clientSubscriber: Subscriber<SanityClient> | undefined
-
-    // Create a subscribable that can simulate updates
-    vi.mocked(getSubscribableClient).mockImplementation(() => ({
-      subscribe: (subscriber: Subscriber<SanityClient>) => {
-        clientSubscriber = subscriber
-        // Send initial client
-        subscriber.next(currentClient)
-        return {
-          unsubscribe: vi.fn(),
-        }
-      },
-    }))
-
-    const {result} = renderHook(() => useClient({apiVersion: 'v2024-11-12'}))
-
-    // Verify initial state
-    expect(result.current.config().token).toBeUndefined()
-    expect(clientSubscriber).toBeDefined()
-
-    // Create authenticated client
-    const authenticatedClient = {
-      config: () => ({token: 'auth-token', apiVersion: 'v2024-11-12'}),
-    } as unknown as SanityClient
-
-    // Update getClient to return the new client
-    vi.mocked(getClient).mockReturnValue(authenticatedClient)
-
-    // Simulate the client update that would happen after auth change
-    await act(async () => {
-      clientSubscriber!.next(authenticatedClient)
-    })
-
-    // Verify the client was updated with the new token
-    expect(result.current.config().token).toBe('auth-token')
-  })
-
-  it('should unsubscribe on unmount', () => {
-    const unsubscribeSpy = vi.fn()
-    vi.mocked(getSubscribableClient).mockImplementation(() => ({
-      subscribe: () => ({
-        unsubscribe: unsubscribeSpy,
-      }),
-    }))
-
-    const {unmount} = renderHook(() => useClient({apiVersion: 'v2024-11-12'}))
-
-    unmount()
-    expect(unsubscribeSpy).toHaveBeenCalled()
-  })
-
-  it('should handle subscription errors', () => {
-    vi.spyOn(console, 'error').mockImplementation(() => {})
-
-    const testError = new Error('Subscription error')
-    let errorSubscriber: Subscriber<SanityClient> | undefined
-
-    // Mock getSubscribableClient to create a subscription that will error
-    vi.mocked(getSubscribableClient).mockImplementation(() => ({
-      subscribe: (subscriber: Subscriber<SanityClient>) => {
-        errorSubscriber = subscriber
-        return {
-          unsubscribe: vi.fn(),
-        }
-      },
-    }))
-
-    renderHook(() => useClient({apiVersion: 'v2024-11-12'}))
-
-    errorSubscriber!.error(testError)
-
-    // eslint-disable-next-line no-console
-    expect(console.error).toHaveBeenCalledWith('Error in useClient subscription:', testError)
-  })
-})

package/src/hooks/documentCollection/useDocuments.test.ts

@@ -1,130 +0,0 @@
-import {createDocumentListStore, type DocumentListOptions} from '@sanity/sdk'
-import {act, renderHook} from '@testing-library/react'
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {useSanityInstance} from '../context/useSanityInstance'
-import {useDocuments} from './useDocuments'
-
-vi.mock('@sanity/sdk')
-vi.mock('../context/useSanityInstance')
-
-describe('useDocuments', () => {
-  const mockInstance = {}
-
-  const getCurrent = vi.fn()
-  const unsubscribe = vi.fn()
-  const subscribe = vi.fn().mockReturnValue(unsubscribe)
-  const dispose = vi.fn()
-
-  const mockDocumentListStore: ReturnType<typeof createDocumentListStore> = {
-    setOptions: vi.fn(),
-    loadMore: vi.fn(),
-    getState: vi.fn().mockReturnValue({getCurrent, subscribe}),
-    dispose,
-  }
-
-  beforeEach(() => {
-    vi.mocked(useSanityInstance).mockReturnValue(
-      mockInstance as unknown as ReturnType<typeof useSanityInstance>,
-    )
-    vi.mocked(createDocumentListStore).mockReturnValue(
-      mockDocumentListStore as unknown as ReturnType<typeof createDocumentListStore>,
-    )
-  })
-
-  afterEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('should initialize with given options', () => {
-    const options: DocumentListOptions = {
-      filter: 'some-filter',
-      sort: [{field: 'name', direction: 'asc'}],
-    }
-    renderHook(() => useDocuments(options))
-
-    expect(createDocumentListStore).toHaveBeenCalledWith(mockInstance)
-    expect(mockDocumentListStore.setOptions).toHaveBeenCalledWith(options)
-  })
-
-  it('should subscribe to document list store changes', () => {
-    const options: DocumentListOptions = {}
-
-    renderHook(() => useDocuments(options))
-    expect(subscribe).toHaveBeenCalledTimes(1)
-  })
-
-  it('should return the current document list state', () => {
-    const options = {}
-    const currentState = {result: [], isPending: false}
-    getCurrent.mockReturnValue(currentState)
-
-    const {result} = renderHook(() => useDocuments(options))
-    expect(result.current).toMatchObject(currentState)
-  })
-
-  it('should call loadMore when loadMore is invoked', () => {
-    const options = {}
-    const {result} = renderHook(() => useDocuments(options))
-
-    act(() => {
-      result.current.loadMore()
-    })
-
-    expect(mockDocumentListStore.loadMore).toHaveBeenCalled()
-  })
-
-  it('should update state when document list store changes', () => {
-    const options = {
-      filter: 'some-filter',
-      sort: [{field: 'name', direction: 'asc'}],
-    }
-    getCurrent.mockReturnValue({results: [], isPending: true})
-    const {result, rerender} = renderHook(() => useDocuments(options as DocumentListOptions))
-
-    expect(subscribe).toHaveBeenCalledTimes(1)
-    const [subscriber] = subscribe.mock.calls[0]
-
-    const newState = {results: [{id: 'doc1'}], isPending: false}
-    getCurrent.mockReturnValue(newState)
-
-    act(() => {
-      subscriber()
-      rerender()
-    })
-
-    expect(result.current).toMatchObject(newState)
-  })
-
-  it('should handle empty options', () => {
-    const options = {}
-    renderHook(() => useDocuments(options))
-
-    expect(createDocumentListStore).toHaveBeenCalledWith(mockInstance)
-    expect(mockDocumentListStore.setOptions).toHaveBeenCalledWith(options)
-  })
-
-  it('should handle null result from document list store', () => {
-    const options = {}
-    getCurrent.mockReturnValue({result: null, isPending: false})
-
-    const {result} = renderHook(() => useDocuments(options))
-
-    expect(result.current).toMatchObject({
-      result: null,
-      isPending: false,
-    })
-  })
-
-  it('should unsubscribe from document list store on unmount', () => {
-    const options = {}
-    const unsubscribeSpy = vi.fn()
-    subscribe.mockReturnValue(unsubscribeSpy)
-
-    const {unmount} = renderHook(() => useDocuments(options))
-
-    unmount()
-    expect(mockDocumentListStore.dispose).toHaveBeenCalled()
-    expect(unsubscribeSpy).toHaveBeenCalled()
-  })
-})

package/src/hooks/documentCollection/useDocuments.ts

@@ -1,87 +0,0 @@
-import {createDocumentListStore, type DocumentHandle, type DocumentListOptions} from '@sanity/sdk'
-import {useCallback, useEffect, useState, useSyncExternalStore} from 'react'
-
-import {useSanityInstance} from '../context/useSanityInstance'
-
-/**
- * @public
- */
-export interface UseDocuments {
-  loadMore: () => void
-  results: DocumentHandle[]
-  isPending: boolean
-  hasMore: boolean
-  count: number
-}
-
-type DocumentListStore = ReturnType<typeof createDocumentListStore>
-type DocumentListState = ReturnType<DocumentListStore['getState']>['getCurrent']
-const STABLE_EMPTY = {
-  results: [],
-  isPending: false,
-  hasMore: false,
-  count: 0,
-}
-
-/**
- * Hook to get the list of documents for specified options
- *
- * @public
- *
- * @param options - options for the document list
- * @returns result of the document list and function to load more
- */
-export function useDocuments(options: DocumentListOptions = {}): UseDocuments {
-  const instance = useSanityInstance()
-
-  // NOTE: useState is used because it guaranteed to return a stable reference
-  // across renders
-  const [ref] = useState<{
-    storeInstance: DocumentListStore | null
-    getCurrent: DocumentListState
-    initialOptions: DocumentListOptions
-  }>(() => ({
-    storeInstance: null,
-    getCurrent: () => STABLE_EMPTY,
-    initialOptions: options,
-  }))
-
-  // serialize options to ensure it only calls `setOptions` when the values
-  // themselves changes (in cases where devs put config inline)
-  const serializedOptions = JSON.stringify(options)
-  useEffect(() => {
-    ref.storeInstance?.setOptions(JSON.parse(serializedOptions))
-  }, [ref, serializedOptions])
-
-  const subscribe = useCallback(
-    (onStoreChanged: () => void) => {
-      // to match the lifecycle of `useSyncExternalState`, we create the store
-      // instance after subscribe and mutate the ref to connect everything
-      ref.storeInstance = createDocumentListStore(instance)
-      ref.storeInstance.setOptions(ref.initialOptions)
-      const state = ref.storeInstance.getState()
-      ref.getCurrent = state.getCurrent
-      const unsubscribe = state.subscribe(onStoreChanged)
-
-      return () => {
-        // unsubscribe to clean up the state subscriptions
-        unsubscribe()
-        // dispose of the instance
-        ref.storeInstance?.dispose()
-      }
-    },
-    [instance, ref],
-  )
-
-  const getSnapshot = useCallback(() => {
-    return ref.getCurrent()
-  }, [ref])
-
-  const state = useSyncExternalStore(subscribe, getSnapshot)
-
-  const loadMore = useCallback(() => {
-    ref.storeInstance?.loadMore()
-  }, [ref])
-
-  return {loadMore, ...state}
-}