@sanity/sdk-react 0.0.0-alpha.17 → 0.0.0-alpha.19

package/src/hooks/comlink/useManageFavorite.ts

@@ -0,0 +1,98 @@
+import {type Events, SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
+import {type DocumentHandle, type FrameMessage} from '@sanity/sdk'
+import {useCallback, useState} from 'react'
+
+import {useWindowConnection} from './useWindowConnection'
+
+// should we import this whole type from the message protocol?
+
+interface ManageFavorite {
+  favorite: () => void
+  unfavorite: () => void
+  isFavorited: boolean
+  isConnected: boolean
+}
+
+/**
+ * @beta
+ *
+ * ## useManageFavorite
+ * This hook provides functionality to add and remove documents from favorites,
+ * and tracks the current favorite status of the document.
+ * @category Core UI Communication
+ * @param documentHandle - The document handle containing document ID and type, like `{_id: '123', _type: 'book'}`
+ * @returns An object containing:
+ * - `favorite` - Function to add document to favorites
+ * - `unfavorite` - Function to remove document from favorites
+ * - `isFavorited` - Boolean indicating if document is currently favorited
+ * - `isConnected` - Boolean indicating if connection to Core UI is established
+ *
+ * @example
+ * ```tsx
+ * function MyDocumentAction(props: DocumentActionProps) {
+ *   const {_id, _type} = props
+ *   const {favorite, unfavorite, isFavorited, isConnected} = useManageFavorite({
+ *     _id,
+ *     _type
+ *   })
+ *
+ *   return (
+ *     <Button
+ *       disabled={!isConnected}
+ *       onClick={() => isFavorited ? unfavorite() : favorite()}
+ *       text={isFavorited ? 'Remove from favorites' : 'Add to favorites'}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+export function useManageFavorite({_id, _type}: DocumentHandle): ManageFavorite {
+  const [isFavorited, setIsFavorited] = useState(false) // should load this from a comlink fetch
+  const {sendMessage, status} = useWindowConnection<Events.FavoriteMessage, FrameMessage>({
+    name: SDK_NODE_NAME,
+    connectTo: SDK_CHANNEL_NAME,
+  })
+
+  const handleFavoriteAction = useCallback(
+    (action: 'added' | 'removed', setFavoriteState: boolean) => {
+      if (!_id || !_type) return
+
+      try {
+        const message: Events.FavoriteMessage = {
+          type: 'core/v1/events/favorite',
+          data: {
+            eventType: action,
+            documentId: _id,
+            documentType: _type,
+          },
+        }
+
+        sendMessage(message.type, message.data)
+        setIsFavorited(setFavoriteState)
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error('Failed to update favorite status')
+        // eslint-disable-next-line no-console
+        console.error(
+          `Failed to ${action === 'added' ? 'favorite' : 'unfavorite'} document:`,
+          error,
+        )
+        throw error
+      }
+    },
+    [_id, _type, sendMessage],
+  )
+
+  const favorite = useCallback(() => handleFavoriteAction('added', true), [handleFavoriteAction])
+
+  const unfavorite = useCallback(
+    () => handleFavoriteAction('removed', false),
+    [handleFavoriteAction],
+  )
+
+  return {
+    favorite,
+    unfavorite,
+    isFavorited,
+    isConnected: status === 'connected',
+  }
+}

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

@@ -0,0 +1,77 @@
+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 = {
+    _id: 'mock-id',
+    _type: 'mock-type',
+  }
+
+  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('core/v1/events/history', {
+      eventType: 'viewed',
+      documentId: 'mock-id',
+      documentType: 'mock-type',
+    })
+  })
+
+  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/useRecordDocumentHistoryEvent.ts

@@ -0,0 +1,75 @@
+import {type Events, SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
+import {type DocumentHandle, type FrameMessage} from '@sanity/sdk'
+import {useCallback} from 'react'
+
+import {useWindowConnection} from './useWindowConnection'
+
+interface DocumentInteractionHistory {
+  recordEvent: (eventType: 'viewed' | 'edited' | 'created' | 'deleted') => void
+  isConnected: boolean
+}
+
+/**
+ * @public
+ * Hook for managing document interaction history in Sanity Studio.
+ * This hook provides functionality to record document interactions.
+ * @param documentHandle - The document handle containing document ID and type, like `{_id: '123', _type: 'book'}`
+ * @returns An object containing:
+ * - `recordEvent` - Function to record document interactions
+ * - `isConnected` - Boolean indicating if connection to Studio is established
+ *
+ * @example
+ * ```tsx
+ * function MyDocumentAction(props: DocumentActionProps) {
+ *   const {_id, _type} = props
+ *   const {recordEvent, isConnected} = useRecordDocumentHistoryEvent({
+ *     _id,
+ *     _type
+ *   })
+ *
+ *   return (
+ *     <Button
+ *       disabled={!isConnected}
+ *       onClick={() => recordEvent('viewed')}
+ *       text={'Viewed'}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+export function useRecordDocumentHistoryEvent({
+  _id,
+  _type,
+}: DocumentHandle): DocumentInteractionHistory {
+  const {sendMessage, status} = useWindowConnection<Events.HistoryMessage, FrameMessage>({
+    name: SDK_NODE_NAME,
+    connectTo: SDK_CHANNEL_NAME,
+  })
+
+  const recordEvent = useCallback(
+    (eventType: 'viewed' | 'edited' | 'created' | 'deleted') => {
+      try {
+        const message: Events.HistoryMessage = {
+          type: 'core/v1/events/history',
+          data: {
+            eventType,
+            documentId: _id,
+            documentType: _type,
+          },
+        }
+
+        sendMessage(message.type, message.data)
+      } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('Failed to record history event:', error)
+        throw error
+      }
+    },
+    [_id, _type, sendMessage],
+  )
+
+  return {
+    recordEvent,
+    isConnected: status === 'connected',
+  }
+}

package/src/hooks/context/useSanityInstance.ts

@@ -1,7 +1,7 @@
 import {type SanityInstance} from '@sanity/sdk'
 import {useContext} from 'react'
 
-import {SanityInstanceContext} from '../../context/SanityProvider'
+import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 
 /**
  * `useSanityInstance` returns the current Sanity instance from the application context.

package/dist/_chunks-es/context.js

@@ -1,16 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { c } from "react/compiler-runtime";
-import { createContext } from "react";
-const SanityInstanceContext = createContext(null), SanityProvider = (t0) => {
-  const $ = c(3), {
-    children,
-    sanityInstances
-  } = t0;
-  let t1;
-  return $[0] !== children || $[1] !== sanityInstances ? (t1 = /* @__PURE__ */ jsx(SanityInstanceContext.Provider, { value: sanityInstances, children }), $[0] = children, $[1] = sanityInstances, $[2] = t1) : t1 = $[2], t1;
-};
-export {
-  SanityInstanceContext,
-  SanityProvider
-};
-//# sourceMappingURL=context.js.map

