@sanity/sdk-react 3.11.0-next.20261029105031 → 3.11.0

package/README.md

@@ -798,15 +798,18 @@ function DocStatus({handle}: {handle: DocumentHandle}) {
 
 ## Quick Reference
 
-| Task                  | Hook/Function                               |
-| --------------------- | ------------------------------------------- |
-| List documents        | `useDocuments`, `usePaginatedDocuments`     |
-| Read document         | `useDocument`, `useDocumentProjection`      |
-| Edit field            | `useEditDocument`                           |
-| Publish/Delete/Create | `useApplyDocumentActions` + action creators |
-| GROQ query            | `useQuery`                                  |
-| Check permissions     | `useDocumentPermissions`                    |
-| Listen to changes     | `useDocumentEvent`                          |
+| Task                  | Hook/Function                                                                                                       |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| List documents        | `useDocuments`, `usePaginatedDocuments`                                                                             |
+| Read document         | `useDocument`, `useDocumentProjection`                                                                              |
+| Edit field            | `useEditDocument`                                                                                                   |
+| Publish/Delete/Create | `useApplyDocumentActions` + action creators                                                                         |
+| GROQ query            | `useQuery`                                                                                                          |
+| Check permissions     | `useDocumentPermissions`                                                                                            |
+| Listen to changes     | `useDocumentEvent`                                                                                                  |
+| Comments              | `useComments`, `useCommentThreads`, `useCommentsQuery`, `useCommentActions`, from `@sanity/sdk-react/collaboration` |
+
+Comments have their own guide: [Collaboration](./guides/Collaboration.md).
 
 ---
 
@@ -815,6 +818,7 @@ function DocStatus({handle}: {handle: DocumentHandle}) {
 - **[Sanity Docs](https://sanity.io/docs/app-sdk)** — Conceptual overview, quickstart guide, and step-by-step walkthrough
 - **[App SDK Reference](https://reference.sanity.io/_sanity/sdk-react)** — In-depth API documentation
 - **[SDK Explorer](https://sdk-explorer.sanity.io)** — Example implementations
+- **[Collaboration Guide](./guides/Collaboration.md)** — Reading and writing comments
 - **[Migration Guide](./guides/0-Migration-Guide.md)** — Upgrading from previous versions
 - **[Learn Course](https://www.sanity.io/learn/course/build-content-apps-with-sanity-app-sdk)** — Interactive video tutorial
 

package/dist/_exports/collaboration.d.ts

@@ -0,0 +1,255 @@
+import { t as WithResourceNameSupport } from "../useNormalizedResourceOptions-BKg7aOKA.js";
+import { Comment, CommentThread, CommentsOptions, CommentsQueryOptions, CreateCommentOptions, ReactionOptions, RemoveCommentOptions, ReplyToCommentOptions, SetCommentStatusOptions, UpdateCommentAnchorOptions, UpdateCommentOptions } from "@sanity/sdk/collaboration";
+export * from "@sanity/sdk/collaboration";
+/**
+ * @beta
+ * @category Types
+ * @category Comments
+ */
+interface CommentActions {
+  /** Starts a thread on one of a document's fields. */
+  createComment: (options: WithResourceNameSupport<CreateCommentOptions>) => Promise<Comment>;
+  /** Adds a reply to an existing thread. */
+  replyToComment: (options: WithResourceNameSupport<ReplyToCommentOptions>) => Promise<Comment>;
+  /** Rewrites a comment's message. */
+  updateComment: (options: WithResourceNameSupport<UpdateCommentOptions>) => Promise<void>;
+  /**
+   * Re-anchors a comment to a different run of text, without marking it edited.
+   */
+  updateCommentAnchor: (options: WithResourceNameSupport<UpdateCommentAnchorOptions>) => Promise<void>;
+  /** Resolves or reopens a thread. Pass the thread's first comment. */
+  setCommentStatus: (options: WithResourceNameSupport<SetCommentStatusOptions>) => Promise<void>;
+  /** Deletes a comment, and its replies when it starts a thread. */
+  removeComment: (options: WithResourceNameSupport<RemoveCommentOptions>) => Promise<void>;
+  /** Adds the current user's reaction to a comment. */
+  addReaction: (options: WithResourceNameSupport<ReactionOptions>) => Promise<void>;
+  /** Removes the current user's reaction from a comment. */
+  removeReaction: (options: WithResourceNameSupport<ReactionOptions>) => Promise<void>;
+}
+/**
+ * Returns the comment write actions, bound to the current instance.
+ *
+ * Each writes optimistically: the change shows immediately and is rolled back
+ * if the server rejects it, so an app can render straight from
+ * {@link useCommentThreads} without tracking pending state itself.
+ *
+ * Creating is the exception, and `replyToComment` counts as creating. A comment
+ * that fails to post stays on screen carrying `state.createError` rather than
+ * disappearing, so passing the same `commentId` again retries it instead of
+ * losing what someone typed.
+ *
+ * The resource is resolved when an action is called rather than when the hook
+ * runs, so one set of callbacks works across several resources. Pass `resource`
+ * or `resourceName` per call to choose; otherwise the surrounding
+ * `ResourceProvider` decides. The organization the comments live in is
+ * resolved per call as well: the one the Dashboard opened the app in, else
+ * `organizationId` on the Sanity config, else the organization owning the
+ * resource's project. It cannot be passed on the call.
+ *
+ * @category Comments
+ * @function
+ * @returns The write actions
+ *
+ * @example Resolve a thread
+ * ```tsx
+ * function ResolveButton({commentId}: {commentId: string}) {
+ *   const {setCommentStatus} = useCommentActions()
+ *
+ *   return (
+ *     <button onClick={() => setCommentStatus({commentId, status: 'resolved'})}>
+ *       Resolve
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @beta
+ */
+export declare function useCommentActions(): CommentActions;
+/**
+ * @beta
+ * @category Types
+ * @category Comments
+ */
+interface UseCommentsResult {
+  /** Every matching comment, newest first, replies included. */
+  comments: Comment[];
+  /** True while switching to a different document or filter. */
+  isPending: boolean;
+  /**
+   * Set when the comments have stopped following the server: the listener
+   * failed after they had loaded, so what you are reading is the list as it
+   * last stood rather than as it is. Clears when a listener comes back.
+   */
+  error?: unknown;
+}
+/**
+ * Reads a document's comments and keeps them up to date.
+ *
+ * The list is flat, replies included, which suits a count or a feed. Reach for
+ * {@link useCommentThreads} to read the same comments grouped, where a reply
+ * sits under the comment it answers and filtering by `status` or `fieldPath`
+ * selects whole threads rather than individual comments. Both read the same
+ * document and share a listener, so using them side by side costs nothing
+ * extra. {@link useCommentsQuery} covers anything that is not one document's
+ * comments.
+ *
+ * Suspends until the comments have loaded. Switching document or filter is a
+ * transition, so the previous list stays on screen and `isPending` goes true
+ * rather than the component suspending again.
+ *
+ * @category Comments
+ * @function
+ * @param options - The document to read, optionally narrowed by `fieldPath`, `status`, or `scope`
+ * @returns The matching comments, and whether a switch is in flight
+ *
+ * @example Count the open comments on a field
+ * ```tsx
+ * function TitleCommentCount({documentId}: {documentId: string}) {
+ *   const {comments} = useComments({
+ *     documentId,
+ *     documentType: 'article',
+ *     fieldPath: 'title',
+ *     status: 'open',
+ *   })
+ *
+ *   return <span>{comments.length}</span>
+ * }
+ * ```
+ *
+ * @beta
+ */
+export declare function useComments(options: WithResourceNameSupport<CommentsOptions>): UseCommentsResult;
+/**
+ * @beta
+ * @category Types
+ */
+interface UseCommentsQueryResult {
+  /** Every matching comment, newest first, replies included. */
+  comments: Comment[];
+  /** True while switching to a different filter. */
+  isPending: boolean;
+  /**
+   * Set when the comments have stopped following the server: the listener
+   * failed after they had loaded, so what you are reading is the list as it
+   * last stood rather than as it is. Clears when a listener comes back.
+   */
+  error?: unknown;
+}
+/**
+ * Reads comments matching a GROQ filter and keeps them up to date.
+ *
+ * The escape hatch for anything that is not "comments on this document":
+ * cross-document views, per-user views, organization-wide activity. The list is
+ * flat, replies included; reach for {@link useCommentThreads} to read one
+ * document's comments grouped into threads.
+ *
+ * `_type == "sanity.comment"` is applied for you. Comments are stored per
+ * organization, resolved rather than configured: the one the Dashboard opened
+ * the app in, else `organizationId` on the Sanity config, else the organization
+ * owning the resource's project. The filter runs over every comment that
+ * organization can read, not only the ones in the resource's dataset: comment
+ * queries are routed by organization and the resource is not sent with them.
+ * To keep to one dataset, add a `target.document._ref` prefix condition
+ * yourself. Refs are `dataset:{projectId}.{dataset}:{documentId}`.
+ *
+ * Suspends until the comments have loaded. Switching filter is a transition, so
+ * the previous list stays on screen and `isPending` goes true rather than the
+ * component suspending again.
+ *
+ * Writes show here before the server confirms them, the same as they do on a
+ * document's comments, because the filter is matched against the written
+ * comment locally. That holds for writes through the resource the query is
+ * bound to; comments written through another dataset arrive once the server
+ * confirms them. A filter that cannot be answered that way — one that
+ * dereferences, runs a `*[...]` of its own, or calls a context-dependent
+ * function such as `sanity::dataset()` or `now()` — still works, but only
+ * follows the server, and costs a connection of its own rather than sharing one.
+ *
+ * @category Comments
+ * @function
+ * @param options - The GROQ `filter` to match, and any `params` it reads
+ * @returns The matching comments, and whether a switch is in flight
+ *
+ * @example Every comment mentioning the current user
+ * ```tsx
+ * function Mentions({userId}: {userId: string}) {
+ *   const {comments} = useCommentsQuery({
+ *     filter: 'count(message[].children[_type == "mention" && userId == $userId]) > 0',
+ *     params: {userId},
+ *   })
+ *
+ *   return <span>{comments.length}</span>
+ * }
+ * ```
+ *
+ * @example Open comments in one dataset
+ * ```tsx
+ * function OpenInProduction() {
+ *   const {comments} = useCommentsQuery({
+ *     filter: 'string::startsWith(target.document._ref, $prefix) && status == "open"',
+ *     params: {prefix: 'dataset:abc123.production:'},
+ *   })
+ *
+ *   return <span>{comments.length}</span>
+ * }
+ * ```
+ *
+ * @beta
+ */
+export declare function useCommentsQuery(options: WithResourceNameSupport<CommentsQueryOptions>): UseCommentsQueryResult;
+/**
+ * @beta
+ * @category Types
+ * @category Comments
+ */
+interface UseCommentThreadsResult {
+  /** Matching threads, newest first, each with its replies oldest first. */
+  threads: CommentThread[];
+  /** True while switching to a different document or filter. */
+  isPending: boolean;
+  /**
+   * Set when the threads have stopped following the server: the listener
+   * failed after they had loaded, so what you are reading is the list as it
+   * last stood rather than as it is. Clears when a listener comes back.
+   */
+  error?: unknown;
+}
+/**
+ * Reads a document's comment threads and keeps them up to date.
+ *
+ * A thread carries its first comment plus its replies, and `status` and
+ * `fieldPath` come from that first comment, so filtering by either selects
+ * whole threads. Use {@link useComments} to read the same list flat, `scope` to
+ * say which of the document's comments to cover — by default it follows the
+ * perspective in view — and {@link useCommentsQuery} when the question is not
+ * "comments on this document".
+ *
+ * Suspends until the comments have loaded. Switching document or filter is a
+ * transition, so the previous list stays on screen and `isPending` goes true
+ * rather than the component suspending again.
+ *
+ * @category Comments
+ * @function
+ * @param options - The document to read, optionally narrowed by `fieldPath`, `status`, or `scope`
+ * @returns The matching threads, and whether a switch is in flight
+ *
+ * @example Count the open threads on a field
+ * ```tsx
+ * function TitleCommentCount({documentId}: {documentId: string}) {
+ *   const {threads} = useCommentThreads({
+ *     documentId,
+ *     documentType: 'article',
+ *     fieldPath: 'title',
+ *     status: 'open',
+ *   })
+ *
+ *   return <span>{threads.length}</span>
+ * }
+ * ```
+ *
+ * @beta
+ */
+export declare function useCommentThreads(options: WithResourceNameSupport<CommentsOptions>): UseCommentThreadsResult;
+export type { CommentActions, UseCommentThreadsResult, UseCommentsQueryResult, UseCommentsResult };
+//# sourceMappingURL=collaboration.d.ts.map

package/dist/_exports/collaboration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collaboration.d.ts","names":["Comment","CreateCommentOptions","ReactionOptions","RemoveCommentOptions","ReplyToCommentOptions","SetCommentStatusOptions","UpdateCommentAnchorOptions","UpdateCommentOptions","WithResourceNameSupport","CommentActions","Promise","useCommentActions","Comment","CommentsOptions","WithResourceNameSupport","UseCommentsResult","useComments","Comment","CommentsQueryOptions","WithResourceNameSupport","UseCommentsQueryResult","useCommentsQuery","CommentsOptions","CommentThread","WithResourceNameSupport","UseCommentThreadsResult","useCommentThreads"],"sources":["../../src/hooks/comments/useCommentActions.ts","../../src/hooks/comments/useComments.ts","../../src/hooks/comments/useCommentsQuery.ts","../../src/hooks/comments/useCommentThreads.ts"],"mappings":";;;;;;;;UAoCiBS;;EAEf,gBAAgB,SAASD,wBAAwBP,0BAA0BS,QAAQV;;EAEnF,iBAAiB,SAASQ,wBAAwBJ,2BAA2BM,QAAQV;;EAErF,gBAAgB,SAASQ,wBAAwBD,0BAA0BG;;;;EAI3E,sBACE,SAASF,wBAAwBF,gCAC9BI;;EAEL,mBAAmB,SAASF,wBAAwBH,6BAA6BK;;EAEjF,gBAAgB,SAASF,wBAAwBL,0BAA0BO;;EAE3E,cAAc,SAASF,wBAAwBN,qBAAqBQ;;EAEpE,iBAAiB,SAASF,wBAAwBN,qBAAqBQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkDzDC,qBAAqBF;;;;;;UCxFpBM;;EAEf,UAAUH;;EAEV;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+CcI,YAAY,SAASF,wBAAwBD,mBAAmBE;;;;;UC1D/DK;;EAEf,UAAUH;;EAEV;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwEcI,iBACd,SAASF,wBAAwBD,wBAChCE;;;;;;UCnFcK;;EAEf,SAASF;;EAET;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8CcG,kBACd,SAASF,wBAAwBF,mBAChCG"}

package/dist/_exports/collaboration.js

@@ -0,0 +1,244 @@
+import { t as useSanityInstance } from "../useSanityInstance-C0a_Ou_p.js";
+import { a as useEffectiveContextResource, i as normalizeResourceOptions, l as ResourcesContext, n as trackHookUsage, s as PerspectiveContext, t as useCommentList } from "../useCommentList-CXi_IIwA.js";
+import { c } from "react-compiler-runtime";
+import "@sanity/sdk";
+import { getCommentsQueryOptionsKey, getDocumentCommentsOptionsKey, parseCommentsQueryOptionsKey, parseDocumentCommentsOptionsKey } from "@sanity/sdk/_internal";
+import { useContext } from "react";
+import { addReaction, createComment as createComment$1, getCommentThreadsState as getCommentThreadsState$1, getCommentsErrorState, getCommentsQueryErrorState, getCommentsQueryState, getCommentsState as getCommentsState$1, removeComment as removeComment$1, removeReaction, replyToComment as replyToComment$1, resolveCommentThreads as resolveCommentThreads$1, resolveComments as resolveComments$1, resolveCommentsQuery, setCommentStatus as setCommentStatus$1, updateComment as updateComment$1, updateCommentAnchor } from "@sanity/sdk/collaboration";
+export * from "@sanity/sdk/collaboration";
+/**
+* Returns the comment write actions, bound to the current instance.
+*
+* Each writes optimistically: the change shows immediately and is rolled back
+* if the server rejects it, so an app can render straight from
+* {@link useCommentThreads} without tracking pending state itself.
+*
+* Creating is the exception, and `replyToComment` counts as creating. A comment
+* that fails to post stays on screen carrying `state.createError` rather than
+* disappearing, so passing the same `commentId` again retries it instead of
+* losing what someone typed.
+*
+* The resource is resolved when an action is called rather than when the hook
+* runs, so one set of callbacks works across several resources. Pass `resource`
+* or `resourceName` per call to choose; otherwise the surrounding
+* `ResourceProvider` decides. The organization the comments live in is
+* resolved per call as well: the one the Dashboard opened the app in, else
+* `organizationId` on the Sanity config, else the organization owning the
+* resource's project. It cannot be passed on the call.
+*
+* @category Comments
+* @function
+* @returns The write actions
+*
+* @example Resolve a thread
+* ```tsx
+* function ResolveButton({commentId}: {commentId: string}) {
+*   const {setCommentStatus} = useCommentActions()
+*
+*   return (
+*     <button onClick={() => setCommentStatus({commentId, status: 'resolved'})}>
+*       Resolve
+*     </button>
+*   )
+* }
+* ```
+*
+* @beta
+*/
+function useCommentActions() {
+	let $ = c(7), instance = useSanityInstance();
+	trackHookUsage(instance, "useCommentActions");
+	let resources = useContext(ResourcesContext), contextResource = useEffectiveContextResource(), contextPerspective = useContext(PerspectiveContext), t0;
+	$[0] !== contextPerspective || $[1] !== contextResource || $[2] !== resources ? (t0 = (options) => normalizeResourceOptions(options, resources, contextResource, contextPerspective), $[0] = contextPerspective, $[1] = contextResource, $[2] = resources, $[3] = t0) : t0 = $[3];
+	let resolve = t0, t1;
+	return $[4] !== instance || $[5] !== resolve ? (t1 = {
+		createComment: (options_0) => createComment$1(instance, resolve(options_0)),
+		replyToComment: (options_1) => replyToComment$1(instance, resolve(options_1)),
+		updateComment: (options_2) => updateComment$1(instance, resolve(options_2)),
+		updateCommentAnchor: (options_3) => updateCommentAnchor(instance, resolve(options_3)),
+		setCommentStatus: (options_4) => setCommentStatus$1(instance, resolve(options_4)),
+		removeComment: (options_5) => removeComment$1(instance, resolve(options_5)),
+		addReaction: (options_6) => addReaction(instance, resolve(options_6)),
+		removeReaction: (options_7) => removeReaction(instance, resolve(options_7))
+	}, $[4] = instance, $[5] = resolve, $[6] = t1) : t1 = $[6], t1;
+}
+const SOURCE$2 = {
+	getState: getCommentsState$1,
+	getErrorState: getCommentsErrorState,
+	resolve: resolveComments$1,
+	getKey: getDocumentCommentsOptionsKey,
+	parseKey: parseDocumentCommentsOptionsKey
+};
+/**
+* Reads a document's comments and keeps them up to date.
+*
+* The list is flat, replies included, which suits a count or a feed. Reach for
+* {@link useCommentThreads} to read the same comments grouped, where a reply
+* sits under the comment it answers and filtering by `status` or `fieldPath`
+* selects whole threads rather than individual comments. Both read the same
+* document and share a listener, so using them side by side costs nothing
+* extra. {@link useCommentsQuery} covers anything that is not one document's
+* comments.
+*
+* Suspends until the comments have loaded. Switching document or filter is a
+* transition, so the previous list stays on screen and `isPending` goes true
+* rather than the component suspending again.
+*
+* @category Comments
+* @function
+* @param options - The document to read, optionally narrowed by `fieldPath`, `status`, or `scope`
+* @returns The matching comments, and whether a switch is in flight
+*
+* @example Count the open comments on a field
+* ```tsx
+* function TitleCommentCount({documentId}: {documentId: string}) {
+*   const {comments} = useComments({
+*     documentId,
+*     documentType: 'article',
+*     fieldPath: 'title',
+*     status: 'open',
+*   })
+*
+*   return <span>{comments.length}</span>
+* }
+* ```
+*
+* @beta
+*/
+function useComments(options) {
+	let $ = c(4), { value, isPending, error } = useCommentList("useComments", options, SOURCE$2), t0;
+	return $[0] !== error || $[1] !== isPending || $[2] !== value ? (t0 = {
+		comments: value,
+		isPending,
+		error
+	}, $[0] = error, $[1] = isPending, $[2] = value, $[3] = t0) : t0 = $[3], t0;
+}
+const SOURCE$1 = {
+	getState: getCommentsQueryState,
+	getErrorState: getCommentsQueryErrorState,
+	resolve: resolveCommentsQuery,
+	getKey: getCommentsQueryOptionsKey,
+	parseKey: parseCommentsQueryOptionsKey
+};
+/**
+* Reads comments matching a GROQ filter and keeps them up to date.
+*
+* The escape hatch for anything that is not "comments on this document":
+* cross-document views, per-user views, organization-wide activity. The list is
+* flat, replies included; reach for {@link useCommentThreads} to read one
+* document's comments grouped into threads.
+*
+* `_type == "sanity.comment"` is applied for you. Comments are stored per
+* organization, resolved rather than configured: the one the Dashboard opened
+* the app in, else `organizationId` on the Sanity config, else the organization
+* owning the resource's project. The filter runs over every comment that
+* organization can read, not only the ones in the resource's dataset: comment
+* queries are routed by organization and the resource is not sent with them.
+* To keep to one dataset, add a `target.document._ref` prefix condition
+* yourself. Refs are `dataset:{projectId}.{dataset}:{documentId}`.
+*
+* Suspends until the comments have loaded. Switching filter is a transition, so
+* the previous list stays on screen and `isPending` goes true rather than the
+* component suspending again.
+*
+* Writes show here before the server confirms them, the same as they do on a
+* document's comments, because the filter is matched against the written
+* comment locally. That holds for writes through the resource the query is
+* bound to; comments written through another dataset arrive once the server
+* confirms them. A filter that cannot be answered that way — one that
+* dereferences, runs a `*[...]` of its own, or calls a context-dependent
+* function such as `sanity::dataset()` or `now()` — still works, but only
+* follows the server, and costs a connection of its own rather than sharing one.
+*
+* @category Comments
+* @function
+* @param options - The GROQ `filter` to match, and any `params` it reads
+* @returns The matching comments, and whether a switch is in flight
+*
+* @example Every comment mentioning the current user
+* ```tsx
+* function Mentions({userId}: {userId: string}) {
+*   const {comments} = useCommentsQuery({
+*     filter: 'count(message[].children[_type == "mention" && userId == $userId]) > 0',
+*     params: {userId},
+*   })
+*
+*   return <span>{comments.length}</span>
+* }
+* ```
+*
+* @example Open comments in one dataset
+* ```tsx
+* function OpenInProduction() {
+*   const {comments} = useCommentsQuery({
+*     filter: 'string::startsWith(target.document._ref, $prefix) && status == "open"',
+*     params: {prefix: 'dataset:abc123.production:'},
+*   })
+*
+*   return <span>{comments.length}</span>
+* }
+* ```
+*
+* @beta
+*/
+function useCommentsQuery(options) {
+	let $ = c(4), { value, isPending, error } = useCommentList("useCommentsQuery", options, SOURCE$1), t0;
+	return $[0] !== error || $[1] !== isPending || $[2] !== value ? (t0 = {
+		comments: value,
+		isPending,
+		error
+	}, $[0] = error, $[1] = isPending, $[2] = value, $[3] = t0) : t0 = $[3], t0;
+}
+const SOURCE = {
+	getState: getCommentThreadsState$1,
+	getErrorState: getCommentsErrorState,
+	resolve: resolveCommentThreads$1,
+	getKey: getDocumentCommentsOptionsKey,
+	parseKey: parseDocumentCommentsOptionsKey
+};
+/**
+* Reads a document's comment threads and keeps them up to date.
+*
+* A thread carries its first comment plus its replies, and `status` and
+* `fieldPath` come from that first comment, so filtering by either selects
+* whole threads. Use {@link useComments} to read the same list flat, `scope` to
+* say which of the document's comments to cover — by default it follows the
+* perspective in view — and {@link useCommentsQuery} when the question is not
+* "comments on this document".
+*
+* Suspends until the comments have loaded. Switching document or filter is a
+* transition, so the previous list stays on screen and `isPending` goes true
+* rather than the component suspending again.
+*
+* @category Comments
+* @function
+* @param options - The document to read, optionally narrowed by `fieldPath`, `status`, or `scope`
+* @returns The matching threads, and whether a switch is in flight
+*
+* @example Count the open threads on a field
+* ```tsx
+* function TitleCommentCount({documentId}: {documentId: string}) {
+*   const {threads} = useCommentThreads({
+*     documentId,
+*     documentType: 'article',
+*     fieldPath: 'title',
+*     status: 'open',
+*   })
+*
+*   return <span>{threads.length}</span>
+* }
+* ```
+*
+* @beta
+*/
+function useCommentThreads(options) {
+	let $ = c(4), { value, isPending, error } = useCommentList("useCommentThreads", options, SOURCE), t0;
+	return $[0] !== error || $[1] !== isPending || $[2] !== value ? (t0 = {
+		threads: value,
+		isPending,
+		error
+	}, $[0] = error, $[1] = isPending, $[2] = value, $[3] = t0) : t0 = $[3], t0;
+}
+export { useCommentActions, useCommentThreads, useComments, useCommentsQuery };
+
+//# sourceMappingURL=collaboration.js.map

package/dist/_exports/collaboration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collaboration.js","names":["DocumentResource","PerspectiveHandle","addReaction","Comment","createComment","CreateCommentOptions","ReactionOptions","removeComment","RemoveCommentOptions","removeReaction","replyToComment","ReplyToCommentOptions","setCommentStatus","SetCommentStatusOptions","updateComment","updateCommentAnchor","UpdateCommentAnchorOptions","UpdateCommentOptions","useContext","useMemo","PerspectiveContext","ResourcesContext","useSanityInstance","normalizeResourceOptions","useEffectiveContextResource","WithResourceNameSupport","trackHookUsage","CommentActions","options","Promise","Resolvable","resource","resourceName","projectId","dataset","perspective","useCommentActions","$","_c","instance","resources","contextResource","contextPerspective","t0","resolve","t1","options_0","options_1","options_2","options_3","options_4","options_5","options_6","options_7","_c","createComment","replyToComment","updateComment","setCommentStatus","removeComment","getDocumentCommentsOptionsKey","parseDocumentCommentsOptionsKey","Comment","CommentsOptions","getCommentsErrorState","getCommentsState","resolveComments","useMemo","WithResourceNameSupport","CommentListSource","useCommentList","UseCommentsResult","comments","isPending","error","SOURCE","getState","getErrorState","resolve","getKey","parseKey","useComments","options","$","_c","value","t0","SOURCE","getCommentsState","resolveComments","_c","getCommentsQueryOptionsKey","parseCommentsQueryOptionsKey","Comment","CommentsQueryOptions","getCommentsQueryErrorState","getCommentsQueryState","resolveCommentsQuery","useMemo","WithResourceNameSupport","CommentListSource","useCommentList","UseCommentsQueryResult","comments","isPending","error","SOURCE","getState","getErrorState","resolve","getKey","parseKey","useCommentsQuery","options","$","_c","value","t0","SOURCE","_c","getDocumentCommentsOptionsKey","parseDocumentCommentsOptionsKey","CommentsOptions","CommentThread","getCommentsErrorState","getCommentThreadsState","resolveCommentThreads","useMemo","WithResourceNameSupport","CommentListSource","useCommentList","UseCommentThreadsResult","threads","isPending","error","SOURCE","getState","getErrorState","resolve","getKey","parseKey","useCommentThreads","options","$","_c","value","t0","getCommentThreadsState","resolveCommentThreads","_c"],"sources":["../../src/hooks/comments/useCommentActions.ts","../../src/hooks/comments/useComments.ts","../../src/hooks/comments/useCommentsQuery.ts","../../src/hooks/comments/useCommentThreads.ts"],"sourcesContent":["import {type DocumentResource, type PerspectiveHandle} from '@sanity/sdk'\nimport {\n  addReaction,\n  type Comment,\n  createComment,\n  type CreateCommentOptions,\n  type ReactionOptions,\n  removeComment,\n  type RemoveCommentOptions,\n  removeReaction,\n  replyToComment,\n  type ReplyToCommentOptions,\n  setCommentStatus,\n  type SetCommentStatusOptions,\n  updateComment,\n  updateCommentAnchor,\n  type UpdateCommentAnchorOptions,\n  type UpdateCommentOptions,\n} from '@sanity/sdk/collaboration'\nimport {useContext, useMemo} from 'react'\n\nimport {PerspectiveContext} from '../../context/PerspectiveContext'\nimport {ResourcesContext} from '../../context/ResourcesContext'\nimport {useSanityInstance} from '../context/useSanityInstance'\nimport {\n  normalizeResourceOptions,\n  useEffectiveContextResource,\n  type WithResourceNameSupport,\n} from '../helpers/useNormalizedResourceOptions'\nimport {trackHookUsage} from '../helpers/useTrackHookUsage'\n\n/**\n * @beta\n * @category Types\n * @category Comments\n */\nexport interface CommentActions {\n  /** Starts a thread on one of a document's fields. */\n  createComment: (options: WithResourceNameSupport<CreateCommentOptions>) => Promise<Comment>\n  /** Adds a reply to an existing thread. */\n  replyToComment: (options: WithResourceNameSupport<ReplyToCommentOptions>) => Promise<Comment>\n  /** Rewrites a comment's message. */\n  updateComment: (options: WithResourceNameSupport<UpdateCommentOptions>) => Promise<void>\n  /**\n   * Re-anchors a comment to a different run of text, without marking it edited.\n   */\n  updateCommentAnchor: (\n    options: WithResourceNameSupport<UpdateCommentAnchorOptions>,\n  ) => Promise<void>\n  /** Resolves or reopens a thread. Pass the thread's first comment. */\n  setCommentStatus: (options: WithResourceNameSupport<SetCommentStatusOptions>) => Promise<void>\n  /** Deletes a comment, and its replies when it starts a thread. */\n  removeComment: (options: WithResourceNameSupport<RemoveCommentOptions>) => Promise<void>\n  /** Adds the current user's reaction to a comment. */\n  addReaction: (options: WithResourceNameSupport<ReactionOptions>) => Promise<void>\n  /** Removes the current user's reaction from a comment. */\n  removeReaction: (options: WithResourceNameSupport<ReactionOptions>) => Promise<void>\n}\n\ntype Resolvable = {\n  resource?: DocumentResource\n  resourceName?: string\n  projectId?: string\n  dataset?: string\n  perspective?: PerspectiveHandle['perspective']\n}\n\n/**\n * Returns the comment write actions, bound to the current instance.\n *\n * Each writes optimistically: the change shows immediately and is rolled back\n * if the server rejects it, so an app can render straight from\n * {@link useCommentThreads} without tracking pending state itself.\n *\n * Creating is the exception, and `replyToComment` counts as creating. A comment\n * that fails to post stays on screen carrying `state.createError` rather than\n * disappearing, so passing the same `commentId` again retries it instead of\n * losing what someone typed.\n *\n * The resource is resolved when an action is called rather than when the hook\n * runs, so one set of callbacks works across several resources. Pass `resource`\n * or `resourceName` per call to choose; otherwise the surrounding\n * `ResourceProvider` decides. The organization the comments live in is\n * resolved per call as well: the one the Dashboard opened the app in, else\n * `organizationId` on the Sanity config, else the organization owning the\n * resource's project. It cannot be passed on the call.\n *\n * @category Comments\n * @function\n * @returns The write actions\n *\n * @example Resolve a thread\n * ```tsx\n * function ResolveButton({commentId}: {commentId: string}) {\n *   const {setCommentStatus} = useCommentActions()\n *\n *   return (\n *     <button onClick={() => setCommentStatus({commentId, status: 'resolved'})}>\n *       Resolve\n *     </button>\n *   )\n * }\n * ```\n *\n * @beta\n */\nexport function useCommentActions(): CommentActions {\n  const instance = useSanityInstance()\n  trackHookUsage(instance, 'useCommentActions')\n\n  const resources = useContext(ResourcesContext)\n  const contextResource = useEffectiveContextResource()\n  const contextPerspective = useContext(PerspectiveContext)\n\n  return useMemo(() => {\n    const resolve = <T extends Resolvable>(options: T) =>\n      normalizeResourceOptions(options, resources, contextResource, contextPerspective)\n\n    return {\n      createComment: (options) => createComment(instance, resolve(options)),\n      replyToComment: (options) => replyToComment(instance, resolve(options)),\n      updateComment: (options) => updateComment(instance, resolve(options)),\n      updateCommentAnchor: (options) => updateCommentAnchor(instance, resolve(options)),\n      setCommentStatus: (options) => setCommentStatus(instance, resolve(options)),\n      removeComment: (options) => removeComment(instance, resolve(options)),\n      addReaction: (options) => addReaction(instance, resolve(options)),\n      removeReaction: (options) => removeReaction(instance, resolve(options)),\n    }\n  }, [contextPerspective, contextResource, instance, resources])\n}\n","import {getDocumentCommentsOptionsKey, parseDocumentCommentsOptionsKey} from '@sanity/sdk/_internal'\nimport {\n  type Comment,\n  type CommentsOptions,\n  getCommentsErrorState,\n  getCommentsState,\n  resolveComments,\n} from '@sanity/sdk/collaboration'\nimport {useMemo} from 'react'\n\nimport {type WithResourceNameSupport} from '../helpers/useNormalizedResourceOptions'\nimport {type CommentListSource, useCommentList} from './useCommentList'\n\n/**\n * @beta\n * @category Types\n * @category Comments\n */\nexport interface UseCommentsResult {\n  /** Every matching comment, newest first, replies included. */\n  comments: Comment[]\n  /** True while switching to a different document or filter. */\n  isPending: boolean\n  /**\n   * Set when the comments have stopped following the server: the listener\n   * failed after they had loaded, so what you are reading is the list as it\n   * last stood rather than as it is. Clears when a listener comes back.\n   */\n  error?: unknown\n}\n\nconst SOURCE: CommentListSource<CommentsOptions, Comment[]> = {\n  getState: getCommentsState,\n  getErrorState: getCommentsErrorState,\n  resolve: resolveComments,\n  getKey: getDocumentCommentsOptionsKey,\n  parseKey: parseDocumentCommentsOptionsKey,\n}\n\n/**\n * Reads a document's comments and keeps them up to date.\n *\n * The list is flat, replies included, which suits a count or a feed. Reach for\n * {@link useCommentThreads} to read the same comments grouped, where a reply\n * sits under the comment it answers and filtering by `status` or `fieldPath`\n * selects whole threads rather than individual comments. Both read the same\n * document and share a listener, so using them side by side costs nothing\n * extra. {@link useCommentsQuery} covers anything that is not one document's\n * comments.\n *\n * Suspends until the comments have loaded. Switching document or filter is a\n * transition, so the previous list stays on screen and `isPending` goes true\n * rather than the component suspending again.\n *\n * @category Comments\n * @function\n * @param options - The document to read, optionally narrowed by `fieldPath`, `status`, or `scope`\n * @returns The matching comments, and whether a switch is in flight\n *\n * @example Count the open comments on a field\n * ```tsx\n * function TitleCommentCount({documentId}: {documentId: string}) {\n *   const {comments} = useComments({\n *     documentId,\n *     documentType: 'article',\n *     fieldPath: 'title',\n *     status: 'open',\n *   })\n *\n *   return <span>{comments.length}</span>\n * }\n * ```\n *\n * @beta\n */\nexport function useComments(options: WithResourceNameSupport<CommentsOptions>): UseCommentsResult {\n  const {value, isPending, error} = useCommentList('useComments', options, SOURCE)\n  return useMemo(() => ({comments: value, isPending, error}), [error, isPending, value])\n}\n","import {getCommentsQueryOptionsKey, parseCommentsQueryOptionsKey} from '@sanity/sdk/_internal'\nimport {\n  type Comment,\n  type CommentsQueryOptions,\n  getCommentsQueryErrorState,\n  getCommentsQueryState,\n  resolveCommentsQuery,\n} from '@sanity/sdk/collaboration'\nimport {useMemo} from 'react'\n\nimport {type WithResourceNameSupport} from '../helpers/useNormalizedResourceOptions'\nimport {type CommentListSource, useCommentList} from './useCommentList'\n\n/**\n * @beta\n * @category Types\n */\nexport interface UseCommentsQueryResult {\n  /** Every matching comment, newest first, replies included. */\n  comments: Comment[]\n  /** True while switching to a different filter. */\n  isPending: boolean\n  /**\n   * Set when the comments have stopped following the server: the listener\n   * failed after they had loaded, so what you are reading is the list as it\n   * last stood rather than as it is. Clears when a listener comes back.\n   */\n  error?: unknown\n}\n\nconst SOURCE: CommentListSource<CommentsQueryOptions, Comment[]> = {\n  getState: getCommentsQueryState,\n  getErrorState: getCommentsQueryErrorState,\n  resolve: resolveCommentsQuery,\n  getKey: getCommentsQueryOptionsKey,\n  parseKey: parseCommentsQueryOptionsKey,\n}\n\n/**\n * Reads comments matching a GROQ filter and keeps them up to date.\n *\n * The escape hatch for anything that is not \"comments on this document\":\n * cross-document views, per-user views, organization-wide activity. The list is\n * flat, replies included; reach for {@link useCommentThreads} to read one\n * document's comments grouped into threads.\n *\n * `_type == \"sanity.comment\"` is applied for you. Comments are stored per\n * organization, resolved rather than configured: the one the Dashboard opened\n * the app in, else `organizationId` on the Sanity config, else the organization\n * owning the resource's project. The filter runs over every comment that\n * organization can read, not only the ones in the resource's dataset: comment\n * queries are routed by organization and the resource is not sent with them.\n * To keep to one dataset, add a `target.document._ref` prefix condition\n * yourself. Refs are `dataset:{projectId}.{dataset}:{documentId}`.\n *\n * Suspends until the comments have loaded. Switching filter is a transition, so\n * the previous list stays on screen and `isPending` goes true rather than the\n * component suspending again.\n *\n * Writes show here before the server confirms them, the same as they do on a\n * document's comments, because the filter is matched against the written\n * comment locally. That holds for writes through the resource the query is\n * bound to; comments written through another dataset arrive once the server\n * confirms them. A filter that cannot be answered that way — one that\n * dereferences, runs a `*[...]` of its own, or calls a context-dependent\n * function such as `sanity::dataset()` or `now()` — still works, but only\n * follows the server, and costs a connection of its own rather than sharing one.\n *\n * @category Comments\n * @function\n * @param options - The GROQ `filter` to match, and any `params` it reads\n * @returns The matching comments, and whether a switch is in flight\n *\n * @example Every comment mentioning the current user\n * ```tsx\n * function Mentions({userId}: {userId: string}) {\n *   const {comments} = useCommentsQuery({\n *     filter: 'count(message[].children[_type == \"mention\" && userId == $userId]) > 0',\n *     params: {userId},\n *   })\n *\n *   return <span>{comments.length}</span>\n * }\n * ```\n *\n * @example Open comments in one dataset\n * ```tsx\n * function OpenInProduction() {\n *   const {comments} = useCommentsQuery({\n *     filter: 'string::startsWith(target.document._ref, $prefix) && status == \"open\"',\n *     params: {prefix: 'dataset:abc123.production:'},\n *   })\n *\n *   return <span>{comments.length}</span>\n * }\n * ```\n *\n * @beta\n */\nexport function useCommentsQuery(\n  options: WithResourceNameSupport<CommentsQueryOptions>,\n): UseCommentsQueryResult {\n  const {value, isPending, error} = useCommentList('useCommentsQuery', options, SOURCE)\n  return useMemo(() => ({comments: value, isPending, error}), [error, isPending, value])\n}\n","import {getDocumentCommentsOptionsKey, parseDocumentCommentsOptionsKey} from '@sanity/sdk/_internal'\nimport {\n  type CommentsOptions,\n  type CommentThread,\n  getCommentsErrorState,\n  getCommentThreadsState,\n  resolveCommentThreads,\n} from '@sanity/sdk/collaboration'\nimport {useMemo} from 'react'\n\nimport {type WithResourceNameSupport} from '../helpers/useNormalizedResourceOptions'\nimport {type CommentListSource, useCommentList} from './useCommentList'\n\n/**\n * @beta\n * @category Types\n * @category Comments\n */\nexport interface UseCommentThreadsResult {\n  /** Matching threads, newest first, each with its replies oldest first. */\n  threads: CommentThread[]\n  /** True while switching to a different document or filter. */\n  isPending: boolean\n  /**\n   * Set when the threads have stopped following the server: the listener\n   * failed after they had loaded, so what you are reading is the list as it\n   * last stood rather than as it is. Clears when a listener comes back.\n   */\n  error?: unknown\n}\n\nconst SOURCE: CommentListSource<CommentsOptions, CommentThread[]> = {\n  getState: getCommentThreadsState,\n  getErrorState: getCommentsErrorState,\n  resolve: resolveCommentThreads,\n  getKey: getDocumentCommentsOptionsKey,\n  parseKey: parseDocumentCommentsOptionsKey,\n}\n\n/**\n * Reads a document's comment threads and keeps them up to date.\n *\n * A thread carries its first comment plus its replies, and `status` and\n * `fieldPath` come from that first comment, so filtering by either selects\n * whole threads. Use {@link useComments} to read the same list flat, `scope` to\n * say which of the document's comments to cover — by default it follows the\n * perspective in view — and {@link useCommentsQuery} when the question is not\n * \"comments on this document\".\n *\n * Suspends until the comments have loaded. Switching document or filter is a\n * transition, so the previous list stays on screen and `isPending` goes true\n * rather than the component suspending again.\n *\n * @category Comments\n * @function\n * @param options - The document to read, optionally narrowed by `fieldPath`, `status`, or `scope`\n * @returns The matching threads, and whether a switch is in flight\n *\n * @example Count the open threads on a field\n * ```tsx\n * function TitleCommentCount({documentId}: {documentId: string}) {\n *   const {threads} = useCommentThreads({\n *     documentId,\n *     documentType: 'article',\n *     fieldPath: 'title',\n *     status: 'open',\n *   })\n *\n *   return <span>{threads.length}</span>\n * }\n * ```\n *\n * @beta\n */\nexport function useCommentThreads(\n  options: WithResourceNameSupport<CommentsOptions>,\n): UseCommentThreadsResult {\n  const {value, isPending, error} = useCommentList('useCommentThreads', options, SOURCE)\n  return useMemo(() => ({threads: value, isPending, error}), [error, isPending, value])\n}\n"],"mappings":"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"}

package/dist/_exports/dashboard.js

@@ -1,4 +1,5 @@
-import { a as DashboardTokenRefreshProvider, i as useOrganizationId, l as createStateSourceHook, n as useTopic, r as useEmit, s as useWindowConnection, t as useStudioWorkspacesByProjectIdDataset, u as useSanityInstance } from "../useStudioWorkspacesByProjectIdDataset-FRofq7KL.js";
+import { t as useSanityInstance } from "../useSanityInstance-C0a_Ou_p.js";
+import { a as DashboardTokenRefreshProvider, i as useOrganizationId, l as createStateSourceHook, n as useTopic, r as useEmit, s as useWindowConnection, t as useStudioWorkspacesByProjectIdDataset } from "../useStudioWorkspacesByProjectIdDataset-Cx-Q44d0.js";
 import { c } from "react-compiler-runtime";
 import "@sanity/sdk";
 import { createLogger, getApplicationOrigin, getWorkerClient, isMessageBusEnvironment, requireDashboardMessageBus } from "@sanity/sdk/_internal";