@sanity/sdk-react 0.0.0-alpha.9 → 0.0.0-rc.1

package/dist/hooks.js

@@ -1,218 +0,0 @@
-import { createStateSourceHook, useSanityInstance, createCallbackHook } from "./_chunks-es/useLogOut.js";
-import { useAuthState, useHandleCallback, useLogOut, useLoginUrls } from "./_chunks-es/useLogOut.js";
-import { getTokenState, getCurrentUserState, getSubscribableClient, getClient, getOrCreateController, getOrCreateChannel, releaseChannel, getOrCreateNode, releaseNode, applyActions, getDocumentState, resolveDocument, subscribeDocumentEvents, getDocumentSyncStatus, editDocument, createDocumentListStore, getPreviewState, resolvePreview } from "@sanity/sdk";
-import { useCallback, useSyncExternalStore, useMemo, useEffect, useRef, useInsertionEffect, useState } from "react";
-import { Observable, startWith, distinctUntilChanged, switchMap, EMPTY } from "rxjs";
-const useAuthToken = createStateSourceHook(getTokenState), useCurrentUser = createStateSourceHook(getCurrentUserState);
-function useClient(options) {
-  const instance = useSanityInstance(), subscribe = useCallback(
-    (onStoreChange) => {
-      const subscription = getSubscribableClient(instance, options).subscribe({
-        next: onStoreChange,
-        error: (error) => {
-          console.error("Error in useClient subscription:", error);
-        }
-      });
-      return () => subscription.unsubscribe();
-    },
-    [instance, options]
-  ), getSnapshot = useCallback(() => getClient(instance, options), [instance, options]);
-  return useSyncExternalStore(subscribe, getSnapshot);
-}
-function useFrameConnection(options) {
-  const { onMessage, targetOrigin, name, connectTo } = options, instance = useSanityInstance(), controller = useMemo(
-    () => getOrCreateController(instance, targetOrigin),
-    [instance, targetOrigin]
-  ), channel = useMemo(
-    () => getOrCreateChannel(instance, {
-      name,
-      connectTo
-    }),
-    [instance, name, connectTo]
-  );
-  useEffect(() => {
-    if (!channel || !onMessage) return;
-    const unsubscribers = [];
-    return Object.entries(onMessage).forEach(([type, handler]) => {
-      const unsubscribe = channel.on(type, handler);
-      unsubscribers.push(unsubscribe);
-    }), () => {
-      unsubscribers.forEach((unsub) => unsub());
-    };
-  }, [channel, onMessage]);
-  const connect = useCallback(
-    (frameWindow) => {
-      const removeTarget = controller?.addTarget(frameWindow);
-      return () => {
-        removeTarget?.();
-      };
-    },
-    [controller]
-  ), sendMessage = useCallback(
-    (type, data) => {
-      channel?.post(type, data);
-    },
-    [channel]
-  );
-  return useEffect(() => () => {
-    releaseChannel(instance, name);
-  }, [name, instance]), {
-    connect,
-    sendMessage
-  };
-}
-function useWindowConnection(options) {
-  const { name, onMessage, connectTo } = options, instance = useSanityInstance(), node = useMemo(
-    () => getOrCreateNode(instance, { name, connectTo }),
-    [instance, name, connectTo]
-  );
-  useEffect(() => {
-    if (!onMessage) return;
-    const unsubscribers = [];
-    return Object.entries(onMessage).forEach(([type, handler]) => {
-      const unsubscribe = node.on(type, handler);
-      unsubscribers.push(unsubscribe);
-    }), () => {
-      unsubscribers.forEach((unsub) => unsub());
-    };
-  }, [node, onMessage]);
-  const sendMessage = useCallback(
-    (type, data) => {
-      node?.post(type, data);
-    },
-    [node]
-  );
-  return useEffect(() => () => {
-    releaseNode(instance, name);
-  }, [instance, name]), {
-    sendMessage
-  };
-}
-function useApplyActions() {
-  return _useApplyActions();
-}
-const _useApplyActions = createCallbackHook(applyActions);
-function useDocument(doc, path) {
-  const documentId = typeof doc == "string" ? doc : doc._id, instance = useSanityInstance();
-  if (!useCallback(
-    () => getDocumentState(instance, documentId).getCurrent() !== void 0,
-    [instance, documentId]
-  )()) throw resolveDocument(instance, documentId);
-  const { subscribe, getCurrent } = useMemo(
-    () => getDocumentState(instance, documentId, path),
-    [documentId, instance, path]
-  );
-  return useSyncExternalStore(subscribe, getCurrent);
-}
-function useDocumentEvent(handler) {
-  const ref = useRef(handler);
-  useInsertionEffect(() => {
-    ref.current = handler;
-  });
-  const stableHandler = useCallback((documentEvent) => ref.current(documentEvent), []), instance = useSanityInstance();
-  useEffect(() => subscribeDocumentEvents(instance, stableHandler), [instance, stableHandler]);
-}
-const useDocumentSyncStatus = createStateSourceHook(getDocumentSyncStatus), ignoredKeys = ["_id", "_type", "_createdAt", "_updatedAt", "_rev"];
-function useEditDocument(doc, path) {
-  const documentId = typeof doc == "string" ? doc : doc._id, instance = useSanityInstance(), apply = useApplyActions();
-  if (!useCallback(
-    () => getDocumentState(instance, documentId).getCurrent() !== void 0,
-    [instance, documentId]
-  )()) throw resolveDocument(instance, documentId);
-  return useCallback(
-    (next) => {
-      if (path)
-        return apply(editDocument(documentId, { set: { [path]: next } }));
-      const current = getDocumentState(instance, documentId).getCurrent();
-      if (typeof next != "object" || !next)
-        throw new Error(
-          "No path was provided to `useEditDocument` and the value provided was not a document object."
-        );
-      const editActions = Object.entries(next).filter(([key]) => !ignoredKeys.includes(key)).filter(([key, value]) => current?.[key] !== value).map(([key, value]) => editDocument(documentId, { set: { [key]: value } }));
-      return apply(editActions);
-    },
-    [apply, documentId, instance, path]
-  );
-}
-const STABLE_EMPTY = {
-  results: [],
-  isPending: !1,
-  hasMore: !1,
-  count: 0
-};
-function useDocuments(options = {}) {
-  const instance = useSanityInstance(), [ref] = useState(() => ({
-    storeInstance: null,
-    getCurrent: () => STABLE_EMPTY,
-    initialOptions: options
-  })), serializedOptions = JSON.stringify(options);
-  useEffect(() => {
-    ref.storeInstance?.setOptions(JSON.parse(serializedOptions));
-  }, [ref, serializedOptions]);
-  const subscribe = useCallback(
-    (onStoreChanged) => {
-      ref.storeInstance = createDocumentListStore(instance), ref.storeInstance.setOptions(ref.initialOptions);
-      const state2 = ref.storeInstance.getState();
-      ref.getCurrent = state2.getCurrent;
-      const unsubscribe = state2.subscribe(onStoreChanged);
-      return () => {
-        unsubscribe(), ref.storeInstance?.dispose();
-      };
-    },
-    [instance, ref]
-  ), getSnapshot = useCallback(() => ref.getCurrent(), [ref]), state = useSyncExternalStore(subscribe, getSnapshot);
-  return { loadMore: useCallback(() => {
-    ref.storeInstance?.loadMore();
-  }, [ref]), ...state };
-}
-function usePreview({ document: { _id, _type }, ref }) {
-  const instance = useSanityInstance(), stateSource = useMemo(
-    () => getPreviewState(instance, { document: { _id, _type } }),
-    [instance, _id, _type]
-  ), subscribe = useCallback(
-    (onStoreChanged) => {
-      const subscription = new Observable((observer) => {
-        if (typeof IntersectionObserver > "u" || typeof HTMLElement > "u")
-          return;
-        const intersectionObserver = new IntersectionObserver(
-          ([entry]) => observer.next(entry.isIntersecting),
-          { rootMargin: "0px", threshold: 0 }
-        );
-        return ref?.current && ref.current instanceof HTMLElement && intersectionObserver.observe(ref.current), () => intersectionObserver.disconnect();
-      }).pipe(
-        startWith(!1),
-        distinctUntilChanged(),
-        switchMap(
-          (isVisible) => isVisible ? new Observable((obs) => stateSource.subscribe(() => obs.next())) : EMPTY
-        )
-      ).subscribe({ next: onStoreChanged });
-      return () => subscription.unsubscribe();
-    },
-    [stateSource, ref]
-  ), getSnapshot = useCallback(() => {
-    const currentState = stateSource.getCurrent();
-    if (currentState.results === null) throw resolvePreview(instance, { document: { _id, _type } });
-    return currentState;
-  }, [_id, _type, instance, stateSource]);
-  return useSyncExternalStore(subscribe, getSnapshot);
-}
-export {
-  useApplyActions,
-  useAuthState,
-  useAuthToken,
-  useClient,
-  useCurrentUser,
-  useDocument,
-  useDocumentEvent,
-  useDocumentSyncStatus,
-  useDocuments,
-  useEditDocument,
-  useFrameConnection,
-  useHandleCallback,
-  useLogOut,
-  useLoginUrls,
-  usePreview,
-  useSanityInstance,
-  useWindowConnection
-};
-//# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.js","sources":["../src/hooks/auth/useAuthToken.tsx","../src/hooks/auth/useCurrentUser.tsx","../src/hooks/client/useClient.ts","../src/hooks/comlink/useFrameConnection.ts","../src/hooks/comlink/useWindowConnection.ts","../src/hooks/document/useApplyActions.ts","../src/hooks/document/useDocument.ts","../src/hooks/document/useDocumentEvent.ts","../src/hooks/document/useDocumentSyncStatus.ts","../src/hooks/document/useEditDocument.ts","../src/hooks/documentCollection/useDocuments.ts","../src/hooks/preview/usePreview.tsx"],"sourcesContent":["import {getTokenState} from '@sanity/sdk'\n\nimport {createStateSourceHook} from '../helpers/createStateSourceHook'\n\n/**\n * Hook to get the currently logged in user\n * @internal\n * @returns The current user or null if not authenticated\n */\nexport const useAuthToken = createStateSourceHook(getTokenState)\n","import {type CurrentUser, getCurrentUserState} from '@sanity/sdk'\n\nimport {createStateSourceHook} from '../helpers/createStateSourceHook'\n\n/**\n * @TODO This should suspend! And possibly not return `null`?\n *\n * @public\n *\n * The `useCurrentUser` hook returns the currently authenticated user’s profile information (their name, email, roles, etc).\n * If no users are currently logged in, the hook returns null.\n *\n * @returns The current user data, or `null` if not authenticated\n *\n * @example Rendering a basic user profile\n * ```\n * const user = useCurrentUser()\n *\n * return (\n *   <figure>\n *     <img src={user?.profileImage} alt=`Profile image for ${user?.name}` />\n *     <h2>{user?.name}</h2>\n *   </figure>\n * )\n * ```\n */\nexport const useCurrentUser: () => CurrentUser | null = createStateSourceHook(getCurrentUserState)\n","import {type SanityClient} from '@sanity/client'\nimport {type ClientOptions, getClient, getSubscribableClient} from '@sanity/sdk'\nimport {useCallback, useSyncExternalStore} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\n/**\n * A React hook that provides a client that subscribes to changes in your application,\n * such as user authentication changes.\n *\n * @remarks\n * The hook uses `useSyncExternalStore` to safely subscribe to changes\n * and ensure consistency between server and client rendering.\n *\n * @returns A Sanity client\n *\n * @example\n * ```tsx\n * function MyComponent() {\n *   const client = useClient()\n *   const [document, setDocument] = useState(null)\n *   useEffect(async () => {\n *     const doc = client.fetch('*[_id == \"myDocumentId\"]')\n *     setDocument(doc)\n *   }, [])\n *  return <div>{JSON.stringify(document) ?? 'Loading...'}</div>\n * }\n * ```\n *\n * @public\n */\nexport function useClient(options: ClientOptions): SanityClient {\n  const instance = useSanityInstance()\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => {\n      const client$ = getSubscribableClient(instance, options)\n      const subscription = client$.subscribe({\n        next: onStoreChange,\n        error: (error) => {\n          // @TODO: We should tackle error handling / error boundaries soon\n          // eslint-disable-next-line no-console\n          console.error('Error in useClient subscription:', error)\n        },\n      })\n      return () => subscription.unsubscribe()\n    },\n    [instance, options],\n  )\n\n  const getSnapshot = useCallback(() => {\n    return getClient(instance, options)\n  }, [instance, options])\n\n  return useSyncExternalStore(subscribe, getSnapshot)\n}\n","import {\n  type FrameMessage,\n  getOrCreateChannel,\n  getOrCreateController,\n  releaseChannel,\n  type WindowMessage,\n} from '@sanity/sdk'\nimport {useCallback, useEffect, useMemo} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\n/**\n * @internal\n */\nexport type FrameMessageHandler<TWindowMessage extends WindowMessage> = (\n  event: TWindowMessage['data'],\n) => TWindowMessage['response'] | Promise<TWindowMessage['response']>\n\n/**\n * @internal\n */\nexport interface UseFrameConnectionOptions<TWindowMessage extends WindowMessage> {\n  name: string\n  connectTo: string\n  targetOrigin: string\n  onMessage?: Record<string, FrameMessageHandler<TWindowMessage>>\n}\n\n/**\n * @internal\n */\nexport interface FrameConnection<TFrameMessage extends FrameMessage> {\n  connect: (frameWindow: Window) => () => void // Return cleanup function\n  sendMessage: <T extends TFrameMessage['type']>(\n    ...params: Extract<TFrameMessage, {type: T}>['data'] extends undefined\n      ? [type: T]\n      : [type: T, data: Extract<TFrameMessage, {type: T}>['data']]\n  ) => void\n}\n\n/**\n * @internal\n */\nexport function useFrameConnection<\n  TFrameMessage extends FrameMessage,\n  TWindowMessage extends WindowMessage,\n>(options: UseFrameConnectionOptions<TWindowMessage>): FrameConnection<TFrameMessage> {\n  const {onMessage, targetOrigin, name, connectTo} = options\n  const instance = useSanityInstance()\n\n  const controller = useMemo(\n    () => getOrCreateController(instance, targetOrigin),\n    [instance, targetOrigin],\n  )\n\n  const channel = useMemo(\n    () =>\n      getOrCreateChannel(instance, {\n        name,\n        connectTo,\n      }),\n    [instance, name, connectTo],\n  )\n\n  useEffect(() => {\n    if (!channel || !onMessage) return\n\n    const unsubscribers: Array<() => void> = []\n\n    Object.entries(onMessage).forEach(([type, handler]) => {\n      const unsubscribe = channel.on(type, handler)\n      unsubscribers.push(unsubscribe)\n    })\n\n    return () => {\n      unsubscribers.forEach((unsub) => unsub())\n    }\n  }, [channel, onMessage])\n\n  const connect = useCallback(\n    (frameWindow: Window) => {\n      const removeTarget = controller?.addTarget(frameWindow)\n      return () => {\n        removeTarget?.()\n      }\n    },\n    [controller],\n  )\n\n  const sendMessage = useCallback(\n    <T extends TFrameMessage['type']>(\n      type: T,\n      data?: Extract<TFrameMessage, {type: T}>['data'],\n    ) => {\n      channel?.post(type, data)\n    },\n    [channel],\n  )\n\n  // cleanup channel on unmount\n  useEffect(() => {\n    return () => {\n      releaseChannel(instance, name)\n    }\n  }, [name, instance])\n\n  return {\n    connect,\n    sendMessage,\n  }\n}\n","import {type FrameMessage, getOrCreateNode, releaseNode, type WindowMessage} from '@sanity/sdk'\nimport {useCallback, useEffect, useMemo} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\n/**\n * @internal\n */\nexport type WindowMessageHandler<TFrameMessage extends FrameMessage> = (\n  event: TFrameMessage['data'],\n) => TFrameMessage['response']\n\n/**\n * @internal\n */\nexport interface UseWindowConnectionOptions<TMessage extends FrameMessage> {\n  name: string\n  connectTo: string\n  onMessage?: Record<TMessage['type'], WindowMessageHandler<TMessage>>\n}\n\n/**\n * @internal\n */\nexport interface WindowConnection<TMessage extends WindowMessage> {\n  sendMessage: <TType extends TMessage['type']>(\n    type: TType,\n    data?: Extract<TMessage, {type: TType}>['data'],\n  ) => void\n}\n\n/**\n * @internal\n */\nexport function useWindowConnection<\n  TWindowMessage extends WindowMessage,\n  TFrameMessage extends FrameMessage,\n>(options: UseWindowConnectionOptions<TFrameMessage>): WindowConnection<TWindowMessage> {\n  const {name, onMessage, connectTo} = options\n  const instance = useSanityInstance()\n\n  const node = useMemo(\n    () => getOrCreateNode(instance, {name, connectTo}),\n    [instance, name, connectTo],\n  )\n\n  useEffect(() => {\n    if (!onMessage) return\n\n    const unsubscribers: Array<() => void> = []\n\n    Object.entries(onMessage).forEach(([type, handler]) => {\n      const unsubscribe = node.on(type, handler as WindowMessageHandler<TFrameMessage>)\n      unsubscribers.push(unsubscribe)\n    })\n\n    return () => {\n      unsubscribers.forEach((unsub) => unsub())\n    }\n  }, [node, onMessage])\n\n  const sendMessage = useCallback(\n    <TType extends WindowMessage['type']>(\n      type: TType,\n      data?: Extract<WindowMessage, {type: TType}>['data'],\n    ) => {\n      node?.post(type, data)\n    },\n    [node],\n  )\n\n  // cleanup node on unmount\n  useEffect(() => {\n    return () => {\n      releaseNode(instance, name)\n    }\n  }, [instance, name])\n\n  return {\n    sendMessage,\n  }\n}\n","import {\n  type ActionsResult,\n  applyActions,\n  type ApplyActionsOptions,\n  type DocumentAction,\n} from '@sanity/sdk'\nimport {type SanityDocument} from '@sanity/types'\n\nimport {createCallbackHook} from '../helpers/createCallbackHook'\n\n/** @beta */\nexport function useApplyActions(): <TDocument extends SanityDocument>(\n  action: DocumentAction<TDocument> | DocumentAction<TDocument>[],\n  options?: ApplyActionsOptions,\n) => Promise<ActionsResult<TDocument>>\n/** @beta */\nexport function useApplyActions(): (\n  action: DocumentAction | DocumentAction[],\n  options?: ApplyActionsOptions,\n) => Promise<ActionsResult> {\n  return _useApplyActions()\n}\n\nconst _useApplyActions = createCallbackHook(applyActions)\n","import {\n  type DocumentHandle,\n  getDocumentState,\n  type JsonMatch,\n  type JsonMatchPath,\n  resolveDocument,\n} from '@sanity/sdk'\nimport {type SanityDocument} from '@sanity/types'\nimport {useCallback, useMemo, useSyncExternalStore} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\n/** @beta */\nexport function useDocument<\n  TDocument extends SanityDocument,\n  TPath extends JsonMatchPath<TDocument>,\n>(doc: string | DocumentHandle<TDocument>, path: TPath): JsonMatch<TDocument, TPath> | undefined\n/** @beta */\nexport function useDocument<TDocument extends SanityDocument>(\n  doc: string | DocumentHandle<TDocument>,\n): TDocument | null\n/** @beta */\nexport function useDocument(doc: string | DocumentHandle, path?: string): unknown {\n  const documentId = typeof doc === 'string' ? doc : doc._id\n  const instance = useSanityInstance()\n  const isDocumentReady = useCallback(\n    () => getDocumentState(instance, documentId).getCurrent() !== undefined,\n    [instance, documentId],\n  )\n  if (!isDocumentReady()) throw resolveDocument(instance, documentId)\n\n  const {subscribe, getCurrent} = useMemo(\n    () => getDocumentState(instance, documentId, path),\n    [documentId, instance, path],\n  )\n\n  return useSyncExternalStore(subscribe, getCurrent)\n}\n","import {type DocumentEvent, subscribeDocumentEvents} from '@sanity/sdk'\nimport {useCallback, useEffect, useInsertionEffect, useRef} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\n/** @beta */\nexport function useDocumentEvent(handler: (documentEvent: DocumentEvent) => void): void {\n  const ref = useRef(handler)\n\n  useInsertionEffect(() => {\n    ref.current = handler\n  })\n\n  const stableHandler = useCallback((documentEvent: DocumentEvent) => {\n    return ref.current(documentEvent)\n  }, [])\n\n  const instance = useSanityInstance()\n  useEffect(() => {\n    return subscribeDocumentEvents(instance, stableHandler)\n  }, [instance, stableHandler])\n}\n","import {getDocumentSyncStatus} from '@sanity/sdk'\n\nimport {createStateSourceHook} from '../helpers/createStateSourceHook'\n\n/** @beta */\nexport const useDocumentSyncStatus = createStateSourceHook(getDocumentSyncStatus)\n","import {\n  type ActionsResult,\n  type DocumentHandle,\n  editDocument,\n  getDocumentState,\n  type JsonMatch,\n  type JsonMatchPath,\n  resolveDocument,\n} from '@sanity/sdk'\nimport {type SanityDocument} from '@sanity/types'\nimport {useCallback} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\nimport {useApplyActions} from './useApplyActions'\n\nconst ignoredKeys = ['_id', '_type', '_createdAt', '_updatedAt', '_rev']\n\n/** @beta */\nexport function useEditDocument<\n  TDocument extends SanityDocument,\n  TPath extends JsonMatchPath<TDocument>,\n>(\n  doc: string | DocumentHandle<TDocument>,\n  path: TPath,\n): (nextValue: JsonMatch<TDocument, TPath>) => Promise<ActionsResult<TDocument>>\n/** @beta */\nexport function useEditDocument<TDocument extends SanityDocument>(\n  doc: string | DocumentHandle<TDocument>,\n): (nextValue: Partial<TDocument>) => Promise<ActionsResult<TDocument>>\n/** @beta */\nexport function useEditDocument(\n  doc: string | DocumentHandle,\n  path?: string,\n): (nextValue: unknown) => Promise<ActionsResult> {\n  const documentId = typeof doc === 'string' ? doc : doc._id\n  const instance = useSanityInstance()\n  const apply = useApplyActions()\n  const isDocumentReady = useCallback(\n    () => getDocumentState(instance, documentId).getCurrent() !== undefined,\n    [instance, documentId],\n  )\n  if (!isDocumentReady()) throw resolveDocument(instance, documentId)\n\n  return useCallback(\n    (next: unknown) => {\n      if (path) {\n        return apply(editDocument(documentId, {set: {[path]: next}}))\n      }\n\n      const current = getDocumentState(instance, documentId).getCurrent()\n\n      if (typeof next !== 'object' || !next) {\n        throw new Error(\n          `No path was provided to \\`useEditDocument\\` and the value provided was not a document object.`,\n        )\n      }\n\n      const editActions = Object.entries(next)\n        .filter(([key]) => !ignoredKeys.includes(key))\n        .filter(([key, value]) => current?.[key] !== value)\n        .map(([key, value]) => editDocument(documentId, {set: {[key]: value}}))\n\n      return apply(editActions)\n    },\n    [apply, documentId, instance, path],\n  )\n}\n","import {createDocumentListStore, type DocumentHandle, type DocumentListOptions} from '@sanity/sdk'\nimport {useCallback, useEffect, useState, useSyncExternalStore} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\n/**\n * @public\n */\nexport interface DocumentCollection {\n  /** Retrieve more documents matching the provided options */\n  loadMore: () => void\n  /** The retrieved document handles of the documents matching the provided options */\n  results: DocumentHandle[]\n  /** Whether a retrieval of documents is in flight */\n  isPending: boolean\n  /** Whether more documents exist that match the provided options than have been retrieved */\n  hasMore: boolean\n  /** The total number of documents in the collection */\n  count: number\n}\n\ntype DocumentListStore = ReturnType<typeof createDocumentListStore>\ntype DocumentListState = ReturnType<DocumentListStore['getState']>['getCurrent']\nconst STABLE_EMPTY = {\n  results: [],\n  isPending: false,\n  hasMore: false,\n  count: 0,\n}\n\n/**\n * @public\n *\n * The `useDocuments` hook retrieves and provides access to a live collection of documents, optionally filtered, sorted, and matched to a given Content Lake perspective.\n * Because the returned document collection is live, the results will update in real time until the component invoking the hook is unmounted.\n *\n * @param options - Options for narrowing and sorting the document collection\n * @returns The collection of documents matching the provided options (if any), as well as properties describing the collection and a function to load more.\n *\n * @example Retrieving all documents of type 'movie'\n * ```\n * const { results, isPending } = useDocuments({ filter: '_type == \"movie\"' })\n *\n * return (\n *   <div>\n *     <h1>Movies</h1>\n *     {results && (\n *       <ul>\n *         {results.map(movie => (<li key={movie._id}>…</li>))}\n *       </ul>\n *     )}\n *     {isPending && <div>Loading movies…</div>}\n *   </div>\n * )\n * ```\n *\n * @example Retrieving all movies released since 1980, sorted by director’s last name\n * ```\n * const { results } = useDocuments({\n *   filter: '_type == \"movie\" && releaseDate >= \"1980-01-01\"',\n *   sort: [\n *     {\n *       // Expand the `director` reference field with the dereferencing operator `->`\n *       field: 'director->lastName',\n *       sort: 'asc',\n *     },\n *   ],\n * })\n *\n * return (\n *   <div>\n *      <h1>Movies released since 1980</h1>\n *      {results && (\n *        <ol>\n *          {results.map(movie => (<li key={movie._id}>…</li>))}\n *        </ol>\n *     )}\n *   </div>\n * )\n * ```\n */\nexport function useDocuments(options: DocumentListOptions = {}): DocumentCollection {\n  const instance = useSanityInstance()\n\n  // NOTE: useState is used because it guaranteed to return a stable reference\n  // across renders\n  const [ref] = useState<{\n    storeInstance: DocumentListStore | null\n    getCurrent: DocumentListState\n    initialOptions: DocumentListOptions\n  }>(() => ({\n    storeInstance: null,\n    getCurrent: () => STABLE_EMPTY,\n    initialOptions: options,\n  }))\n\n  // serialize options to ensure it only calls `setOptions` when the values\n  // themselves changes (in cases where devs put config inline)\n  const serializedOptions = JSON.stringify(options)\n  useEffect(() => {\n    ref.storeInstance?.setOptions(JSON.parse(serializedOptions))\n  }, [ref, serializedOptions])\n\n  const subscribe = useCallback(\n    (onStoreChanged: () => void) => {\n      // to match the lifecycle of `useSyncExternalState`, we create the store\n      // instance after subscribe and mutate the ref to connect everything\n      ref.storeInstance = createDocumentListStore(instance)\n      ref.storeInstance.setOptions(ref.initialOptions)\n      const state = ref.storeInstance.getState()\n      ref.getCurrent = state.getCurrent\n      const unsubscribe = state.subscribe(onStoreChanged)\n\n      return () => {\n        // unsubscribe to clean up the state subscriptions\n        unsubscribe()\n        // dispose of the instance\n        ref.storeInstance?.dispose()\n      }\n    },\n    [instance, ref],\n  )\n\n  const getSnapshot = useCallback(() => {\n    return ref.getCurrent()\n  }, [ref])\n\n  const state = useSyncExternalStore(subscribe, getSnapshot)\n\n  const loadMore = useCallback(() => {\n    ref.storeInstance?.loadMore()\n  }, [ref])\n\n  return {loadMore, ...state}\n}\n","import {type DocumentHandle, getPreviewState, type PreviewValue, resolvePreview} from '@sanity/sdk'\nimport {useCallback, useMemo, useSyncExternalStore} from 'react'\nimport {distinctUntilChanged, EMPTY, Observable, startWith, switchMap} from 'rxjs'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\n/**\n * @alpha\n */\nexport interface UsePreviewOptions {\n  document: DocumentHandle\n  ref?: React.RefObject<unknown>\n}\n\n/**\n * @alpha\n */\nexport interface UsePreviewResults {\n  /** The results of resolving the document’s preview values */\n  results: PreviewValue\n  /** True when preview values are being refreshed */\n  isPending: boolean\n}\n\n/**\n * @alpha\n *\n * The `usePreview` hook takes a document (via a `DocumentHandle`) and returns its resolved preview values,\n * including the document’s `title`, `subtitle`, `media`, and `status`. These values are live and will update in realtime.\n * To reduce unnecessary network requests for resolving the preview values, an optional `ref` can be passed to the hook so that preview\n * resolution will only occur if the `ref` is intersecting the current viewport.\n *\n * @param options - The document handle for the document you want to resolve preview values for, and an optional ref\n * @returns The preview values for the given document and a boolean to indicate whether the resolution is pending\n *\n * @example Combining with useDocuments to render a collection of document previews\n * ```\n * // PreviewComponent.jsx\n * export default function PreviewComponent({ document }) {\n *   const { results: { title, subtitle, media }, isPending } = usePreview({ document })\n *   return (\n *     <article style={{ opacity: isPending ? 0.5 : 1}}>\n *       {media?.type === 'image-asset' ? <img src={media.url} alt='' /> : ''}\n *       <h2>{title}</h2>\n *       <p>{subtitle}</p>\n *     </article>\n *   )\n * }\n *\n * // DocumentList.jsx\n * const { results, isPending } = useDocuments({ filter: '_type == \"movie\"' })\n * return (\n *   <div>\n *     <h1>Movies</h1>\n *     <ul>\n *       {isPending ? 'Loading…' : results.map(movie => (\n *         <li key={movie._id}>\n *           <Suspense fallback='Loading…'>\n *             <PreviewComponent document={movie} />\n *           </Suspense>\n *         </li>\n *       ))}\n *     </ul>\n *   </div>\n * )\n * ```\n */\nexport function usePreview({document: {_id, _type}, ref}: UsePreviewOptions): UsePreviewResults {\n  const instance = useSanityInstance()\n\n  const stateSource = useMemo(\n    () => getPreviewState(instance, {document: {_id, _type}}),\n    [instance, _id, _type],\n  )\n\n  // Create subscribe function for useSyncExternalStore\n  const subscribe = useCallback(\n    (onStoreChanged: () => void) => {\n      const subscription = new Observable<boolean>((observer) => {\n        // for environments that don't have an intersection observer\n        if (typeof IntersectionObserver === 'undefined' || typeof HTMLElement === 'undefined') {\n          return\n        }\n\n        const intersectionObserver = new IntersectionObserver(\n          ([entry]) => observer.next(entry.isIntersecting),\n          {rootMargin: '0px', threshold: 0},\n        )\n        if (ref?.current && ref.current instanceof HTMLElement) {\n          intersectionObserver.observe(ref.current)\n        }\n        return () => intersectionObserver.disconnect()\n      })\n        .pipe(\n          startWith(false),\n          distinctUntilChanged(),\n          switchMap((isVisible) =>\n            isVisible\n              ? new Observable<void>((obs) => {\n                  return stateSource.subscribe(() => obs.next())\n                })\n              : EMPTY,\n          ),\n        )\n        .subscribe({next: onStoreChanged})\n\n      return () => subscription.unsubscribe()\n    },\n    [stateSource, ref],\n  )\n\n  // Create getSnapshot function to return current state\n  const getSnapshot = useCallback(() => {\n    const currentState = stateSource.getCurrent()\n    if (currentState.results === null) throw resolvePreview(instance, {document: {_id, _type}})\n    return currentState as UsePreviewResults\n  }, [_id, _type, instance, stateSource])\n\n  return useSyncExternalStore(subscribe, getSnapshot)\n}\n"],"names":["state"],"mappings":"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"}