package/dist/_chunks-es/context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.js","sources":["../../src/context/SanityProvider.tsx"],"sourcesContent":["import {type SanityInstance} from '@sanity/sdk'\nimport {createContext, type ReactElement} from 'react'\n\n/**\n * @internal\n */\nexport interface SanityProviderProps {\n  children: React.ReactNode\n  sanityInstances: SanityInstance[]\n}\n\nexport const SanityInstanceContext = createContext<SanityInstance[] | null>(null)\n\n/**\n * @internal\n *\n * Top-level context provider that provides access to the Sanity configuration instance.\n * This must wrap any components making use of the Sanity SDK React hooks.\n *\n * @remarks In most cases, SanityApp should be used rather than SanityProvider directly; SanityApp bundles both SanityProvider and an authentication layer.\n * @param props - Sanity project and dataset configuration\n * @returns Rendered component\n * @example\n * ```tsx\n * import {createSanityInstance} from '@sanity/sdk'\n * import {SanityProvider} from '@sanity/sdk-react'\n *\n * import MyAppRoot from './Root'\n *\n * const sanityInstance = createSanityInstance({\n *   projectId: 'your-project-id',\n *   dataset: 'production',\n * })\n *\n * export default function MyApp() {\n *   return (\n *     <SanityProvider sanityInstance={sanityInstance}>\n *       <MyAppRoot />\n *     </SanityProvider>\n *   )\n * }\n * ```\n */\nexport const SanityProvider = ({children, sanityInstances}: SanityProviderProps): ReactElement => {\n  return (\n    <SanityInstanceContext.Provider value={sanityInstances}>\n      {children}\n    </SanityInstanceContext.Provider>\n  )\n}\n"],"names":["SanityInstanceContext","createContext","SanityProvider","t0","$","_c","children","sanityInstances","t1"],"mappings":";;;AAWO,MAAMA,wBAAwBC,cAAuC,IAAI,GAgCnEC,iBAAiBC,CAAA,OAAA;AAAAC,QAAAA,IAAAC,EAAA,CAAA,GAAC;AAAA,IAAAC;AAAAA,IAAAC;AAAAA,EAAAA,IAAAJ;AAAgDK,MAAAA;AAAA,SAAAJ,EAAAE,CAAAA,MAAAA,YAAAF,SAAAG,mBAE3EC,KAAA,oBAAA,sBAAA,UAAA,EAAuCD,OAAAA,iBACpCD,SAAAA,CACH,GAAiCF,OAAAE,UAAAF,OAAAG,iBAAAH,OAAAI,MAAAA,KAAAJ,EAAA,CAAA,GAFjCI;AAEiC;"}

package/dist/_chunks-es/useLogOut.js

@@ -1,73 +0,0 @@
-import { getAuthState, handleCallback, getLoginUrlsState, fetchLoginUrls, logout } from "@sanity/sdk";
-import { c } from "react/compiler-runtime";
-import { useContext, useSyncExternalStore, useMemo } from "react";
-import { SanityInstanceContext } from "./context.js";
-const useSanityInstance = (resourceId) => {
-  const $ = c(5), sanityInstance = useContext(SanityInstanceContext);
-  if (!sanityInstance)
-    throw new Error("useSanityInstance must be called from within the SanityProvider");
-  if (sanityInstance.length === 0)
-    throw new Error("No Sanity instances found");
-  if (sanityInstance.length === 1 || !resourceId)
-    return sanityInstance[0];
-  if (!resourceId)
-    throw new Error("resourceId is required when there are multiple Sanity instances");
-  let t0;
-  if ($[0] !== resourceId || $[1] !== sanityInstance) {
-    let t1;
-    $[3] !== resourceId ? (t1 = (inst) => inst.identity.resourceId === resourceId, $[3] = resourceId, $[4] = t1) : t1 = $[4], t0 = sanityInstance.find(t1), $[0] = resourceId, $[1] = sanityInstance, $[2] = t0;
-  } else
-    t0 = $[2];
-  const instance = t0;
-  if (!instance)
-    throw new Error(`Sanity instance with resourceId ${resourceId} not found`);
-  return instance;
-};
-function createStateSourceHook(options) {
-  const getState = typeof options == "function" ? options : options.getState, getResourceId = "getResourceId" in options ? options.getResourceId : void 0, suspense = "shouldSuspend" in options && "suspender" in options ? options : void 0;
-  function useHook(...t0) {
-    const $ = c(5), params = t0;
-    let resourceId;
-    if (getResourceId) {
-      let t12;
-      $[0] !== params ? (t12 = getResourceId(...params), $[0] = params, $[1] = t12) : t12 = $[1], resourceId = t12;
-    }
-    const instance = useSanityInstance(resourceId);
-    if (suspense?.suspender && suspense?.shouldSuspend?.(instance, ...params))
-      throw suspense.suspender(instance, ...params);
-    let t1;
-    $[2] !== instance || $[3] !== params ? (t1 = getState(instance, ...params), $[2] = instance, $[3] = params, $[4] = t1) : t1 = $[4];
-    const state = t1;
-    return useSyncExternalStore(state.subscribe, state.getCurrent);
-  }
-  return useHook;
-}
-const useAuthState = createStateSourceHook(getAuthState);
-function createCallbackHook(callback, resourceId) {
-  function useHook() {
-    const $ = c(2), instance = useSanityInstance(resourceId);
-    let t0;
-    return $[0] !== instance ? (t0 = (...t1) => callback(instance, ...t1), $[0] = instance, $[1] = t0) : t0 = $[1], t0;
-  }
-  return useHook;
-}
-const useHandleCallback = createCallbackHook(handleCallback);
-function useLoginUrls() {
-  const instance = useSanityInstance(), {
-    subscribe,
-    getCurrent
-  } = useMemo(() => getLoginUrlsState(instance), [instance]);
-  if (!getCurrent()) throw fetchLoginUrls(instance);
-  return useSyncExternalStore(subscribe, getCurrent);
-}
-const useLogOut = createCallbackHook(logout);
-export {
-  createCallbackHook,
-  createStateSourceHook,
-  useAuthState,
-  useHandleCallback,
-  useLogOut,
-  useLoginUrls,
-  useSanityInstance
-};
-//# sourceMappingURL=useLogOut.js.map