package/src/_exports/components.ts

@@ -1,2 +0,0 @@
-export {AuthBoundary} from '../components/auth/AuthBoundary'
-export {SanityApp, type SanityAppProps} from '../components/SanityApp'

package/src/_exports/context.ts

@@ -1,2 +0,0 @@
-export type {SanityProviderProps} from '../context/SanityProvider'
-export {SanityProvider} from '../context/SanityProvider'

package/src/_exports/hooks.ts

@@ -1,32 +0,0 @@
-export {useAuthState} from '../hooks/auth/useAuthState'
-export {useAuthToken} from '../hooks/auth/useAuthToken'
-export {useCurrentUser} from '../hooks/auth/useCurrentUser'
-export {useHandleCallback} from '../hooks/auth/useHandleCallback'
-export {useLoginUrls} from '../hooks/auth/useLoginUrls'
-export {useLogOut} from '../hooks/auth/useLogOut'
-export {useClient} from '../hooks/client/useClient'
-export {
-  type FrameConnection,
-  type FrameMessageHandler as MessageHandler,
-  useFrameConnection,
-  type UseFrameConnectionOptions,
-} from '../hooks/comlink/useFrameConnection'
-export {
-  useWindowConnection,
-  type UseWindowConnectionOptions,
-  type WindowConnection,
-  type WindowMessageHandler,
-} from '../hooks/comlink/useWindowConnection'
-export {useSanityInstance} from '../hooks/context/useSanityInstance'
-export {useApplyActions} from '../hooks/document/useApplyActions'
-export {useDocument} from '../hooks/document/useDocument'
-export {useDocumentEvent} from '../hooks/document/useDocumentEvent'
-export {useDocumentSyncStatus} from '../hooks/document/useDocumentSyncStatus'
-export {useEditDocument} from '../hooks/document/useEditDocument'
-export {type DocumentCollection, useDocuments} from '../hooks/documentCollection/useDocuments'
-export {
-  usePreview,
-  type UsePreviewOptions,
-  type UsePreviewResults,
-} from '../hooks/preview/usePreview'
-export {type CurrentUser} from '@sanity/sdk'

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, type 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()
-  })
-})