package/dist/_chunks-es/useLogOut.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useLogOut.js","sources":["../../src/hooks/context/useSanityInstance.ts","../../src/hooks/helpers/createStateSourceHook.tsx","../../src/hooks/auth/useAuthState.tsx","../../src/hooks/helpers/createCallbackHook.tsx","../../src/hooks/auth/useHandleCallback.tsx","../../src/hooks/auth/useLoginUrls.tsx","../../src/hooks/auth/useLogOut.tsx"],"sourcesContent":["import {type SanityInstance} from '@sanity/sdk'\nimport {useContext} from 'react'\n\nimport {SanityInstanceContext} from '../../context/SanityProvider'\n\n/**\n * `useSanityInstance` returns the current Sanity instance from the application context.\n * This must be called from within a `SanityProvider` component.\n * @internal\n *\n * @param resourceId - The resourceId of the Sanity instance to return (optional)\n * @returns The current Sanity instance\n * @example\n * ```tsx\n * const instance = useSanityInstance('abc123.production')\n * ```\n */\nexport const useSanityInstance = (resourceId?: string): SanityInstance => {\n  const sanityInstance = useContext(SanityInstanceContext)\n  if (!sanityInstance) {\n    throw new Error('useSanityInstance must be called from within the SanityProvider')\n  }\n  if (sanityInstance.length === 0) {\n    throw new Error('No Sanity instances found')\n  }\n  if (sanityInstance.length === 1 || !resourceId) {\n    return sanityInstance[0]\n  }\n\n  if (!resourceId) {\n    throw new Error('resourceId is required when there are multiple Sanity instances')\n  }\n\n  const instance = sanityInstance.find((inst) => inst.identity.resourceId === resourceId)\n  if (!instance) {\n    throw new Error(`Sanity instance with resourceId ${resourceId} not found`)\n  }\n  return instance\n}\n","import {type ResourceId, type SanityInstance, type StateSource} from '@sanity/sdk'\nimport {useSyncExternalStore} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\ntype StateSourceFactory<TParams extends unknown[], TState> = (\n  instance: SanityInstance,\n  ...params: TParams\n) => StateSource<TState>\n\ninterface CreateStateSourceHookOptions<TParams extends unknown[], TState> {\n  getState: StateSourceFactory<TParams, TState>\n  shouldSuspend?: (instance: SanityInstance, ...params: TParams) => boolean\n  suspender?: (instance: SanityInstance, ...params: TParams) => Promise<unknown>\n  getResourceId?: (...params: TParams) => ResourceId | undefined\n}\n\nexport function createStateSourceHook<TParams extends unknown[], TState>(\n  options: StateSourceFactory<TParams, TState> | CreateStateSourceHookOptions<TParams, TState>,\n): (...params: TParams) => TState {\n  const getState = typeof options === 'function' ? options : options.getState\n  const getResourceId = 'getResourceId' in options ? options.getResourceId : undefined\n  const suspense = 'shouldSuspend' in options && 'suspender' in options ? options : undefined\n\n  function useHook(...params: TParams) {\n    let resourceId: ResourceId | undefined\n    if (getResourceId) {\n      resourceId = getResourceId(...params)\n    }\n    const instance = useSanityInstance(resourceId)\n    if (suspense?.suspender && suspense?.shouldSuspend?.(instance, ...params)) {\n      throw suspense.suspender(instance, ...params)\n    }\n\n    const state = getState(instance, ...params)\n    return useSyncExternalStore(state.subscribe, state.getCurrent)\n  }\n\n  return useHook\n}\n","import {type AuthState, getAuthState} from '@sanity/sdk'\n\nimport {createStateSourceHook} from '../helpers/createStateSourceHook'\n\n/**\n * @internal\n * A React hook that subscribes to authentication state changes.\n *\n * This hook provides access to the current authentication state type from the Sanity auth store.\n * It automatically re-renders when the authentication state changes.\n *\n * @remarks\n * The hook uses `useSyncExternalStore` to safely subscribe to auth state changes\n * and ensure consistency between server and client rendering.\n *\n * @returns The current authentication state type\n *\n * @example\n * ```tsx\n * function AuthStatus() {\n *   const authState = useAuthState()\n *   return <div>Current auth state: {authState}</div>\n * }\n * ```\n */\nexport const useAuthState: () => AuthState = createStateSourceHook(getAuthState)\n","import {type ResourceId, type SanityInstance} from '@sanity/sdk'\nimport {useCallback} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\nexport function createCallbackHook<TParams extends unknown[], TReturn>(\n  callback: (instance: SanityInstance, ...params: TParams) => TReturn,\n  resourceId?: ResourceId,\n): () => (...params: TParams) => TReturn {\n  function useHook() {\n    const instance = useSanityInstance(resourceId)\n    return useCallback((...params: TParams) => callback(instance, ...params), [instance])\n  }\n\n  return useHook\n}\n","import {handleCallback} from '@sanity/sdk'\n\nimport {createCallbackHook} from '../helpers/createCallbackHook'\n\n/**\n * @internal\n * A React hook that returns a function for handling authentication callbacks.\n *\n * @remarks\n * This hook provides access to the authentication store's callback handler,\n * which processes auth redirects by extracting the session ID and fetching the\n * authentication token. If fetching the long-lived token is successful,\n * `handleCallback` will return a Promise that resolves a new location that\n * removes the short-lived token from the URL. Use this in combination with\n * `history.replaceState` or your own router's `replace` function to update the\n * current location without triggering a reload.\n *\n * @example\n * ```tsx\n * function AuthCallback() {\n *   const handleCallback = useHandleCallback()\n *   const router = useRouter() // Example router\n *\n *   useEffect(() => {\n *     async function processCallback() {\n *       // Handle the callback and get the cleaned URL\n *       const newUrl = await handleCallback(window.location.href)\n *\n *       if (newUrl) {\n *         // Replace URL without triggering navigation\n *         router.replace(newUrl, {shallow: true})\n *       }\n *     }\n *\n *     processCallback().catch(console.error)\n *   }, [handleCallback, router])\n *\n *   return <div>Completing login...</div>\n * }\n * ```\n *\n * @returns A callback handler function that processes OAuth redirects\n * @public\n */\nexport const useHandleCallback = createCallbackHook(handleCallback)\n","import {type AuthProvider, fetchLoginUrls, getLoginUrlsState} from '@sanity/sdk'\nimport {useMemo, useSyncExternalStore} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\n/**\n * @internal\n * A React hook that retrieves the available authentication provider URLs for login.\n *\n * @remarks\n * This hook fetches the login URLs from the Sanity auth store when the component mounts.\n * Each provider object contains information about an authentication method, including its URL.\n * The hook will suspend if the login URLs have not yet loaded.\n *\n * @example\n * ```tsx\n * // LoginProviders component that uses the hook\n * function LoginProviders() {\n *   const providers = useLoginUrls()\n *\n *   return (\n *     <div>\n *       {providers.map((provider) => (\n *         <a key={provider.name} href={provider.url}>\n *           Login with {provider.title}\n *         </a>\n *       ))}\n *     </div>\n *   )\n * }\n *\n * // Parent component with Suspense boundary\n * function LoginPage() {\n *   return (\n *     <Suspense fallback={<div>Loading authentication providers...</div>}>\n *       <LoginProviders />\n *     </Suspense>\n *   )\n * }\n * ```\n *\n * @returns An array of {@link AuthProvider} objects containing login URLs and provider information\n * @public\n */\nexport function useLoginUrls(): AuthProvider[] {\n  const instance = useSanityInstance()\n  const {subscribe, getCurrent} = useMemo(() => getLoginUrlsState(instance), [instance])\n\n  if (!getCurrent()) throw fetchLoginUrls(instance)\n\n  return useSyncExternalStore(subscribe, getCurrent as () => AuthProvider[])\n}\n","import {logout} from '@sanity/sdk'\n\nimport {createCallbackHook} from '../helpers/createCallbackHook'\n\n/**\n * Hook to log out of the current session\n * @internal\n * @returns A function to log out of the current session\n */\nexport const useLogOut = createCallbackHook(logout)\n"],"names":["useSanityInstance","resourceId","$","_c","sanityInstance","useContext","SanityInstanceContext","Error","length","t0","t1","inst","identity","find","instance","createStateSourceHook","options","getState","getResourceId","undefined","suspense","useHook","params","suspender","shouldSuspend","state","useSyncExternalStore","subscribe","getCurrent","useAuthState","getAuthState","createCallbackHook","callback","useHandleCallback","handleCallback","useLoginUrls","useMemo","getLoginUrlsState","fetchLoginUrls","useLogOut","logout"],"mappings":";;;;AAiBO,MAAMA,oBAAoBC,CAAA,eAAA;AAAA,QAAAC,IAAAC,EAAA,CAAA,GAC/BC,iBAAuBC,WAAAC,qBAAgC;AAAC,MAAA,CACnDF;AAAcG,UAAAA,IAAAA,MACD,iEAAiE;AAAA,MAE/EH,eAAcI,WAAa;AAAAD,UAAAA,IAAAA,MACb,2BAA2B;AAEzCH,MAAAA,eAAcI,WAAA,MAAkBP;AAAU,WACrCG,eAAc,CAAA;AAAA,MAAA,CAGlBH;AAAUM,UAAAA,IAAAA,MACG,iEAAiE;AAAAE,MAAAA;AAAA,MAAAP,EAAAD,CAAAA,MAAAA,cAAAC,SAAAE,gBAAA;AAAAM,QAAAA;AAAAR,aAAAD,cAG9CS,KAAAC,UAAUA,KAAIC,SAAAX,eAAyBA,YAAUC,OAAAD,YAAAC,OAAAQ,MAAAA,KAAAR,EAAA,CAAA,GAArEO,KAAAL,eAAcS,KAAMH,EAAiD,GAACR,OAAAD,YAAAC,OAAAE,gBAAAF,OAAAO;AAAAA,EAAA;AAAAA,SAAAP,EAAA,CAAA;AAAvF,QAAAY,WAAiBL;AAAsE,MAAA,CAClFK;AAAQ,UAAA,IAAAP,MACK,mCAAmCN,UAAU,YAAY;AAEpEa,SAAAA;AAAQ;ACpBV,SAASC,sBACdC,SACgC;AAChC,QAAMC,WAAW,OAAOD,WAAY,aAAaA,UAAUA,QAAQC,UAC7DC,gBAAgB,mBAAmBF,UAAUA,QAAQE,gBAAgBC,QACrEC,WAAW,mBAAmBJ,WAAW,eAAeA,UAAUA,UAAUG;AAElF,WAAAE,WAAAZ,IAAA;AAAA,UAAAP,IAAAC,EAAA,CAAA,GAAiBmB,SAAAb;AACXR,QAAAA;AAAkC,QAAAiB,eAAA;AAAAR,UAAAA;AAAAR,eAAAoB,UAEvBZ,MAAAQ,cAAiBI,GAAAA,MAAM,GAACpB,OAAAoB,QAAApB,OAAAQ,OAAAA,MAAAR,EAAA,CAAA,GAArCD,aAAaA;AAAAA,IAAAA;AAEfa,UAAAA,WAAiBd,kBAAkBC,UAAU;AAAC,QAC1CmB,UAAAG,aAAAH,UAAAI,gBAAiDV,UAAaQ,GAAAA,MAAM;AAAC,YACjEF,SAAAG,UAAmBT,UAAQ,GAAKQ,MAAM;AAACZ,QAAAA;AAAAR,MAAAY,CAAAA,MAAAA,YAAAZ,SAAAoB,UAGjCZ,KAAAO,SAASH,UAAQ,GAAKQ,MAAM,GAACpB,OAAAY,UAAAZ,OAAAoB,QAAApB,OAAAQ,MAAAA,KAAAR,EAAA,CAAA;AAA3C,UAAAuB,QAAcf;AAA6B,WACpCgB,qBAAqBD,MAAKE,WAAYF,MAAKG,UAAW;AAAA,EAAA;AAGxDP,SAAAA;AACT;ACdaQ,MAAAA,eAAgCd,sBAAsBe,YAAY;ACpB/DC,SAAAA,mBACdC,UACA/B,YACuC;AACvC,WAAAoB,UAAA;AAAA,UAAAnB,IAAAC,EAAA,CAAA,GACEW,WAAiBd,kBAAAC,UAA4B;AAACQ,QAAAA;AAAAP,WAAAA,SAAAY,YAC3BL,KAAAA,IAAAC,OAAwBsB,SAASlB,UAAQ,GAAxCJ,EAAmD,GAACR,OAAAY,UAAAZ,OAAAO,MAAAA,KAAAP,EAAA,CAAA,GAAjEO;AAAAA,EAAAA;AAGFY,SAAAA;AACT;AC6BaY,MAAAA,oBAAoBF,mBAAmBG,cAAc;ACA3D,SAASC,eAA+B;AACvCrB,QAAAA,WAAWd,qBACX;AAAA,IAAC2B;AAAAA,IAAWC;AAAAA,EAAAA,IAAcQ,QAAQ,MAAMC,kBAAkBvB,QAAQ,GAAG,CAACA,QAAQ,CAAC;AAErF,MAAI,CAACc,WAAAA,EAAc,OAAMU,eAAexB,QAAQ;AAEzCY,SAAAA,qBAAqBC,WAAWC,UAAkC;AAC3E;AC1CaW,MAAAA,YAAYR,mBAAmBS,MAAM;"}

package/dist/components.d.ts

@@ -1,154 +0,0 @@
-import {FallbackProps} from 'react-error-boundary'
-import {ReactElement} from 'react'
-import {ReactNode} from 'react'
-import {SanityConfig} from '@sanity/sdk'
-
-/**
- * A component that handles authentication flow and error boundaries for a
- * protected section of the application.
- *
- * @remarks
- * This component manages different authentication states and renders the
- * appropriate components based on that state.
- *
- * @example
- * ```tsx
- * function App() {
- *   return (
- *     <AuthBoundary header={<MyLogo />}>
- *       <ProtectedContent />
- *     </AuthBoundary>
- *   )
- * }
- * ```
- *
- * @internal
- */
-export declare function AuthBoundary({
-  LoginErrorComponent,
-  ...props
-}: AuthBoundaryProps): React.ReactNode
-
-/**
- * @internal
- */
-declare interface AuthBoundaryProps extends LoginLayoutProps {
-  /**
-   * Custom component to render the login screen.
-   * Receives all login layout props. Defaults to {@link Login}.
-   */
-  LoginComponent?: React.ComponentType<LoginLayoutProps>
-  /**
-   * Custom component to render during OAuth callback processing.
-   * Receives all login layout props. Defaults to {@link LoginCallback}.
-   */
-  CallbackComponent?: React.ComponentType<LoginLayoutProps>
-  /**
-   * Custom component to render when authentication errors occur.
-   * Receives login layout props and error boundary props. Defaults to
-   * {@link LoginError}
-   */
-  LoginErrorComponent?: React.ComponentType<LoginErrorProps>
-}
-
-/**
- * @alpha
- */
-declare type LoginErrorProps = FallbackProps & LoginLayoutProps
-
-/**
- * @alpha
- */
-declare interface LoginLayoutProps {
-  /** Optional header content rendered at top of card */
-  header?: React.ReactNode
-  /** Optional footer content rendered below card. Defaults to an internal login footer */
-  footer?: React.ReactNode
-  /** Main content rendered in card body */
-  children?: React.ReactNode
-}
-
-/**
- * @public
- *
- * The SanityApp component provides your Sanity application with access to your Sanity configuration,
- * as well as application context and state which is used by the Sanity React hooks. Your application
- * must be wrapped with the SanityApp component to function properly.
- *
- * @param props - Your Sanity configuration and the React children to render
- * @returns Your Sanity application, integrated with your Sanity configuration and application context
- *
- * @example
- * ```tsx
- * import { SanityApp } from '@sanity/sdk-react'
- *
- * import MyAppRoot from './Root'
- *
- * // Single project configuration
- * const mySanityConfigs = [
- *   {
- *     projectId: 'my-project-id',
- *     dataset: 'production',
- *   },
- * ]
- *
- * // Or multiple project configurations
- * const multipleConfigs = [
- *   // Configuration for your main project. This will be used as the default project for all hooks if no resource ID override is provided.
- *   {
- *     projectId: 'marketing-website-project',
- *     dataset: 'production',
- *   },
- *   // Configuration for a separate blog project
- *   {
- *     projectId: 'blog-project',
- *     dataset: 'production',
- *   },
- *   // Configuration for a separate ecommerce project
- *   {
- *     projectId: 'ecommerce-project',
- *     dataset: 'production',
- *   }
- * ]
- *
- * export default function MyApp() {
- *   return (
- *     <SanityApp sanityConfigs={mySanityConfigs}>
- *       <MyAppRoot />
- *     </SanityApp>
- *   )
- * }
- * ```
- */
-export declare function SanityApp({sanityConfigs, children, fallback}: SanityAppProps): ReactElement
-
-/**
- * @public
- */
-export declare interface SanityAppProps {
-  sanityConfigs: SanityConfig[]
-  children: React.ReactNode
-  fallback: React.ReactNode
-}
-
-/**
- * @internal
- *
- * Top-level context provider that provides access to the Sanity SDK.
- */
-export declare function SDKProvider({
-  children,
-  sanityConfigs,
-  fallback,
-}: SDKProviderProps): ReactElement
-
-/**
- * @internal
- */
-export declare interface SDKProviderProps {
-  children: ReactNode
-  sanityConfigs: SanityConfig[]
-  fallback: ReactNode
-}
-
-export {}