next-sanity 13.0.0-cache-components.5 → 13.0.0-cache-components.7

package/dist/cache-life.d.ts

@@ -0,0 +1,35 @@
+/**
+* For usage with `cacheComponents: true`, and `defineLive`:
+* ```ts
+* // next.config.ts
+*
+* import type {NextConfig} from 'next'
+* import {sanity} from 'next-sanity/cache-life'
+*
+* const nextConfig: NextConfig = {
+*   cacheComponents: true,
+*   cacheLife: {
+*     sanity
+*   }
+* }
+*
+* export default nextConfig
+* ```
+*
+* ```ts
+*
+* async function sanityFetch() {
+*   'use cache'
+*    cacheLife('sanity')
+*    const {data} = await fetch({query, params})
+*    return data
+* }
+*/
+declare const sanity: {
+  /**
+  * Sanity Live handles on-demand revalidation, so the default 15min time based revalidation is too short
+  */
+  readonly revalidate: 7_776_000;
+};
+export { sanity };
+//# sourceMappingURL=cache-life.d.ts.map

package/dist/cache-life.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-life.d.ts","names":[],"sources":["../src/cache-life.ts"],"sourcesContent":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa"}

package/dist/cache-life.js

@@ -0,0 +1,4 @@
+const sanity = { revalidate: 7776e3 };
+export { sanity };
+
+//# sourceMappingURL=cache-life.js.map

package/dist/cache-life.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-life.js","names":[],"sources":["../src/cache-life.ts"],"sourcesContent":["/**\n * For usage with `cacheComponents: true`, and `defineLive`:\n * ```ts\n * // next.config.ts\n *\n * import type {NextConfig} from 'next'\n * import {sanity} from 'next-sanity/cache-life'\n *\n * const nextConfig: NextConfig = {\n *   cacheComponents: true,\n *   cacheLife: {\n *     sanity\n *   }\n * }\n *\n * export default nextConfig\n * ```\n *\n * ```ts\n *\n * async function sanityFetch() {\n *   'use cache'\n *    cacheLife('sanity')\n *    const {data} = await fetch({query, params})\n *    return data\n * }\n */\nexport const sanity = {\n  /**\n   * Sanity Live handles on-demand revalidation, so the default 15min time based revalidation is too short\n   */\n  revalidate: 7_776_000, // 90 days,\n} as const satisfies {\n  /**\n   * This cache may be stale on clients for ... seconds before checking with the server.\n   */\n  stale?: number\n  /**\n   * If the server receives a new request after ... seconds, start revalidating new values in the background.\n   */\n  revalidate?: number\n  /**\n   * If this entry has no traffic for ... seconds it will expire. The next request will recompute it.\n   */\n  expire?: number\n}\n"],"mappings":"AA2BA,MAAa,SAAS,EAIpB,YAAY,QACb"}

package/dist/defineLive.d.ts

@@ -1,4 +1,145 @@
+import { cookies } from "next/headers";
 import { ClientPerspective, ClientReturn, ContentSourceMap, LiveEventGoAway, QueryParams, SanityClient, SyncTag } from "@sanity/client";
+import { ClientPerspective as ClientPerspective$1, ClientReturn as ClientReturn$1, ContentSourceMap as ContentSourceMap$1, LiveEventGoAway as LiveEventGoAway$1, QueryParams as QueryParams$1, SanityClient as SanityClient$1 } from "next-sanity";
+type ResolvePerspectiveFromCookies = (options: {
+  /**
+  * You must await the cookies() function from next/headers
+  * and pass it here.
+  * Example:
+  * ```ts
+  * import { cookies } from 'next/headers'
+  *
+  * const perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})
+  * ```
+  */
+  cookies: Awaited<ReturnType<typeof cookies>>;
+}) => Promise<Exclude<ClientPerspective, "raw">>;
+/**
+* Resolves the perspective from the cookie that is set by `import { defineEnableDraftMode } from "next-sanity/draft-mode"`
+* @public
+*/
+declare const resolvePerspectiveFromCookies: ({
+  cookies: jar
+}: {
+  cookies: Awaited<ReturnType<typeof cookies>>;
+}) => Promise<Exclude<ClientPerspective, "raw">>;
+/**
+* Perspectives supported by Sanity Live.
+* Using the legacy `'raw'` perspective is not supported and leads to undefined behavior.
+*/
+type PerspectiveType = Exclude<ClientPerspective$1, "raw">;
+/**
+* TODO: docs
+*/
+type DefinedFetchType = <const QueryString extends string>(options: {
+  query: QueryString;
+  params?: QueryParams$1;
+  /**
+  * @defaultValue 'published'
+  */
+  perspective?: PerspectiveType;
+  /**
+  * Enables stega encoding of the data, this is typically only used in draft mode in conjunction with `perspective: 'drafts'` and with `@sanity/visual-editing` setup.
+  * @defaultValue `false`
+  */
+  stega?: boolean;
+  /**
+  * Custom cache tags that can be used with next's  `updateTag` functions for custom `read-your-write` server actions,
+  * for example a like button that uses client.mutate to update a document and then immediately shows the result.
+  */
+  tags?: string[];
+  /**
+  * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.
+  * @see https://www.sanity.io/docs/reference-api-request-tags
+  * @defaultValue 'next-loader.fetch'
+  */
+  requestTag?: string;
+}) => Promise<{
+  data: ClientReturn$1<QueryString, unknown>;
+  sourceMap: ContentSourceMap$1 | null;
+  tags: string[];
+}>;
+interface DefinedLiveProps {
+  /**
+  * TODO: should match the `perspective` you give `defineLive().fetch()`, setting it to a value other than `"published"`
+  * and with `browserToken` set will cause it to subscribe to draft content changes as well as published content.
+  */
+  perspective?: PerspectiveType;
+  /**
+  * TODO: If Presentation Tool is present this event will fire with the current `perspective` stack used in the
+  * Sanity Studio global perspective menu. The default event handler will store this state in a cookie,
+  * which can be read with `resolvePerspectiveFromCookies` and used to ensure data fetching in the preview
+  * matches the perspective and content viewed in the Studio, allowing you to quickly switch and preview different perspectives.
+  */
+  onStudioPerspective?: (perspective: PerspectiveType) => void;
+  /**
+  * Automatic refresh of RSC when the component <SanityLive /> is mounted.
+  * @defaultValue `false`
+  */
+  refreshOnMount?: boolean;
+  /**
+  * Automatically refresh when window gets focused
+  * @defaultValue `false`
+  */
+  refreshOnFocus?: boolean;
+  /**
+  * Automatically refresh when the browser regains a network connection (via navigator.onLine)
+  * @defaultValue `false`
+  */
+  refreshOnReconnect?: boolean;
+  /**
+  * Automatically refresh on an interval when the Live Event API emits a `goaway` event, which indicates that the connection is rejected or closed.
+  * This typically happens if the connection limit is reached, or if the connection is idle for too long.
+  * To disable this long polling fallback behavior set `intervalOnGoAway` to `false` or `0`.
+  * You can also use `onGoAway` to handle the `goaway` event in your own way, and read the reason why the event was emitted.
+  * @defaultValue `30_000` 30 seconds interval
+  */
+  intervalOnGoAway?: number | false;
+  /**
+  * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.
+  * @see https://www.sanity.io/docs/reference-api-request-tags
+  * @defaultValue 'next-loader.live'
+  */
+  requestTag?: string;
+  /**
+  * Handle errors from the Live Events subscription.
+  * By default it's reported using `console.error`, you can override this prop to handle it in your own way.
+  */
+  onError?: (error: unknown) => void;
+  /**
+  * Handle the `goaway` event if the connection is rejected/closed.
+  * `event.reason` will be a string of why the event was emitted, for example `'connection limit reached'`.
+  * When this happens the `<SanityLive />` will fallback to long polling with a default interval of 30 seconds, providing your own `onGoAway` handler does not change this behavior.
+  * If you want to disable long polling set `intervalOnGoAway` to `false` or `0`.
+  */
+  onGoAway?: (event: LiveEventGoAway$1, intervalOnGoAway: number | false) => void;
+  /**
+  * TODO: docs, this handles events for published content only, and can be used to revalidate content for all your users when in presentation tool
+  */
+  onChange?: (tags: string[]) => Promise<void | "refresh">;
+  /**
+  * TODO: docs, this handles events for all changes, published, drafts and even version documents in content releases.
+  * It's only used when `browserToken` is provided, and the `perspective` prop is other than `"published"`.
+  * Wether you should just `refresh()` or use `updateTag` to expire tags depends on how you fetch draft content and wether it's cached or not.
+  */
+  onChangeIncludingDrafts?: (tags: string[]) => Promise<void | "refresh">;
+}
+interface LiveOptions {
+  /**
+  * Required for `fetch()` and `<Live>` to work
+  */
+  client: SanityClient$1;
+  /**
+  * Optional. If provided then the token needs to have permissions to query documents with `drafts.` prefixes in order for `perspective: 'drafts'` to work.
+  * This token is never shared with the browser, unless you reuse it in `browserToken`..
+  */
+  serverToken?: string | false;
+  /**
+  * Optional. This token is shared with the browser when `<Live>` is given a `perspective` prop other than `"published"`, and should only have access to query published documents.
+  * It is used to setup a `Live Draft Content` EventSource connection, and enables live previewing drafts stand-alone, outside of Presentation Tool.
+  */
+  browserToken?: string | false;
+}
 /**
 * @public
 */
@@ -15,10 +156,6 @@ type DefinedSanityFetchType = <const QueryString extends string>(options: {
   perspective?: Exclude<ClientPerspective, "raw">;
   stega?: boolean;
   /**
-  * @deprecated use `requestTag` instead
-  */
-  tag?: never;
-  /**
   * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.
   * @see https://www.sanity.io/docs/reference-api-request-tags
   * @defaultValue 'next-loader.fetch'
@@ -60,10 +197,6 @@ interface DefinedSanityLiveProps {
   */
   intervalOnGoAway?: number | false;
   /**
-  * @deprecated use `requestTag` instead
-  */
-  tag?: never;
-  /**
   * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.
   * @see https://www.sanity.io/docs/reference-api-request-tags
   * @defaultValue 'next-loader.live'
@@ -121,20 +254,15 @@ interface DefineSanityLiveOptions {
   */
   stega?: boolean;
 }
-/**
-* @public
-*/
 declare function defineLive(config: DefineSanityLiveOptions): {
   /**
-  * Use this function to fetch data from Sanity in your React Server Components.
-  * @public
+  * @deprecated use `fetch` instead, and define your own `sanityFetch` function with logic for when to toggle `stega` and `perspective`
   */
   sanityFetch: DefinedSanityFetchType;
   /**
-  * Render this in your root layout.tsx to make your page revalidate on new content live, automatically.
-  * @public
+  * @deprecated use `Live` instead, and define your own `SanityLive` component with logic for when to toggle `perspective`
   */
   SanityLive: React.ComponentType<DefinedSanityLiveProps>;
 };
-export { defineLive as i, DefinedSanityFetchType as n, DefinedSanityLiveProps as r, DefineSanityLiveOptions as t };
+export { DefinedFetchType as a, PerspectiveType as c, defineLive as i, ResolvePerspectiveFromCookies as l, DefinedSanityFetchType as n, DefinedLiveProps as o, DefinedSanityLiveProps as r, LiveOptions as s, DefineSanityLiveOptions as t, resolvePerspectiveFromCookies as u };
 //# sourceMappingURL=defineLive.d.ts.map

package/dist/defineLive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defineLive.d.ts","names":[],"sources":["../src/live/defineLive.tsx"],"sourcesContent":[],"mappings":";;AAkBA;;AAEW,KAFC,sBAAA,GAED,CAAA,0BAAA,MAAA,CAAA,CAAA,OAAA,EAAA;EAAsB,KAAA,EADxB,WACwB;EAAR,MAAA,CAAA,EAAd,WAAc,GAAA,OAAA,CAAQ,WAAR,CAAA;EAQD;;;;;;EAYlB,IAAA,CAAA,EAAA,MAAA,EAAA;EASN,WAAiB,CAAA,EArBD,OAqBC,CArBO,iBAqBP,EAAA,KAAA,CAAA;EAoDI,KAAA,CAAA,EAAA,OAAA;EAMS;;;EAM9B,GAAiB,CAAA,EAAA,KAAA;EAuCjB;;;;;EAUoB,UAAA,CAAA,EAAA,MAAA;MA1Hd;QACE,aAAa;aACR;;;;;;UAOI,sBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoDI;;;;;8BAMS,cAAc;;;;;UAM3B,uBAAA;;;;UAIP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCM,UAAA,SAAmB;;;;;eAKpB;;;;;cAKD,KAAA,CAAM,cAAc"}
+{"version":3,"file":"defineLive.d.ts","names":[],"sources":["../src/shared/live/resolvePerspectiveFromCookies.ts","../src/shared/live/types.ts","../src/live/defineLive.tsx"],"sourcesContent":[],"mappings":";;;KAMY,6BAAA;;AAAZ;;;;;;;;AAkBA;EACW,OAAA,EARA,OAQA,CARQ,UAQR,CAAA,OAR0B,OAQ1B,CAAA,CAAA;CAE0B,EAAA,GAT/B,OAS+B,CATvB,OASuB,CATf,iBASe,EAAA,KAAA,CAAA,CAAA;;;;;AACjC,cAJS,6BAIT,EAAA,CAAA;EAAA,OAAA,EAHO;CAGP,EAAA;EAAA,OAAA,EADO,OACP,CADe,UACf,CAAA,OADiC,OACjC,CAAA,CAAA;MAAA,QAAQ,QAAQ;;;;AAtBpB;AAWqC,KCJzB,eAAA,GAAkB,ODIO,CCJC,mBDID,EAAA,KAAA,CAAA;;;;AACvB,KCAF,gBAAA,GDAE,CAAA,0BAAA,MAAA,CAAA,CAAA,OAAA,EAAA;EAAR,KAAA,ECCG,WDDH;EAAA,MAAA,CAAA,ECEK,aDFL;EAMN;;;EAGmB,WAAA,CAAA,ECHH,eDGG;EAAR;;;;EACP,KAAA,CAAA,EAAA,OAAA;;ACfJ;AAKA;;EAEW,IAAA,CAAA,EAAA,MAAA,EAAA;EAIK;;;;;EAiBV,UAAA,CAAA,EAAA,MAAA;AAMN,CAAA,EAAA,GANM,OAMW,CAAA;EAKD,IAAA,EAVR,cAUQ,CAVK,WAUL,EAAA,OAAA,CAAA;EAQsB,SAAA,EAjBzB,kBAiByB,GAAA,IAAA;EA6CjB,IAAA,EAAA,MAAA,EAAA;CAKY,CAAA;AAOe,UAtE/B,gBAAA,CAsE+B;EAAA;AAGhD;;ACpGA;EACS,WAAA,CAAA,ED+BO,eC/BP;EACE;;;;;;EAiBH,mBAAA,CAAA,EAAA,CAAA,WAAA,EDqB8B,eCrB9B,EAAA,GAAA,IAAA;EACK;;;AAOb;EA+CqB,cAAA,CAAA,EAAA,OAAA;EAMS;;;AAM9B;EAgCA,cAAgB,CAAA,EAAA,OAAA;EAAmB;;;;EAQf,kBAAA,CAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;qBDzCC;;;;iCAKY;;;;;;gDAOe;;UAG/B,WAAA;;;;UAIP;;;;;;;;;;;;;;;ADtHE,KEcA,sBAAA,GFdA,CAAA,0BAAA,MAAA,CAAA,CAAA,OAAA,EAAA;EAWyB,KAAA,EEI5B,WFJ4B;EAAlB,MAAA,CAAA,EEKR,WFLQ,GEKM,OFLN,CEKc,WFLd,CAAA;EAAR;;;;;AAOX;EACW,IAAA,CAAA,EAAA,MAAA,EAAA;EAE0B,WAAA,CAAA,EEGrB,OFHqB,CEGb,iBFHa,EAAA,KAAA,CAAA;EAAlB,KAAA,CAAA,EAAA,OAAA;EAAR;;;;;;ACdX,CAAA,EAAA,GCyBM,ODzBM,CAAA;EAKZ,IAAY,ECqBJ,YDrBI,CCqBS,WDrBT,CAAA;EACH,SAAA,ECqBI,gBDrBJ,GAAA,IAAA;EACE,IAAA,EAAA,MAAA,EAAA;CAIK,CAAA;;;;AAiBV,UCMW,sBAAA,CDNX;EAAA;AAMN;;;;EA+DiC,cAAA,CAAA,EAAA,OAAA;EAOe;;AAGhD;;ACpGA;EACS,cAAA,CAAA,EAAA,OAAA;EACE;;;;;EAiBU,kBAAA,CAAA,EAAA,OAAA;EAAb;;;;AAQR;;;EAqD4C,gBAAA,CAAA,EAAA,MAAA,GAAA,KAAA;EAAA;AAM5C;AAgCA;;;EAQkC,UAAA,CAAA,EAAA,MAAA;EAApB;;;;;;;;;;;qBApDO;;;;;8BAMS,cAAc;;;;;UAM3B,uBAAA;;;;UAIP;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BM,UAAA,SAAmB;;;;eAIpB;;;;cAID,KAAA,CAAM,cAAc"}

package/dist/experimental/client-components/live.d.ts

@@ -1,6 +1,7 @@
-import { n as PUBLISHED_SYNC_TAG_PREFIX, t as DRAFT_SYNC_TAG_PREFIX } from "../../constants.js";
 import { ClientPerspective, InitializedClientConfig, LiveEventGoAway, SyncTag } from "@sanity/client";
 interface SanityClientConfig extends Pick<InitializedClientConfig, "projectId" | "dataset" | "apiHost" | "apiVersion" | "useProjectHostname" | "token" | "requestTagPrefix"> {}
+declare const PUBLISHED_SYNC_TAG_PREFIX = "sp:";
+declare const DRAFT_SYNC_TAG_PREFIX = "sd:";
 /**
 * @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.
 */

package/dist/experimental/client-components/live.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live.d.ts","names":[],"sources":["../../../src/experimental/types.ts","../../../src/experimental/client-components/live.tsx"],"sourcesContent":[],"mappings":";;UAEiB,kBAAA,SAA2B,KAC1C;AADF;;ACkCA;AACU,UADO,eAAA,CACP;EAYW,MAAA,EAZX,kBAYW;EAED,gBAAA,EAAA,OAAA;EAAmC,cAAA,CAAA,EAAA,OAAA;EAAwB,cAAA,CAAA,EAAA,OAAA;EACxE,kBAAA,CAAA,EAAA,OAAA;EACsC,UAAA,EAAA,MAAA,GAAA,SAAA;EAAR;;;;;;qBAJhB;uCAED,mCAAmC,wBAAwB,gBACxE;qCAC8B,QAAQ;;;;;iBAkCrB,UAAA,QAAkB,kBAAkB,KAAA,CAAM,GAAA,CAAI"}
+{"version":3,"file":"live.d.ts","names":[],"sources":["../../../src/experimental/types.ts","../../../src/experimental/constants.ts","../../../src/experimental/client-components/live.tsx"],"sourcesContent":[],"mappings":";UAEiB,kBAAA,SAA2B,KAC1C;cCHW,yBAAA;cACA,qBAAA;;AADb;AACA;UCmCiB,eAAA;EAAjB,MAAiB,EACP,kBADO;EACP,gBAAA,EAAA,OAAA;EAYW,cAAA,CAAA,EAAA,OAAA;EAED,cAAA,CAAA,EAAA,OAAA;EAAmC,kBAAA,CAAA,EAAA,OAAA;EAAwB,UAAA,EAAA,MAAA,GAAA,SAAA;EACxE;;;;SAmCiB,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAkB,GAAA,IAAA;;qBAtCrB;uCAED,mCAAmC,wBAAwB,gBACxE;qCAC8B,QAAQ;;;;;iBAkCrB,UAAA,QAAkB,kBAAkB,KAAA,CAAM,GAAA,CAAI"}

package/dist/live/server-actions/index.js

@@ -1,8 +1,8 @@
 "use server";
 import { t as sanitizePerspective } from "../../sanitizePerspective.js";
-import { revalidateTag } from "next/cache";
 import { perspectiveCookieName } from "@sanity/preview-url-secret/constants";
 import { cookies, draftMode } from "next/headers";
+import { revalidateTag } from "next/cache";
 async function revalidateSyncTags(tags) {
 	revalidateTag("sanity:fetch-sync-tags", "max");
 	for (const _tag of tags) {

package/dist/live.d.ts

@@ -1,11 +1,18 @@
 import { t as isCorsOriginError } from "./isCorsOriginError.js";
-import { n as DefinedSanityFetchType, r as DefinedSanityLiveProps, t as DefineSanityLiveOptions } from "./defineLive.js";
-import { t as ResolvePerspectiveFromCookies } from "./resolvePerspectiveFromCookies.js";
+import { a as DefinedFetchType, c as PerspectiveType, l as ResolvePerspectiveFromCookies, n as DefinedSanityFetchType, o as DefinedLiveProps, r as DefinedSanityLiveProps, t as DefineSanityLiveOptions } from "./defineLive.js";
 /**
 * @public
 */
 declare function defineLive(_config: DefineSanityLiveOptions): {
+  fetch: DefinedFetchType;
+  Live: React.ComponentType<DefinedLiveProps>;
+  /**
+  * @deprecated use `fetch` instead, and define your own `sanityFetch` function with logic for when to toggle `stega` and `perspective`
+  */
   sanityFetch: DefinedSanityFetchType;
+  /**
+  * @deprecated use `Live` instead, and define your own `SanityLive` component with logic for when to toggle `perspective`
+  */
   SanityLive: React.ComponentType<DefinedSanityLiveProps>;
 };
 /**
@@ -13,5 +20,5 @@ declare function defineLive(_config: DefineSanityLiveOptions): {
 * @public
 */
 declare const resolvePerspectiveFromCookies: ResolvePerspectiveFromCookies;
-export { type DefineSanityLiveOptions, type DefinedSanityFetchType, type DefinedSanityLiveProps, defineLive, isCorsOriginError, resolvePerspectiveFromCookies };
+export { type PerspectiveType as LivePerspective, defineLive, isCorsOriginError, resolvePerspectiveFromCookies };
 //# sourceMappingURL=live.d.ts.map

package/dist/live.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live.d.ts","names":["resolvePerspectiveFromCookies: ResolvePerspectiveFromCookies"],"sources":["../src/live.tsx"],"sourcesContent":[],"mappings":";;;;;AAiBA;AAAoC,iBAApB,UAAA,CAAoB,OAAA,EAAA,uBAAA,CAAA,EAAA;EACrB,WAAA,EAAA,sBAAA;EACmB,UAAA,EAApB,KAAA,CAAM,aAAc,CAAA,sBAAA,CAAA;CAApB;;;;;cAgBDA,+BAA+B"}
+{"version":3,"file":"live.d.ts","names":["resolvePerspectiveFromCookies: ResolvePerspectiveFromCookies"],"sources":["../src/live.tsx"],"sourcesContent":[],"mappings":";;;;;AAsBc,iBAFE,UAAA,CAEF,OAAA,EAFsB,uBAEtB,CAAA,EAAA;EAIC,KAAA,EALN,gBAKM;EAImB,IAAA,EAR1B,KAAA,CAAM,aAQoB,CARN,gBAQM,CAAA;EAApB;;AASd;eAbe;;;;cAID,KAAA,CAAM,cAAc;;;;;;cASrBA,+BAA+B"}

package/dist/live.js.map

@@ -1 +1 @@
-{"version":3,"file":"live.js","names":["resolvePerspectiveFromCookies: ResolvePerspectiveFromCookies"],"sources":["../src/live.tsx"],"sourcesContent":["// This is the fallback export condition for `import 'next-sanity/live'`,\n// it should have the same type definitions as the other conditions so that userland don't have to worry about setting the right\n// `customCondition` in their `tsconfig.json` in order to get accurate typings.\n// The implementation here though should all throw errors, as importing this file means userland made a mistake and somehow a client component is\n// trying to pull in something it shouldn't.\n\nexport {isCorsOriginError} from '#live/isCorsOriginError'\n\nimport type {\n  DefineSanityLiveOptions,\n  DefinedSanityFetchType,\n  DefinedSanityLiveProps,\n} from './live/defineLive'\n\n/**\n * @public\n */\nexport function defineLive(_config: DefineSanityLiveOptions): {\n  sanityFetch: DefinedSanityFetchType\n  SanityLive: React.ComponentType<DefinedSanityLiveProps>\n} {\n  throw new Error(`defineLive can't be imported by a client component`)\n}\n\n/**\n * @public\n */\nexport type {DefineSanityLiveOptions, DefinedSanityFetchType, DefinedSanityLiveProps}\n\nimport type {ResolvePerspectiveFromCookies} from '#live/resolvePerspectiveFromCookies'\n\n/**\n * Resolves the perspective from the cookie that is set by `import { defineEnableDraftMode } from \"next-sanity/draft-mode\"`\n * @public\n */\nexport const resolvePerspectiveFromCookies: ResolvePerspectiveFromCookies = () => {\n  throw new Error(`resolvePerspectiveFromCookies can't be imported by a client component`)\n}\n"],"mappings":";AAiBA,SAAgB,WAAW,SAGzB;AACA,OAAM,IAAI,MAAM,qDAAqD;;AAcvE,MAAaA,sCAAqE;AAChF,OAAM,IAAI,MAAM,wEAAwE"}
+{"version":3,"file":"live.js","names":["resolvePerspectiveFromCookies: ResolvePerspectiveFromCookies"],"sources":["../src/live.tsx"],"sourcesContent":["// This is the fallback export condition for `import 'next-sanity/live'`,\n// it should have the same type definitions as the other conditions so that userland don't have to worry about setting the right\n// `customCondition` in their `tsconfig.json` in order to get accurate typings.\n// The implementation here though should all throw errors, as importing this file means userland made a mistake and somehow a client component is\n// trying to pull in something it shouldn't.\n\nimport type {ResolvePerspectiveFromCookies} from '#live/resolvePerspectiveFromCookies'\nimport type {DefinedFetchType, DefinedLiveProps} from '#live/types'\n\nimport type {\n  DefineSanityLiveOptions,\n  DefinedSanityFetchType,\n  DefinedSanityLiveProps,\n} from './live/defineLive'\n\nexport {isCorsOriginError} from '#live/isCorsOriginError'\n\n/**\n * @public\n */\nexport function defineLive(_config: DefineSanityLiveOptions): {\n  fetch: DefinedFetchType\n  Live: React.ComponentType<DefinedLiveProps>\n  /**\n   * @deprecated use `fetch` instead, and define your own `sanityFetch` function with logic for when to toggle `stega` and `perspective`\n   */\n  sanityFetch: DefinedSanityFetchType\n  /**\n   * @deprecated use `Live` instead, and define your own `SanityLive` component with logic for when to toggle `perspective`\n   */\n  SanityLive: React.ComponentType<DefinedSanityLiveProps>\n} {\n  throw new Error(`defineLive can't be imported by a client component`)\n}\n\n/**\n * Resolves the perspective from the cookie that is set by `import { defineEnableDraftMode } from \"next-sanity/draft-mode\"`\n * @public\n */\nexport const resolvePerspectiveFromCookies: ResolvePerspectiveFromCookies = () => {\n  throw new Error(`resolvePerspectiveFromCookies can't be imported by a client component`)\n}\n\nexport type {PerspectiveType as LivePerspective} from '#live/types'\n"],"mappings":";AAoBA,SAAgB,WAAW,SAWzB;AACA,OAAM,IAAI,MAAM,qDAAqD;;AAOvE,MAAaA,sCAAqE;AAChF,OAAM,IAAI,MAAM,wEAAwE"}

package/dist/live.next-js.d.ts

@@ -1,134 +1,16 @@
-import { n as PUBLISHED_SYNC_TAG_PREFIX, t as DRAFT_SYNC_TAG_PREFIX } from "./constants.js";
 import { t as isCorsOriginError } from "./isCorsOriginError.js";
-import { n as resolvePerspectiveFromCookies } from "./resolvePerspectiveFromCookies.js";
-import { ClientPerspective, ClientReturn, ContentSourceMap, LiveEventGoAway, QueryParams, SanityClient, SyncTag } from "next-sanity";
-/**
-* @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.
-*/
-interface SanityFetchOptions<QueryString extends string> {
-  query: QueryString;
-  params?: QueryParams;
+import { a as DefinedFetchType, c as PerspectiveType, n as DefinedSanityFetchType, o as DefinedLiveProps, r as DefinedSanityLiveProps, s as LiveOptions, u as resolvePerspectiveFromCookies } from "./defineLive.js";
+declare function defineLive(config: LiveOptions): {
+  fetch: DefinedFetchType;
+  Live: React.ComponentType<DefinedLiveProps>;
   /**
-  * @defaultValue 'published'
-  */
-  perspective?: Exclude<ClientPerspective, "raw">;
-  /**
-  * Enables stega encoding of the data, this is typically only used in draft mode in conjunction with `perspective: 'drafts'` and with `@sanity/visual-editing` setup.
-  * @defaultValue `false`
-  */
-  stega?: boolean;
-  /**
-  * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.
-  * @see https://www.sanity.io/docs/reference-api-request-tags
-  * @defaultValue 'next-loader.fetch'
-  */
-  requestTag?: string;
-  /**
-  * Custom cache tags that can be used with next's `revalidateTag` and `updateTag` functions for custom webhook on-demand revalidation.
-  */
-  tags?: string[];
-}
-/**
-* @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.
-*/
-type DefinedSanityFetchType = <const QueryString extends string>(options: SanityFetchOptions<QueryString>) => Promise<{
-  data: ClientReturn<QueryString, unknown>;
-  /**
-  * The Content Source Map can be used for custom setups like `encodeSourceMap` for `data-sanity` attributes, or `stegaEncodeSourceMap` for stega encoding in your own way.
-  * The Content Source Map is only fetched by default in draft mode, if `stega` is `true`. Otherwise your client configuration will need to have `resultSourceMap: 'withKeyArraySelector' | true`
-  */
-  sourceMap: ContentSourceMap | null;
-  /**
-  * The cache tags used with `next/cache`, useful for debugging.
-  */
-  tags: string[];
-}>;
-/**
-* @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.
-*/
-interface DefinedSanityLiveProps {
-  /**
-  * Automatic refresh of RSC when the component <SanityLive /> is mounted.
-  * @defaultValue `false`
-  */
-  refreshOnMount?: boolean;
-  /**
-  * Automatically refresh when window gets focused
-  * @defaultValue `false`
-  */
-  refreshOnFocus?: boolean;
-  /**
-  * Automatically refresh when the browser regains a network connection (via navigator.onLine)
-  * @defaultValue `false`
-  */
-  refreshOnReconnect?: boolean;
-  /**
-  * Automatically refresh on an interval when the Live Event API emits a `goaway` event, which indicates that the connection is rejected or closed.
-  * This typically happens if the connection limit is reached, or if the connection is idle for too long.
-  * To disable this long polling fallback behavior set `intervalOnGoAway` to `false` or `0`.
-  * You can also use `onGoAway` to handle the `goaway` event in your own way, and read the reason why the event was emitted.
-  * @defaultValue `30_000` 30 seconds interval
-  */
-  intervalOnGoAway?: number | false;
-  /**
-  * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.
-  * @see https://www.sanity.io/docs/reference-api-request-tags
-  * @defaultValue 'next-loader.live'
-  */
-  requestTag?: string;
-  /**
-  * Handle errors from the Live Events subscription.
-  * By default it's reported using `console.error`, you can override this prop to handle it in your own way.
-  */
-  onError?: (error: unknown) => void;
-  /**
-  * Handle the `goaway` event if the connection is rejected/closed.
-  * `event.reason` will be a string of why the event was emitted, for example `'connection limit reached'`.
-  * When this happens the `<SanityLive />` will fallback to long polling with a default interval of 30 seconds, providing your own `onGoAway` handler does not change this behavior.
-  * If you want to disable long polling set `intervalOnGoAway` to `false` or `0`.
-  */
-  onGoAway?: (event: LiveEventGoAway, intervalOnGoAway: number | false) => void;
-  /**
-  * Override how cache tags are invalidated, you need to pass a server action here.
-  * You can also pass a `use client` function here, and have `router.refresh()` be called if the promise resolves to `'refresh'`.
-  */
-  revalidateSyncTags?: (tags: `${typeof PUBLISHED_SYNC_TAG_PREFIX | typeof DRAFT_SYNC_TAG_PREFIX}${SyncTag}`[]) => Promise<void | "refresh">;
-  /**
-  * Control how the draft mode perspective is resolved, by default it resolves from the `sanity-preview-perspective` cookie.
-  */
-  resolveDraftModePerspective?: () => Promise<ClientPerspective>;
-}
-/**
-* @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.
-*/
-interface DefineSanityLiveOptions {
-  /**
-  * Required for `sanityFetch` and `SanityLive` to work
-  */
-  client: SanityClient;
-  /**
-  * Optional. If provided then the token needs to have permissions to query documents with `drafts.` prefixes in order for `perspective: 'drafts'` to work.
-  * This token is not shared with the browser.
-  */
-  serverToken?: string | false;
-  /**
-  * Optional. This token is shared with the browser, and should only have access to query published documents.
-  * It is used to setup a `Live Draft Content` EventSource connection, and enables live previewing drafts stand-alone, outside of Presentation Tool.
-  */
-  browserToken?: string | false;
-}
-/**
-* @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.
-*/
-declare function defineLive(config: DefineSanityLiveOptions): {
-  /**
-  * Use this function to fetch data from Sanity in your React Server Components.
+  * @deprecated use `fetch` instead, and define your own `sanityFetch` function with logic for when to toggle `stega` and `perspective`
   */
   sanityFetch: DefinedSanityFetchType;
   /**
-  * Render this in your root layout.tsx to make your page revalidate on new content live, automatically.
+  * @deprecated use `Live` instead, and define your own `SanityLive` component with logic for when to toggle `perspective`
   */
   SanityLive: React.ComponentType<DefinedSanityLiveProps>;
 };
-export { type DefineSanityLiveOptions, type DefinedSanityFetchType, type DefinedSanityLiveProps, type SanityFetchOptions, defineLive, isCorsOriginError, resolvePerspectiveFromCookies };
+export { type PerspectiveType as LivePerspective, defineLive, isCorsOriginError, resolvePerspectiveFromCookies };
 //# sourceMappingURL=live.next-js.d.ts.map

package/dist/live.next-js.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live.next-js.d.ts","names":[],"sources":["../src/experimental/live.tsx"],"sourcesContent":[],"mappings":";;;;;;;AAqFiB,UAAA,kBAAA,CAAA,oBAAA,MAAA,CAAA,CAAA;EACR,KAAA,EAAA,WAAA;EACE,MAAA,CAAA,EAAA,WAAA;EAIa;;;EAqBxB,WAAY,CAAA,EArBI,OAqBJ,CArBY,iBAqBZ,EAAA,KAAA,CAAA;EACkB;;;;EAOjB,KAAA,CAAA,EAAA,OAAA;EANR;;AAgBL;;;EAoDuD,UAAA,CAAA,EAAA,MAAA;EAAwB;;;EAUzC,IAAA,CAAA,EAAA,MAAA,EAAA;;AAMtC;AAoBA;;AAIe,KA9GH,sBAAA,GA8GG,CAAA,0BAAA,MAAA,CAAA,CAAA,OAAA,EA7GJ,kBA6GI,CA7Ge,WA6Gf,CAAA,EAAA,GA5GV,OA4GU,CAAA;EAImB,IAAA,EA/G1B,YA+G0B,CA/Gb,WA+Ga,EAAA,OAAA,CAAA;EAApB;;;;aA1GD;;;;;;;;;UAUI,sBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4CI;;;;;wCAQD,mCAAmC,wBAAwB,gBACxE;;;;sCAS+B,QAAQ;;;;;UAM7B,uBAAA;;;;UAIP;;;;;;;;;;;;;;;iBAgBM,UAAA,SAAmB;;;;eAIpB;;;;cAID,KAAA,CAAM,cAAc"}
+{"version":3,"file":"live.next-js.d.ts","names":[],"sources":["../src/experimental/live.tsx"],"sourcesContent":[],"mappings":";;iBAagB,UAAA,SAAmB;EAAnC,KAAgB,EACP,gBADO;EAAmB,IAAA,EAE3B,KAAA,CAAM,aAFqB,CAEP,gBAFO,CAAA;EAC1B;;;EAKM,WAAA,EAAA,sBAAA;EAImB;;;cAApB,KAAA,CAAM,cAAc"}

package/dist/live.next-js.js

@@ -1,40 +1,12 @@
 import { t as isCorsOriginError } from "./isCorsOriginError.js";
 import { n as PUBLISHED_SYNC_TAG_PREFIX, t as DRAFT_SYNC_TAG_PREFIX } from "./constants.js";
 import { t as resolvePerspectiveFromCookies } from "./resolvePerspectiveFromCookies.js";
-import { cacheLife, cacheTag, updateTag } from "next/cache";
 import { cookies, draftMode } from "next/headers";
-import { stegaEncodeSourceMap } from "@sanity/client/stega";
+import { Suspense } from "react";
 import { jsx } from "react/jsx-runtime";
-import { createClient } from "next-sanity";
 import SanityLiveClientComponent from "next-sanity/experimental/client-components/live";
+import { cacheTag, updateTag } from "next/cache";
 import { preconnect } from "react-dom";
-async function sanityCachedFetch(config, { query, params = {}, perspective, stega, requestTag, draftToken, customCacheTags = [] }) {
-	"use cache: remote";
-	const client = createClient({
-		...config,
-		useCdn: true
-	});
-	const useCdn = perspective === "published";
-	const { result, resultSourceMap, syncTags } = await client.fetch(query, params, {
-		filterResponse: false,
-		returnQuery: false,
-		perspective,
-		useCdn,
-		resultSourceMap: stega ? "withKeyArraySelector" : void 0,
-		stega: false,
-		cacheMode: useCdn ? "noStale" : void 0,
-		tag: requestTag,
-		token: perspective === "published" ? config.token : draftToken || config.token
-	});
-	const tags = [...customCacheTags, ...(syncTags || []).map((tag) => `${perspective === "published" ? PUBLISHED_SYNC_TAG_PREFIX : DRAFT_SYNC_TAG_PREFIX}${tag}`)];
-	cacheTag(...tags);
-	cacheLife({ revalidate: 3600 * 24 * 90 });
-	return {
-		data: result,
-		sourceMap: resultSourceMap || null,
-		tags
-	};
-}
 function defineLive(config) {
 	const { client: _client, serverToken, browserToken } = config;
 	if (!_client) throw new Error("`client` is required for `defineLive` to function");
@@ -42,84 +14,69 @@ function defineLive(config) {
 	if (process.env.NODE_ENV !== "production" && !browserToken && browserToken !== false) console.warn("No `browserToken` provided to `defineLive`. This means that live previewing drafts will only work when using the Presentation Tool in your Sanity Studio. To support live previewing drafts stand-alone, provide a `browserToken`. It is shared with the browser so it should only have Viewer rights or lower. You can silence this warning by setting `browserToken: false`.");
 	const client = _client.withConfig({
 		allowReconfigure: false,
-		useCdn: false
+		useCdn: true
 	});
-	const { token: originalToken, apiHost, apiVersion, useProjectHostname, dataset, projectId, requestTagPrefix, stega: stegaConfig } = client.config();
+	const { token: originalToken } = client.config();
 	return {
-		sanityFetch: function sanityFetch({ query, params = {}, stega = false, perspective = "published", tags: customCacheTags = [], requestTag = "next-loader.fetch" }) {
-			return sanityCachedFetch({
-				apiHost,
-				apiVersion,
-				useProjectHostname,
-				dataset,
-				projectId,
-				requestTagPrefix,
-				token: originalToken
-			}, {
-				query,
-				params,
+		fetch: async function fetch({ query, params = {}, perspective = "published", stega = false, tags: customCacheTags = [], requestTag = "next-loader.fetch.cache-components" }) {
+			const useCdn = perspective === "published";
+			const { result, resultSourceMap, syncTags } = await client.fetch(query, params, {
+				filterResponse: false,
+				returnQuery: false,
 				perspective,
+				useCdn,
 				stega,
-				requestTag,
-				draftToken: serverToken,
-				customCacheTags
-			}).then(({ data, sourceMap, tags }) => ({
-				data: stega && sourceMap ? stegaEncodeSourceMap(data, sourceMap, {
-					...stegaConfig,
-					enabled: true
-				}) : data,
-				sourceMap,
+				cacheMode: useCdn ? "noStale" : void 0,
+				tag: requestTag,
+				token: perspective === "published" ? originalToken : serverToken || originalToken
+			});
+			const tags = [...customCacheTags, ...(syncTags || []).map((tag) => `${perspective === "published" ? PUBLISHED_SYNC_TAG_PREFIX : DRAFT_SYNC_TAG_PREFIX}${tag}`)];
+			cacheTag(...tags);
+			return {
+				data: result,
+				sourceMap: resultSourceMap || null,
 				tags
-			}));
+			};
 		},
-		SanityLive: function SanityLive(props) {
-			const { refreshOnMount = false, refreshOnFocus = false, refreshOnReconnect = false, requestTag, onError, onGoAway, intervalOnGoAway, revalidateSyncTags = expireTags } = props;
-			const { projectId: projectId$1, dataset: dataset$1, apiHost: apiHost$1, apiVersion: apiVersion$1, useProjectHostname: useProjectHostname$1, requestTagPrefix: requestTagPrefix$1 } = client.config();
+		Live: function Live(props) {
+			const { perspective = "published", onChange, onChangeIncludingDrafts, onStudioPerspective, refreshOnMount = false, refreshOnFocus = false, refreshOnReconnect = false, requestTag = "next-loader.live.cache-components", onError, onGoAway, intervalOnGoAway } = props;
+			if (onChange) console.warn("`onChange` is not implemented yet");
+			if (onChangeIncludingDrafts) console.warn("`onChangeIncludingDrafts` is not implemented yet");
+			if (onStudioPerspective) console.warn("`onStudioPerspective` is not implemented yet");
+			const includeDrafts = typeof browserToken === "string" && perspective !== "published";
+			const { projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix } = client.config();
 			const { origin } = new URL(client.getUrl("", false));
 			preconnect(origin);
-			return /* @__PURE__ */ jsx(SanityLiveServerComponent, {
+			return /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(SanityLiveClientComponent, {
 				config: {
-					projectId: projectId$1,
-					dataset: dataset$1,
-					apiHost: apiHost$1,
-					apiVersion: apiVersion$1,
-					useProjectHostname: useProjectHostname$1,
-					requestTagPrefix: requestTagPrefix$1
+					projectId,
+					dataset,
+					apiHost,
+					apiVersion,
+					useProjectHostname,
+					requestTagPrefix,
+					token: includeDrafts ? browserToken : void 0
 				},
 				requestTag,
-				browserToken,
+				draftModeEnabled: includeDrafts,
 				refreshOnMount,
 				refreshOnFocus,
 				refreshOnReconnect,
 				onError,
 				onGoAway,
 				intervalOnGoAway,
-				revalidateSyncTags,
-				resolveDraftModePerspective: props.resolveDraftModePerspective ?? resolveDraftModePerspective
-			});
+				revalidateSyncTags: expireTags,
+				resolveDraftModePerspective
+			}) });
+		},
+		sanityFetch: () => {
+			throw new Error("`defineLive().sanityFetch` is not available when `cacheComponents: true`, use `defineLive().fetch` instead");
+		},
+		SanityLive: () => {
+			throw new Error("`defineLive().SanityLive` is not available when `cacheComponents: true`, use `defineLive().Live` instead");
 		}
 	};
 }
-const SanityLiveServerComponent = async function SanityLiveServerComponent$1(props) {
-	const { config, requestTag, intervalOnGoAway, onError, onGoAway, refreshOnFocus, refreshOnMount, refreshOnReconnect, revalidateSyncTags, browserToken, resolveDraftModePerspective: resolveDraftModePerspective$1 } = props;
-	const { isEnabled: isDraftModeEnabled } = await draftMode();
-	return /* @__PURE__ */ jsx(SanityLiveClientComponent, {
-		config: {
-			...config,
-			token: typeof browserToken === "string" && isDraftModeEnabled ? browserToken : void 0
-		},
-		requestTag,
-		draftModeEnabled: isDraftModeEnabled,
-		refreshOnMount,
-		refreshOnFocus,
-		refreshOnReconnect,
-		onError,
-		onGoAway,
-		intervalOnGoAway,
-		revalidateSyncTags,
-		resolveDraftModePerspective: resolveDraftModePerspective$1
-	});
-};
 async function expireTags(_tags) {
 	"use server";
 	if (!Array.isArray(_tags)) {

package/dist/live.next-js.js.map

@@ -1 +1 @@
-{"version":3,"file":"live.next-js.js","names":["SanityLiveServerComponent: React.ComponentType<SanityLiveServerComponentProps>","SanityLiveServerComponent","resolveDraftModePerspective"],"sources":["../src/experimental/live.tsx"],"sourcesContent":["import {resolvePerspectiveFromCookies} from '#live/resolvePerspectiveFromCookies'\nimport {stegaEncodeSourceMap} from '@sanity/client/stega'\nimport {\n  createClient,\n  type ClientPerspective,\n  type ClientReturn,\n  type ContentSourceMap,\n  type LiveEventGoAway,\n  type QueryParams,\n  type SanityClient,\n  type SyncTag,\n} from 'next-sanity'\nimport SanityLiveClientComponent, {\n  type SanityLiveProps,\n} from 'next-sanity/experimental/client-components/live'\nimport {cacheTag, cacheLife, updateTag} from 'next/cache'\nimport {draftMode, cookies} from 'next/headers'\nimport {preconnect} from 'react-dom'\n\nimport type {SanityClientConfig} from './types'\n\nimport {DRAFT_SYNC_TAG_PREFIX, PUBLISHED_SYNC_TAG_PREFIX} from './constants'\n\nasync function sanityCachedFetch<const QueryString extends string>(\n  config: SanityClientConfig,\n  {\n    query,\n    params = {},\n    perspective,\n    stega,\n    requestTag,\n    draftToken,\n    customCacheTags = [],\n  }: {\n    query: QueryString\n    params?: QueryParams\n    perspective: Exclude<ClientPerspective, 'raw'>\n    stega: boolean\n    requestTag: string\n    draftToken?: string | false | undefined\n    customCacheTags?: string[]\n  },\n): Promise<{\n  data: ClientReturn<QueryString, unknown>\n  sourceMap: ContentSourceMap | null\n  tags: string[]\n}> {\n  'use cache: remote'\n\n  const client = createClient({...config, useCdn: true})\n  const useCdn = perspective === 'published'\n\n  const {result, resultSourceMap, syncTags} = await client.fetch(query, params, {\n    filterResponse: false,\n    returnQuery: false,\n    perspective,\n    useCdn,\n    resultSourceMap: stega ? 'withKeyArraySelector' : undefined, // @TODO allow passing csm for non-stega use\n    stega: false,\n    cacheMode: useCdn ? 'noStale' : undefined,\n    tag: requestTag,\n    token: perspective === 'published' ? config.token : draftToken || config.token, // @TODO can pass undefined instead of config.token here?\n  })\n  const tags = [\n    ...customCacheTags,\n    ...(syncTags || []).map(\n      (tag) =>\n        `${perspective === 'published' ? PUBLISHED_SYNC_TAG_PREFIX : DRAFT_SYNC_TAG_PREFIX}${tag}`,\n    ),\n  ]\n  /**\n   * The tags used here, are expired later on in the `expireTags` Server Action with the `expireTag` function from `next/cache`\n   */\n  cacheTag(...tags)\n  /**\n   * Sanity Live handles on-demand revalidation, so the default 15min time based revalidation is too short\n   */\n  cacheLife({revalidate: 60 * 60 * 24 * 90})\n\n  return {data: result, sourceMap: resultSourceMap || null, tags}\n}\n\n/**\n * @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.\n */\nexport interface SanityFetchOptions<QueryString extends string> {\n  query: QueryString\n  params?: QueryParams\n  /**\n   * @defaultValue 'published'\n   */\n  perspective?: Exclude<ClientPerspective, 'raw'>\n  /**\n   * Enables stega encoding of the data, this is typically only used in draft mode in conjunction with `perspective: 'drafts'` and with `@sanity/visual-editing` setup.\n   * @defaultValue `false`\n   */\n  stega?: boolean\n  /**\n   * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.\n   * @see https://www.sanity.io/docs/reference-api-request-tags\n   * @defaultValue 'next-loader.fetch'\n   */\n  requestTag?: string\n  /**\n   * Custom cache tags that can be used with next's `revalidateTag` and `updateTag` functions for custom webhook on-demand revalidation.\n   */\n  tags?: string[]\n}\n\n/**\n * @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.\n */\nexport type DefinedSanityFetchType = <const QueryString extends string>(\n  options: SanityFetchOptions<QueryString>,\n) => Promise<{\n  data: ClientReturn<QueryString, unknown>\n  /**\n   * The Content Source Map can be used for custom setups like `encodeSourceMap` for `data-sanity` attributes, or `stegaEncodeSourceMap` for stega encoding in your own way.\n   * The Content Source Map is only fetched by default in draft mode, if `stega` is `true`. Otherwise your client configuration will need to have `resultSourceMap: 'withKeyArraySelector' | true`\n   */\n  sourceMap: ContentSourceMap | null\n  /**\n   * The cache tags used with `next/cache`, useful for debugging.\n   */\n  tags: string[]\n}>\n\n/**\n * @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.\n */\nexport interface DefinedSanityLiveProps {\n  /**\n   * Automatic refresh of RSC when the component <SanityLive /> is mounted.\n   * @defaultValue `false`\n   */\n  refreshOnMount?: boolean\n  /**\n   * Automatically refresh when window gets focused\n   * @defaultValue `false`\n   */\n  refreshOnFocus?: boolean\n  /**\n   * Automatically refresh when the browser regains a network connection (via navigator.onLine)\n   * @defaultValue `false`\n   */\n  refreshOnReconnect?: boolean\n  /**\n   * Automatically refresh on an interval when the Live Event API emits a `goaway` event, which indicates that the connection is rejected or closed.\n   * This typically happens if the connection limit is reached, or if the connection is idle for too long.\n   * To disable this long polling fallback behavior set `intervalOnGoAway` to `false` or `0`.\n   * You can also use `onGoAway` to handle the `goaway` event in your own way, and read the reason why the event was emitted.\n   * @defaultValue `30_000` 30 seconds interval\n   */\n  intervalOnGoAway?: number | false\n\n  /**\n   * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.\n   * @see https://www.sanity.io/docs/reference-api-request-tags\n   * @defaultValue 'next-loader.live'\n   */\n  requestTag?: string\n\n  /**\n   * Handle errors from the Live Events subscription.\n   * By default it's reported using `console.error`, you can override this prop to handle it in your own way.\n   */\n  onError?: (error: unknown) => void\n\n  /**\n   * Handle the `goaway` event if the connection is rejected/closed.\n   * `event.reason` will be a string of why the event was emitted, for example `'connection limit reached'`.\n   * When this happens the `<SanityLive />` will fallback to long polling with a default interval of 30 seconds, providing your own `onGoAway` handler does not change this behavior.\n   * If you want to disable long polling set `intervalOnGoAway` to `false` or `0`.\n   */\n  onGoAway?: (event: LiveEventGoAway, intervalOnGoAway: number | false) => void\n\n  /**\n   * Override how cache tags are invalidated, you need to pass a server action here.\n   * You can also pass a `use client` function here, and have `router.refresh()` be called if the promise resolves to `'refresh'`.\n   */\n  // @TODO remove, replace with onLiveEvent\n  revalidateSyncTags?: (\n    tags: `${typeof PUBLISHED_SYNC_TAG_PREFIX | typeof DRAFT_SYNC_TAG_PREFIX}${SyncTag}`[],\n  ) => Promise<void | 'refresh'>\n\n  // @TODO add\n  // decide how to handle a live event coming in\n  // onLiveEvent?: (event: LiveEvent, mode: 'production' | 'preview) => void\n\n  /**\n   * Control how the draft mode perspective is resolved, by default it resolves from the `sanity-preview-perspective` cookie.\n   */\n  resolveDraftModePerspective?: () => Promise<ClientPerspective>\n}\n\n/**\n * @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.\n */\nexport interface DefineSanityLiveOptions {\n  /**\n   * Required for `sanityFetch` and `SanityLive` to work\n   */\n  client: SanityClient\n  /**\n   * Optional. If provided then the token needs to have permissions to query documents with `drafts.` prefixes in order for `perspective: 'drafts'` to work.\n   * This token is not shared with the browser.\n   */\n  serverToken?: string | false\n  /**\n   * Optional. This token is shared with the browser, and should only have access to query published documents.\n   * It is used to setup a `Live Draft Content` EventSource connection, and enables live previewing drafts stand-alone, outside of Presentation Tool.\n   */\n  browserToken?: string | false\n}\n\n/**\n * @alpha CAUTION: This API does not follow semver and could have breaking changes in future minor releases.\n */\nexport function defineLive(config: DefineSanityLiveOptions): {\n  /**\n   * Use this function to fetch data from Sanity in your React Server Components.\n   */\n  sanityFetch: DefinedSanityFetchType\n  /**\n   * Render this in your root layout.tsx to make your page revalidate on new content live, automatically.\n   */\n  SanityLive: React.ComponentType<DefinedSanityLiveProps>\n} {\n  const {client: _client, serverToken, browserToken} = config\n\n  if (!_client) {\n    throw new Error('`client` is required for `defineLive` to function')\n  }\n\n  if (process.env.NODE_ENV !== 'production' && !serverToken && serverToken !== false) {\n    console.warn(\n      'No `serverToken` provided to `defineLive`. This means that only published content will be fetched and respond to live events. You can silence this warning by setting `serverToken: false`.',\n    )\n  }\n\n  if (process.env.NODE_ENV !== 'production' && !browserToken && browserToken !== false) {\n    console.warn(\n      'No `browserToken` provided to `defineLive`. This means that live previewing drafts will only work when using the Presentation Tool in your Sanity Studio. To support live previewing drafts stand-alone, provide a `browserToken`. It is shared with the browser so it should only have Viewer rights or lower. You can silence this warning by setting `browserToken: false`.',\n    )\n  }\n\n  const client = _client.withConfig({allowReconfigure: false, useCdn: false})\n  const {\n    token: originalToken,\n    apiHost,\n    apiVersion,\n    useProjectHostname,\n    dataset,\n    projectId,\n    requestTagPrefix,\n    stega: stegaConfig,\n  } = client.config()\n\n  const sanityFetch: DefinedSanityFetchType = function sanityFetch<\n    const QueryString extends string,\n  >({\n    query,\n    params = {},\n    stega = false,\n    perspective = 'published',\n    tags: customCacheTags = [],\n    requestTag = 'next-loader.fetch',\n  }: {\n    query: QueryString\n    params?: QueryParams\n    stega?: boolean\n    tags?: string[]\n    perspective?: Exclude<ClientPerspective, 'raw'>\n    requestTag?: string\n  }) {\n    return sanityCachedFetch(\n      {\n        apiHost,\n        apiVersion,\n        useProjectHostname,\n        dataset,\n        projectId,\n        requestTagPrefix,\n        token: originalToken,\n      },\n      {\n        query,\n        params,\n        perspective,\n        stega,\n        requestTag,\n        draftToken: serverToken,\n        customCacheTags,\n      },\n    ).then(({data, sourceMap, tags}) => ({\n      data:\n        stega && sourceMap\n          ? stegaEncodeSourceMap(data, sourceMap, {...stegaConfig, enabled: true})\n          : data,\n      sourceMap,\n      tags,\n    }))\n  }\n\n  const SanityLive: React.ComponentType<DefinedSanityLiveProps> = function SanityLive(props) {\n    const {\n      // perspective,\n      refreshOnMount = false,\n      refreshOnFocus = false,\n      refreshOnReconnect = false,\n      requestTag,\n      onError,\n      onGoAway,\n      intervalOnGoAway,\n      revalidateSyncTags = expireTags,\n    } = props\n\n    const {projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix} =\n      client.config()\n    const {origin} = new URL(client.getUrl('', false))\n\n    // Preconnect to the Live Event API origin early, as the Sanity API is almost always on a different origin than the app\n    preconnect(origin)\n\n    return (\n      <SanityLiveServerComponent\n        config={{projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix}}\n        requestTag={requestTag}\n        browserToken={browserToken}\n        // origin={origin}\n        refreshOnMount={refreshOnMount}\n        refreshOnFocus={refreshOnFocus}\n        refreshOnReconnect={refreshOnReconnect}\n        onError={onError}\n        onGoAway={onGoAway}\n        intervalOnGoAway={intervalOnGoAway}\n        revalidateSyncTags={revalidateSyncTags}\n        resolveDraftModePerspective={\n          props.resolveDraftModePerspective ?? resolveDraftModePerspective\n        }\n      />\n    )\n  }\n\n  return {sanityFetch, SanityLive}\n}\n\ninterface SanityLiveServerComponentProps extends Omit<\n  SanityLiveProps,\n  'draftModeEnabled' | 'token' | 'draftModePerspective'\n> {\n  browserToken: string | false | undefined\n  // origin: string\n  // perspective?: Exclude<ClientPerspective, 'raw'>\n}\n\nconst SanityLiveServerComponent: React.ComponentType<SanityLiveServerComponentProps> =\n  async function SanityLiveServerComponent(props) {\n    // 'use cache'\n    // @TODO should this be 'max' instead?, or configured by changing the default cache profile?\n    // cacheLife({\n    //   stale: Infinity,\n    //   revalidate: Infinity,\n    //   expire: Infinity,\n    // })\n    const {\n      config,\n      requestTag,\n      intervalOnGoAway,\n      onError,\n      onGoAway,\n      refreshOnFocus,\n      refreshOnMount,\n      refreshOnReconnect,\n      revalidateSyncTags,\n      browserToken,\n      // origin,\n      // perspective,\n      resolveDraftModePerspective,\n    } = props\n\n    const {isEnabled: isDraftModeEnabled} = await draftMode()\n\n    // // Preconnect to the Live Event API origin early, as the Sanity API is almost always on a different origin than the app\n    // preconnect(origin)\n\n    return (\n      <SanityLiveClientComponent\n        config={{\n          ...config,\n          token: typeof browserToken === 'string' && isDraftModeEnabled ? browserToken : undefined,\n        }}\n        requestTag={requestTag}\n        draftModeEnabled={isDraftModeEnabled}\n        refreshOnMount={refreshOnMount}\n        refreshOnFocus={refreshOnFocus}\n        refreshOnReconnect={refreshOnReconnect}\n        onError={onError}\n        onGoAway={onGoAway}\n        intervalOnGoAway={intervalOnGoAway}\n        revalidateSyncTags={revalidateSyncTags}\n        resolveDraftModePerspective={resolveDraftModePerspective}\n      />\n    )\n  }\n\n// @TODO expose parseTags function that returns the correct array of tags\n// we already have s1: prefixes, but they could change\n// use sp: for prod, sd: for draft, keep em short\nasync function expireTags(_tags: unknown): Promise<void> {\n  'use server'\n  // @TODO Draft Mode bypasses cache anyway so we don't bother with expiring tags for draft content\n  // const isDraftMode = (await draftMode()).isEnabled\n  // const tags = _tags.map((tag) => `${isDraftMode ? 'drafts' : 'sanity'}:${tag}`)\n  if (!Array.isArray(_tags)) {\n    console.warn('<SanityLive /> `expireTags` called with non-array tags', _tags)\n    return undefined\n  }\n  const tags = _tags.filter(\n    (tag) => typeof tag === 'string' && tag.startsWith(PUBLISHED_SYNC_TAG_PREFIX),\n  )\n  if (!tags.length) {\n    console.warn('<SanityLive /> `expireTags` called with no valid tags', _tags)\n    return undefined\n  }\n  for (const tag of tags) {\n    updateTag(tag)\n  }\n  // oxlint-disable-next-line no-console\n  console.log(`<SanityLive /> updated tags: ${tags.join(', ')}`)\n}\n\nasync function resolveDraftModePerspective(): Promise<ClientPerspective> {\n  'use server'\n  if ((await draftMode()).isEnabled) {\n    const jar = await cookies()\n    return resolvePerspectiveFromCookies({cookies: jar})\n  }\n  return 'published'\n}\n\n// revalidateSyncTags => actionUpdateTags\n// router.refresh() => actionRefresh\n"],"mappings":";;;;;;;;;;AAuBA,eAAe,kBACb,QACA,EACE,OACA,SAAS,EAAE,EACX,aACA,OACA,YACA,YACA,kBAAkB,EAAE,IAcrB;AACD;CAEA,MAAM,SAAS,aAAa;EAAC,GAAG;EAAQ,QAAQ;EAAK,CAAC;CACtD,MAAM,SAAS,gBAAgB;CAE/B,MAAM,EAAC,QAAQ,iBAAiB,aAAY,MAAM,OAAO,MAAM,OAAO,QAAQ;EAC5E,gBAAgB;EAChB,aAAa;EACb;EACA;EACA,iBAAiB,QAAQ,yBAAyB,KAAA;EAClD,OAAO;EACP,WAAW,SAAS,YAAY,KAAA;EAChC,KAAK;EACL,OAAO,gBAAgB,cAAc,OAAO,QAAQ,cAAc,OAAO;EAC1E,CAAC;CACF,MAAM,OAAO,CACX,GAAG,iBACH,IAAI,YAAY,EAAE,EAAE,KACjB,QACC,GAAG,gBAAgB,cAAc,4BAA4B,wBAAwB,MACxF,CACF;AAID,UAAS,GAAG,KAAK;AAIjB,WAAU,EAAC,YAAY,OAAU,KAAK,IAAG,CAAC;AAE1C,QAAO;EAAC,MAAM;EAAQ,WAAW,mBAAmB;EAAM;EAAK;;AA2IjE,SAAgB,WAAW,QASzB;CACA,MAAM,EAAC,QAAQ,SAAS,aAAa,iBAAgB;AAErD,KAAI,CAAC,QACH,OAAM,IAAI,MAAM,oDAAoD;AAGtE,KAAI,QAAQ,IAAI,aAAa,gBAAgB,CAAC,eAAe,gBAAgB,MAC3E,SAAQ,KACN,8LACD;AAGH,KAAI,QAAQ,IAAI,aAAa,gBAAgB,CAAC,gBAAgB,iBAAiB,MAC7E,SAAQ,KACN,iXACD;CAGH,MAAM,SAAS,QAAQ,WAAW;EAAC,kBAAkB;EAAO,QAAQ;EAAM,CAAC;CAC3E,MAAM,EACJ,OAAO,eACP,SACA,YACA,oBACA,SACA,WACA,kBACA,OAAO,gBACL,OAAO,QAAQ;AAwFnB,QAAO;EAAC,aAtFoC,SAAS,YAEnD,EACA,OACA,SAAS,EAAE,EACX,QAAQ,OACR,cAAc,aACd,MAAM,kBAAkB,EAAE,EAC1B,aAAa,uBAQZ;AACD,UAAO,kBACL;IACE;IACA;IACA;IACA;IACA;IACA;IACA,OAAO;IACR,EACD;IACE;IACA;IACA;IACA;IACA;IACA,YAAY;IACZ;IACD,CACF,CAAC,MAAM,EAAC,MAAM,WAAW,YAAW;IACnC,MACE,SAAS,YACL,qBAAqB,MAAM,WAAW;KAAC,GAAG;KAAa,SAAS;KAAK,CAAC,GACtE;IACN;IACA;IACD,EAAE;;EA2CgB,YAxC2C,SAAS,WAAW,OAAO;GACzF,MAAM,EAEJ,iBAAiB,OACjB,iBAAiB,OACjB,qBAAqB,OACrB,YACA,SACA,UACA,kBACA,qBAAqB,eACnB;GAEJ,MAAM,EAAC,WAAA,aAAW,SAAA,WAAS,SAAA,WAAS,YAAA,cAAY,oBAAA,sBAAoB,kBAAA,uBAClE,OAAO,QAAQ;GACjB,MAAM,EAAC,WAAU,IAAI,IAAI,OAAO,OAAO,IAAI,MAAM,CAAC;AAGlD,cAAW,OAAO;AAElB,UACE,oBAAC,2BAAA;IACC,QAAQ;KAAC,WAAA;KAAW,SAAA;KAAS,SAAA;KAAS,YAAA;KAAY,oBAAA;KAAoB,kBAAA;KAAiB;IAC3E;IACE;IAEE;IACA;IACI;IACX;IACC;IACQ;IACE;IACpB,6BACE,MAAM,+BAA+B;KAEvC;;EAI0B;;AAYlC,MAAMA,4BACJ,eAAeC,4BAA0B,OAAO;CAQ9C,MAAM,EACJ,QACA,YACA,kBACA,SACA,UACA,gBACA,gBACA,oBACA,oBACA,cAGA,6BAAA,kCACE;CAEJ,MAAM,EAAC,WAAW,uBAAsB,MAAM,WAAW;AAKzD,QACE,oBAAC,2BAAA;EACC,QAAQ;GACN,GAAG;GACH,OAAO,OAAO,iBAAiB,YAAY,qBAAqB,eAAe,KAAA;GAChF;EACW;EACZ,kBAAkB;EACF;EACA;EACI;EACX;EACC;EACQ;EACE;EACpB,6BAA6BC;GAC7B;;AAOR,eAAe,WAAW,OAA+B;AACvD;AAIA,KAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAQ,KAAK,0DAA0D,MAAM;AAC7E;;CAEF,MAAM,OAAO,MAAM,QAChB,QAAQ,OAAO,QAAQ,YAAY,IAAI,WAAW,0BAA0B,CAC9E;AACD,KAAI,CAAC,KAAK,QAAQ;AAChB,UAAQ,KAAK,yDAAyD,MAAM;AAC5E;;AAEF,MAAK,MAAM,OAAO,KAChB,WAAU,IAAI;AAGhB,SAAQ,IAAI,gCAAgC,KAAK,KAAK,KAAK,GAAG;;AAGhE,eAAe,8BAA0D;AACvE;AACA,MAAK,MAAM,WAAW,EAAE,UAEtB,QAAO,8BAA8B,EAAC,SAD1B,MAAM,SAAS,EACwB,CAAC;AAEtD,QAAO"}
+{"version":3,"file":"live.next-js.js","names":[],"sources":["../src/experimental/live.tsx"],"sourcesContent":["import type {DefinedFetchType, DefinedLiveProps, LiveOptions, PerspectiveType} from '#live/types'\n\nimport {resolvePerspectiveFromCookies} from '#live/resolvePerspectiveFromCookies'\nimport SanityLiveClientComponent from 'next-sanity/experimental/client-components/live'\nimport {cacheTag, updateTag} from 'next/cache'\nimport {draftMode, cookies} from 'next/headers'\nimport {Suspense} from 'react'\nimport {preconnect} from 'react-dom'\n\nimport type {DefinedSanityFetchType, DefinedSanityLiveProps} from '../live/defineLive'\n\nimport {DRAFT_SYNC_TAG_PREFIX, PUBLISHED_SYNC_TAG_PREFIX} from './constants'\n\nexport function defineLive(config: LiveOptions): {\n  fetch: DefinedFetchType\n  Live: React.ComponentType<DefinedLiveProps>\n  /**\n   * @deprecated use `fetch` instead, and define your own `sanityFetch` function with logic for when to toggle `stega` and `perspective`\n   */\n  sanityFetch: DefinedSanityFetchType\n  /**\n   * @deprecated use `Live` instead, and define your own `SanityLive` component with logic for when to toggle `perspective`\n   */\n  SanityLive: React.ComponentType<DefinedSanityLiveProps>\n} {\n  const {client: _client, serverToken, browserToken} = config\n\n  if (!_client) {\n    throw new Error('`client` is required for `defineLive` to function')\n  }\n\n  if (process.env.NODE_ENV !== 'production' && !serverToken && serverToken !== false) {\n    console.warn(\n      'No `serverToken` provided to `defineLive`. This means that only published content will be fetched and respond to live events. You can silence this warning by setting `serverToken: false`.',\n    )\n  }\n\n  if (process.env.NODE_ENV !== 'production' && !browserToken && browserToken !== false) {\n    console.warn(\n      'No `browserToken` provided to `defineLive`. This means that live previewing drafts will only work when using the Presentation Tool in your Sanity Studio. To support live previewing drafts stand-alone, provide a `browserToken`. It is shared with the browser so it should only have Viewer rights or lower. You can silence this warning by setting `browserToken: false`.',\n    )\n  }\n\n  const client = _client.withConfig({allowReconfigure: false, useCdn: true})\n  const {token: originalToken} = client.config()\n\n  const fetch: DefinedFetchType = async function fetch({\n    query,\n    params = {},\n    perspective = 'published',\n    stega = false,\n    tags: customCacheTags = [],\n    requestTag = 'next-loader.fetch.cache-components',\n  }) {\n    const useCdn = perspective === 'published'\n\n    const {result, resultSourceMap, syncTags} = await client.fetch(query, params, {\n      filterResponse: false,\n      returnQuery: false,\n      perspective,\n      useCdn,\n      stega,\n      cacheMode: useCdn ? 'noStale' : undefined,\n      tag: requestTag,\n      token: perspective === 'published' ? originalToken : serverToken || originalToken, // @TODO can pass undefined instead of config.token here?\n    })\n    const tags = [\n      ...customCacheTags,\n      ...(syncTags || []).map(\n        (tag) =>\n          `${perspective === 'published' ? PUBLISHED_SYNC_TAG_PREFIX : DRAFT_SYNC_TAG_PREFIX}${tag}`,\n      ),\n    ]\n    /**\n     * The tags used here, are expired later on in the `expireTags` Server Action with the `expireTag` function from `next/cache`\n     */\n    cacheTag(...tags)\n    /**\n     * Sanity Live handles on-demand revalidation, so the default 15min time based revalidation is too short\n     */\n    // cacheLife({revalidate: 60 * 60 * 24 * 90})\n\n    return {data: result, sourceMap: resultSourceMap || null, tags}\n\n    // return sanityCachedFetch(\n    //   {\n    //     apiHost,\n    //     apiVersion,\n    //     useProjectHostname,\n    //     dataset,\n    //     projectId,\n    //     requestTagPrefix,\n    //     token: originalToken,\n    //   },\n    //   {\n    //     query,\n    //     params,\n    //     perspective,\n    //     stega,\n    //     requestTag,\n    //     draftToken: serverToken,\n    //     customCacheTags,\n    //   },\n    // ).then(({data, sourceMap, tags}) => ({\n    //   data:\n    //     stega && sourceMap\n    //       ? stegaEncodeSourceMap(data, sourceMap, {...stegaConfig, enabled: true})\n    //       : data,\n    //   sourceMap,\n    //   tags,\n    // }))\n  }\n\n  const Live: React.ComponentType<DefinedLiveProps> = function Live(props) {\n    const {\n      perspective = 'published',\n      onChange,\n      onChangeIncludingDrafts,\n      onStudioPerspective,\n      refreshOnMount = false,\n      refreshOnFocus = false,\n      refreshOnReconnect = false,\n      requestTag = 'next-loader.live.cache-components',\n      onError,\n      onGoAway,\n      intervalOnGoAway,\n    } = props\n\n    if (onChange) {\n      console.warn('`onChange` is not implemented yet')\n    }\n    if (onChangeIncludingDrafts) {\n      console.warn('`onChangeIncludingDrafts` is not implemented yet')\n    }\n    if (onStudioPerspective) {\n      console.warn('`onStudioPerspective` is not implemented yet')\n    }\n\n    const includeDrafts = typeof browserToken === 'string' && perspective !== 'published'\n\n    const {projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix} =\n      client.config()\n    const {origin} = new URL(client.getUrl('', false))\n\n    // Preconnect to the Live Event API origin early, as the Sanity API is almost always on a different origin than the app\n    preconnect(origin)\n\n    return (\n      <Suspense>\n        <SanityLiveClientComponent\n          config={{\n            projectId,\n            dataset,\n            apiHost,\n            apiVersion,\n            useProjectHostname,\n            requestTagPrefix,\n            token: includeDrafts ? browserToken : undefined,\n          }}\n          requestTag={requestTag}\n          // origin={origin}\n          draftModeEnabled={includeDrafts}\n          refreshOnMount={refreshOnMount}\n          refreshOnFocus={refreshOnFocus}\n          refreshOnReconnect={refreshOnReconnect}\n          onError={onError}\n          onGoAway={onGoAway}\n          intervalOnGoAway={intervalOnGoAway}\n          revalidateSyncTags={expireTags}\n          resolveDraftModePerspective={resolveDraftModePerspective}\n        />\n      </Suspense>\n    )\n  }\n\n  return {\n    fetch,\n    Live,\n    sanityFetch: () => {\n      throw new Error(\n        '`defineLive().sanityFetch` is not available when `cacheComponents: true`, use `defineLive().fetch` instead',\n      )\n    },\n    SanityLive: () => {\n      throw new Error(\n        '`defineLive().SanityLive` is not available when `cacheComponents: true`, use `defineLive().Live` instead',\n      )\n    },\n  }\n}\n\n// @TODO expose parseTags function that returns the correct array of tags\n// we already have s1: prefixes, but they could change\n// use sp: for prod, sd: for draft, keep em short\nasync function expireTags(_tags: unknown): Promise<void> {\n  'use server'\n  // @TODO Draft Mode bypasses cache anyway so we don't bother with expiring tags for draft content\n  // const isDraftMode = (await draftMode()).isEnabled\n  // const tags = _tags.map((tag) => `${isDraftMode ? 'drafts' : 'sanity'}:${tag}`)\n  if (!Array.isArray(_tags)) {\n    console.warn('<SanityLive /> `expireTags` called with non-array tags', _tags)\n    return undefined\n  }\n  const tags = _tags.filter(\n    (tag) => typeof tag === 'string' && tag.startsWith(PUBLISHED_SYNC_TAG_PREFIX),\n  )\n  if (!tags.length) {\n    console.warn('<SanityLive /> `expireTags` called with no valid tags', _tags)\n    return undefined\n  }\n  for (const tag of tags) {\n    updateTag(tag)\n  }\n  // oxlint-disable-next-line no-console\n  console.log(`<SanityLive /> updated tags: ${tags.join(', ')}`)\n}\n\nasync function resolveDraftModePerspective(): Promise<PerspectiveType> {\n  'use server'\n  if ((await draftMode()).isEnabled) {\n    const jar = await cookies()\n    return resolvePerspectiveFromCookies({cookies: jar})\n  }\n  return 'published'\n}\n\n// revalidateSyncTags => actionUpdateTags\n// router.refresh() => actionRefresh\n"],"mappings":";;;;;;;;;AAaA,SAAgB,WAAW,QAWzB;CACA,MAAM,EAAC,QAAQ,SAAS,aAAa,iBAAgB;AAErD,KAAI,CAAC,QACH,OAAM,IAAI,MAAM,oDAAoD;AAGtE,KAAI,QAAQ,IAAI,aAAa,gBAAgB,CAAC,eAAe,gBAAgB,MAC3E,SAAQ,KACN,8LACD;AAGH,KAAI,QAAQ,IAAI,aAAa,gBAAgB,CAAC,gBAAgB,iBAAiB,MAC7E,SAAQ,KACN,iXACD;CAGH,MAAM,SAAS,QAAQ,WAAW;EAAC,kBAAkB;EAAO,QAAQ;EAAK,CAAC;CAC1E,MAAM,EAAC,OAAO,kBAAiB,OAAO,QAAQ;AAmI9C,QAAO;EACL,OAlI8B,eAAe,MAAM,EACnD,OACA,SAAS,EAAE,EACX,cAAc,aACd,QAAQ,OACR,MAAM,kBAAkB,EAAE,EAC1B,aAAa,wCACZ;GACD,MAAM,SAAS,gBAAgB;GAE/B,MAAM,EAAC,QAAQ,iBAAiB,aAAY,MAAM,OAAO,MAAM,OAAO,QAAQ;IAC5E,gBAAgB;IAChB,aAAa;IACb;IACA;IACA;IACA,WAAW,SAAS,YAAY,KAAA;IAChC,KAAK;IACL,OAAO,gBAAgB,cAAc,gBAAgB,eAAe;IACrE,CAAC;GACF,MAAM,OAAO,CACX,GAAG,iBACH,IAAI,YAAY,EAAE,EAAE,KACjB,QACC,GAAG,gBAAgB,cAAc,4BAA4B,wBAAwB,MACxF,CACF;AAID,YAAS,GAAG,KAAK;AAMjB,UAAO;IAAC,MAAM;IAAQ,WAAW,mBAAmB;IAAM;IAAK;;EA+F/D,MAhEkD,SAAS,KAAK,OAAO;GACvE,MAAM,EACJ,cAAc,aACd,UACA,yBACA,qBACA,iBAAiB,OACjB,iBAAiB,OACjB,qBAAqB,OACrB,aAAa,qCACb,SACA,UACA,qBACE;AAEJ,OAAI,SACF,SAAQ,KAAK,oCAAoC;AAEnD,OAAI,wBACF,SAAQ,KAAK,mDAAmD;AAElE,OAAI,oBACF,SAAQ,KAAK,+CAA+C;GAG9D,MAAM,gBAAgB,OAAO,iBAAiB,YAAY,gBAAgB;GAE1E,MAAM,EAAC,WAAW,SAAS,SAAS,YAAY,oBAAoB,qBAClE,OAAO,QAAQ;GACjB,MAAM,EAAC,WAAU,IAAI,IAAI,OAAO,OAAO,IAAI,MAAM,CAAC;AAGlD,cAAW,OAAO;AAElB,UACE,oBAAC,UAAA,EAAA,UACC,oBAAC,2BAAA;IACC,QAAQ;KACN;KACA;KACA;KACA;KACA;KACA;KACA,OAAO,gBAAgB,eAAe,KAAA;KACvC;IACW;IAEZ,kBAAkB;IACF;IACA;IACI;IACX;IACC;IACQ;IAClB,oBAAoB;IACS;KAC7B,EAAA,CACO;;EAOb,mBAAmB;AACjB,SAAM,IAAI,MACR,6GACD;;EAEH,kBAAkB;AAChB,SAAM,IAAI,MACR,2GACD;;EAEJ;;AAMH,eAAe,WAAW,OAA+B;AACvD;AAIA,KAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAQ,KAAK,0DAA0D,MAAM;AAC7E;;CAEF,MAAM,OAAO,MAAM,QAChB,QAAQ,OAAO,QAAQ,YAAY,IAAI,WAAW,0BAA0B,CAC9E;AACD,KAAI,CAAC,KAAK,QAAQ;AAChB,UAAQ,KAAK,yDAAyD,MAAM;AAC5E;;AAEF,MAAK,MAAM,OAAO,KAChB,WAAU,IAAI;AAGhB,SAAQ,IAAI,gCAAgC,KAAK,KAAK,KAAK,GAAG;;AAGhE,eAAe,8BAAwD;AACrE;AACA,MAAK,MAAM,WAAW,EAAE,UAEtB,QAAO,8BAA8B,EAAC,SAD1B,MAAM,SAAS,EACwB,CAAC;AAEtD,QAAO"}

package/dist/live.react-server.d.ts

@@ -1,4 +1,3 @@
 import { t as isCorsOriginError } from "./isCorsOriginError.js";
-import { i as defineLive, n as DefinedSanityFetchType, r as DefinedSanityLiveProps, t as DefineSanityLiveOptions } from "./defineLive.js";
-import { n as resolvePerspectiveFromCookies } from "./resolvePerspectiveFromCookies.js";
-export { type DefineSanityLiveOptions, type DefinedSanityFetchType, type DefinedSanityLiveProps, defineLive, isCorsOriginError, resolvePerspectiveFromCookies };
+import { c as PerspectiveType, i as defineLive, u as resolvePerspectiveFromCookies } from "./defineLive.js";
+export { type PerspectiveType as LivePerspective, defineLive, isCorsOriginError, resolvePerspectiveFromCookies };

package/dist/live.react-server.js

@@ -61,7 +61,7 @@ function defineLive(config) {
 			};
 		},
 		SanityLive: async function SanityLive(props) {
-			const { refreshOnMount, refreshOnFocus, refreshOnReconnect, tag, requestTag = tag, onError, onGoAway, intervalOnGoAway, revalidateSyncTags } = props;
+			const { refreshOnMount, refreshOnFocus, refreshOnReconnect, requestTag, onError, onGoAway, intervalOnGoAway, revalidateSyncTags } = props;
 			const { projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix } = client.config();
 			const { isEnabled: isDraftModeEnabled } = await draftMode();
 			const { origin } = new URL(client.getUrl("", false));

package/dist/live.react-server.js.map

@@ -1 +1 @@
-{"version":3,"file":"live.react-server.js","names":["tag"],"sources":["../src/live/resolveCookiePerspective.ts","../src/live/defineLive.tsx"],"sourcesContent":["import type {ClientPerspective} from '@sanity/client'\n\nimport {sanitizePerspective} from '#live/sanitizePerspective'\nimport {perspectiveCookieName} from '@sanity/preview-url-secret/constants'\nimport {cookies, draftMode} from 'next/headers'\n\n/**\n * @internal\n */\nexport async function resolveCookiePerspective(): Promise<Exclude<ClientPerspective, 'raw'>> {\n  return (await draftMode()).isEnabled\n    ? (await cookies()).has(perspectiveCookieName)\n      ? sanitizePerspective((await cookies()).get(perspectiveCookieName)?.value, 'drafts')\n      : 'drafts'\n    : 'published'\n}\n","import {\n  type ClientPerspective,\n  type ClientReturn,\n  type ContentSourceMap,\n  type LiveEventGoAway,\n  type QueryParams,\n  type SanityClient,\n  type SyncTag,\n} from '@sanity/client'\nimport SanityLiveClientComponent from 'next-sanity/live/client-components/live'\nimport {draftMode} from 'next/headers'\nimport {prefetchDNS, preconnect} from 'react-dom'\n\nimport {resolveCookiePerspective} from './resolveCookiePerspective'\n\n/**\n * @public\n */\nexport type DefinedSanityFetchType = <const QueryString extends string>(options: {\n  query: QueryString\n  params?: QueryParams | Promise<QueryParams>\n  /**\n   * Add custom `next.tags` to the underlying fetch request.\n   * @see https://nextjs.org/docs/app/api-reference/functions/fetch#optionsnexttags\n   * This can be used in conjunction with custom fallback revalidation strategies, as well as with custom Server Actions that mutate data and want to render with fresh data right away (faster than the Live Event latency).\n   * @defaultValue `['sanity']`\n   */\n  tags?: string[]\n  perspective?: Exclude<ClientPerspective, 'raw'>\n  stega?: boolean\n  /**\n   * @deprecated use `requestTag` instead\n   */\n  tag?: never\n  /**\n   * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.\n   * @see https://www.sanity.io/docs/reference-api-request-tags\n   * @defaultValue 'next-loader.fetch'\n   */\n  requestTag?: string\n}) => Promise<{\n  data: ClientReturn<QueryString>\n  sourceMap: ContentSourceMap | null\n  tags: string[]\n}>\n\n/**\n * @public\n */\nexport interface DefinedSanityLiveProps {\n  /**\n   * Automatic refresh of RSC when the component <SanityLive /> is mounted.\n   * Note that this is different from revalidation, which is based on tags and causes `sanityFetch` calls to be re-fetched.\n   * @defaultValue `true`\n   */\n  refreshOnMount?: boolean\n  /**\n   * Automatically refresh when window gets focused\n   * Note that this is different from revalidation, which is based on tags and causes `sanityFetch` calls to be re-fetched.\n   * @defaultValue `false` if draftMode().isEnabled, otherwise `true` if not inside an iframe\n   */\n  refreshOnFocus?: boolean\n  /**\n   * Automatically refresh when the browser regains a network connection (via navigator.onLine)\n   * Note that this is different from revalidation, which is based on tags and causes `sanityFetch` calls to be re-fetched.\n   * @defaultValue `true`\n   */\n  refreshOnReconnect?: boolean\n  /**\n   * Automatically refresh on an interval when the Live Event API emits a `goaway` event, which indicates that the connection is rejected or closed.\n   * This typically happens if the connection limit is reached, or if the connection is idle for too long.\n   * To disable this long polling fallback behavior set `intervalOnGoAway` to `false` or `0`.\n   * You can also use `onGoAway` to handle the `goaway` event in your own way, and read the reason why the event was emitted.\n   * @defaultValue `30_000` 30 seconds interval\n   */\n  intervalOnGoAway?: number | false\n\n  /**\n   * @deprecated use `requestTag` instead\n   */\n  tag?: never\n\n  /**\n   * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.\n   * @see https://www.sanity.io/docs/reference-api-request-tags\n   * @defaultValue 'next-loader.live'\n   */\n  requestTag?: string\n\n  /**\n   * Handle errors from the Live Events subscription.\n   * By default it's reported using `console.error`, you can override this prop to handle it in your own way.\n   */\n  onError?: (error: unknown) => void\n\n  /**\n   * Handle the `goaway` event if the connection is rejected/closed.\n   * `event.reason` will be a string of why the event was emitted, for example `'connection limit reached'`.\n   * When this happens the `<SanityLive />` will fallback to long polling with a default interval of 30 seconds, providing your own `onGoAway` handler does not change this behavior.\n   * If you want to disable long polling set `intervalOnGoAway` to `false` or `0`.\n   */\n  onGoAway?: (event: LiveEventGoAway, intervalOnGoAway: number | false) => void\n\n  /**\n   * Override how cache tags are invalidated, you need to pass a server action here.\n   * You can also pass a `use client` function here, and have `router.refresh()` be called if the promise resolves to `'refresh'`.\n   */\n  revalidateSyncTags?: (tags: SyncTag[]) => Promise<void | 'refresh'>\n}\n\n/**\n * @public\n */\nexport interface DefineSanityLiveOptions {\n  /**\n   * Required for `sanityFetch` and `SanityLive` to work\n   */\n  client: SanityClient\n  /**\n   * Optional. If provided then the token needs to have permissions to query documents with `drafts.` prefixes in order for `perspective: 'drafts'` to work.\n   * This token is not shared with the browser.\n   */\n  serverToken?: string | false\n  /**\n   * Optional. This token is shared with the browser, and should only have access to query published documents.\n   * It is used to setup a `Live Draft Content` EventSource connection, and enables live previewing drafts stand-alone, outside of Presentation Tool.\n   */\n  browserToken?: string | false\n  /**\n   * Fetch options used by `sanityFetch`\n   */\n  fetchOptions?: {\n    /**\n     * Optional, enables time based revalidation in addition to the EventSource connection.\n     * @defaultValue `false`\n     */\n    revalidate?: number | false\n  }\n  /**\n   * Optional. Include stega encoding when draft mode is enabled.\n   *  @defaultValue `true`\n   */\n  stega?: boolean\n}\n\n// export type VerifyPreviewSecretType = (\n//   secret: string,\n// ) => Promise<{isValid: boolean; studioUrl: string | null}>\n\n/**\n * @public\n */\nexport function defineLive(config: DefineSanityLiveOptions): {\n  /**\n   * Use this function to fetch data from Sanity in your React Server Components.\n   * @public\n   */\n  sanityFetch: DefinedSanityFetchType\n  /**\n   * Render this in your root layout.tsx to make your page revalidate on new content live, automatically.\n   * @public\n   */\n  SanityLive: React.ComponentType<DefinedSanityLiveProps>\n} {\n  const {\n    client: _client,\n    serverToken,\n    browserToken,\n    fetchOptions,\n    stega: stegaEnabled = true,\n  } = config\n\n  if (!_client) {\n    throw new Error('`client` is required for `defineLive` to function')\n  }\n\n  if (process.env.NODE_ENV !== 'production' && !serverToken && serverToken !== false) {\n    console.warn(\n      'No `serverToken` provided to `defineLive`. This means that only published content will be fetched and respond to live events. You can silence this warning by setting `serverToken: false`.',\n    )\n  }\n\n  if (process.env.NODE_ENV !== 'production' && !browserToken && browserToken !== false) {\n    console.warn(\n      'No `browserToken` provided to `defineLive`. This means that live previewing drafts will only work when using the Presentation Tool in your Sanity Studio. To support live previewing drafts stand-alone, provide a `browserToken`. It is shared with the browser so it should only have Viewer rights or lower. You can silence this warning by setting `browserToken: false`.',\n    )\n  }\n\n  const client = _client.withConfig({allowReconfigure: false, useCdn: false})\n  const {token: originalToken} = client.config()\n  const studioUrlDefined = typeof client.config().stega.studioUrl !== 'undefined'\n\n  const sanityFetch: DefinedSanityFetchType = async function sanityFetch<\n    const QueryString extends string,\n  >({\n    query,\n    params = {},\n    stega: _stega,\n    tags = ['sanity'],\n    perspective: _perspective,\n    tag,\n    requestTag = tag ?? 'next-loader.fetch',\n  }: {\n    query: QueryString\n    params?: QueryParams | Promise<QueryParams>\n    stega?: boolean\n    tags?: string[]\n    perspective?: Exclude<ClientPerspective, 'raw'>\n    tag?: string\n    requestTag?: string\n  }) {\n    const stega = _stega ?? (stegaEnabled && studioUrlDefined && (await draftMode()).isEnabled)\n    const perspective = _perspective ?? (await resolveCookiePerspective())\n    const useCdn = perspective === 'published'\n    const revalidate =\n      fetchOptions?.revalidate !== undefined\n        ? fetchOptions.revalidate\n        : process.env.NODE_ENV === 'production'\n          ? false\n          : undefined\n\n    // fetch the tags first, with revalidate to 1s to ensure we get the latest tags, eventually\n    const {syncTags} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective: perspective as ClientPerspective,\n      stega: false,\n      returnQuery: false,\n      next: {revalidate, tags: [...tags, 'sanity:fetch-sync-tags']},\n      useCdn,\n      cacheMode: useCdn ? 'noStale' : undefined,\n      tag: [requestTag, 'fetch-sync-tags'].filter(Boolean).join('.'),\n    })\n\n    const cacheTags = [...tags, ...(syncTags?.map((tag) => `sanity:${tag}`) || [])]\n\n    const {result, resultSourceMap} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective: perspective as ClientPerspective,\n      stega,\n      token: perspective !== 'published' && serverToken ? serverToken : originalToken,\n      next: {revalidate, tags: cacheTags},\n      useCdn,\n      cacheMode: useCdn ? 'noStale' : undefined,\n      tag: requestTag,\n    })\n    return {data: result, sourceMap: resultSourceMap || null, tags: cacheTags}\n  }\n\n  const SanityLive: React.ComponentType<DefinedSanityLiveProps> = async function SanityLive(props) {\n    const {\n      // handleDraftModeAction = handleDraftModeActionMissing\n      refreshOnMount,\n      refreshOnFocus,\n      refreshOnReconnect,\n      tag,\n      requestTag = tag,\n      onError,\n      onGoAway,\n      intervalOnGoAway,\n      revalidateSyncTags,\n    } = props\n    const {projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix} =\n      client.config()\n    const {isEnabled: isDraftModeEnabled} = await draftMode()\n\n    // Preconnect to the Live Event API origin, or at least prefetch the DNS if preconenct is not supported\n    const {origin} = new URL(client.getUrl('', false))\n    preconnect(origin)\n    prefetchDNS(origin)\n\n    return (\n      <SanityLiveClientComponent\n        projectId={projectId}\n        dataset={dataset}\n        apiHost={apiHost}\n        apiVersion={apiVersion}\n        useProjectHostname={useProjectHostname}\n        requestTagPrefix={requestTagPrefix}\n        requestTag={requestTag}\n        token={typeof browserToken === 'string' && isDraftModeEnabled ? browserToken : undefined}\n        draftModeEnabled={isDraftModeEnabled}\n        // handleDraftModeAction={handleDraftModeAction}\n        draftModePerspective={await resolveCookiePerspective()}\n        refreshOnMount={refreshOnMount}\n        refreshOnFocus={refreshOnFocus}\n        refreshOnReconnect={refreshOnReconnect}\n        onError={onError}\n        onGoAway={onGoAway}\n        intervalOnGoAway={intervalOnGoAway}\n        revalidateSyncTags={revalidateSyncTags}\n      />\n    )\n  }\n\n  return {\n    sanityFetch,\n    SanityLive,\n  }\n}\n"],"mappings":";;;;;;;;;AASA,eAAsB,2BAAuE;AAC3F,SAAQ,MAAM,WAAW,EAAE,aACtB,MAAM,SAAS,EAAE,IAAI,sBAAsB,GAC1C,qBAAqB,MAAM,SAAS,EAAE,IAAI,sBAAsB,EAAE,OAAO,SAAS,GAClF,WACF;;AC0IN,SAAgB,WAAW,QAWzB;CACA,MAAM,EACJ,QAAQ,SACR,aACA,cACA,cACA,OAAO,eAAe,SACpB;AAEJ,KAAI,CAAC,QACH,OAAM,IAAI,MAAM,oDAAoD;AAGtE,KAAI,QAAQ,IAAI,aAAa,gBAAgB,CAAC,eAAe,gBAAgB,MAC3E,SAAQ,KACN,8LACD;AAGH,KAAI,QAAQ,IAAI,aAAa,gBAAgB,CAAC,gBAAgB,iBAAiB,MAC7E,SAAQ,KACN,iXACD;CAGH,MAAM,SAAS,QAAQ,WAAW;EAAC,kBAAkB;EAAO,QAAQ;EAAM,CAAC;CAC3E,MAAM,EAAC,OAAO,kBAAiB,OAAO,QAAQ;CAC9C,MAAM,mBAAmB,OAAO,OAAO,QAAQ,CAAC,MAAM,cAAc;AAwGpE,QAAO;EACL,aAvG0C,eAAe,YAEzD,EACA,OACA,SAAS,EAAE,EACX,OAAO,QACP,OAAO,CAAC,SAAS,EACjB,aAAa,cACb,KACA,aAAa,OAAO,uBASnB;GACD,MAAM,QAAQ,WAAW,gBAAgB,qBAAqB,MAAM,WAAW,EAAE;GACjF,MAAM,cAAc,gBAAiB,MAAM,0BAA0B;GACrE,MAAM,SAAS,gBAAgB;GAC/B,MAAM,aACJ,cAAc,eAAe,KAAA,IACzB,aAAa,aACb,QAAQ,IAAI,aAAa,eACvB,QACA,KAAA;GAGR,MAAM,EAAC,aAAY,MAAM,OAAO,MAAM,OAAO,MAAM,QAAQ;IACzD,gBAAgB;IACH;IACb,OAAO;IACP,aAAa;IACb,MAAM;KAAC;KAAY,MAAM,CAAC,GAAG,MAAM,yBAAyB;KAAC;IAC7D;IACA,WAAW,SAAS,YAAY,KAAA;IAChC,KAAK,CAAC,YAAY,kBAAkB,CAAC,OAAO,QAAQ,CAAC,KAAK,IAAI;IAC/D,CAAC;GAEF,MAAM,YAAY,CAAC,GAAG,MAAM,GAAI,UAAU,KAAK,UAAQ,UAAUA,QAAM,IAAI,EAAE,CAAE;GAE/E,MAAM,EAAC,QAAQ,oBAAmB,MAAM,OAAO,MAAM,OAAO,MAAM,QAAQ;IACxE,gBAAgB;IACH;IACb;IACA,OAAO,gBAAgB,eAAe,cAAc,cAAc;IAClE,MAAM;KAAC;KAAY,MAAM;KAAU;IACnC;IACA,WAAW,SAAS,YAAY,KAAA;IAChC,KAAK;IACN,CAAC;AACF,UAAO;IAAC,MAAM;IAAQ,WAAW,mBAAmB;IAAM,MAAM;IAAU;;EAmD1E,YAhD8D,eAAe,WAAW,OAAO;GAC/F,MAAM,EAEJ,gBACA,gBACA,oBACA,KACA,aAAa,KACb,SACA,UACA,kBACA,uBACE;GACJ,MAAM,EAAC,WAAW,SAAS,SAAS,YAAY,oBAAoB,qBAClE,OAAO,QAAQ;GACjB,MAAM,EAAC,WAAW,uBAAsB,MAAM,WAAW;GAGzD,MAAM,EAAC,WAAU,IAAI,IAAI,OAAO,OAAO,IAAI,MAAM,CAAC;AAClD,cAAW,OAAO;AAClB,eAAY,OAAO;AAEnB,UACE,oBAAC,2BAAA;IACY;IACF;IACA;IACG;IACQ;IACF;IACN;IACZ,OAAO,OAAO,iBAAiB,YAAY,qBAAqB,eAAe,KAAA;IAC/E,kBAAkB;IAElB,sBAAsB,MAAM,0BAA0B;IACtC;IACA;IACI;IACX;IACC;IACQ;IACE;KACpB;;EAOL"}
+{"version":3,"file":"live.react-server.js","names":["tag"],"sources":["../src/live/resolveCookiePerspective.ts","../src/live/defineLive.tsx"],"sourcesContent":["import type {ClientPerspective} from '@sanity/client'\n\nimport {sanitizePerspective} from '#live/sanitizePerspective'\nimport {perspectiveCookieName} from '@sanity/preview-url-secret/constants'\nimport {cookies, draftMode} from 'next/headers'\n\n/**\n * @internal\n */\nexport async function resolveCookiePerspective(): Promise<Exclude<ClientPerspective, 'raw'>> {\n  return (await draftMode()).isEnabled\n    ? (await cookies()).has(perspectiveCookieName)\n      ? sanitizePerspective((await cookies()).get(perspectiveCookieName)?.value, 'drafts')\n      : 'drafts'\n    : 'published'\n}\n","// import type {DefinedFetchType, DefinedLiveProps} from '#live/types'\n\nimport {\n  type ClientPerspective,\n  type ClientReturn,\n  type ContentSourceMap,\n  type LiveEventGoAway,\n  type QueryParams,\n  type SanityClient,\n  type SyncTag,\n} from '@sanity/client'\nimport SanityLiveClientComponent from 'next-sanity/live/client-components/live'\nimport {draftMode} from 'next/headers'\nimport {prefetchDNS, preconnect} from 'react-dom'\n\nimport {resolveCookiePerspective} from './resolveCookiePerspective'\n\n/**\n * @public\n */\nexport type DefinedSanityFetchType = <const QueryString extends string>(options: {\n  query: QueryString\n  params?: QueryParams | Promise<QueryParams>\n  /**\n   * Add custom `next.tags` to the underlying fetch request.\n   * @see https://nextjs.org/docs/app/api-reference/functions/fetch#optionsnexttags\n   * This can be used in conjunction with custom fallback revalidation strategies, as well as with custom Server Actions that mutate data and want to render with fresh data right away (faster than the Live Event latency).\n   * @defaultValue `['sanity']`\n   */\n  tags?: string[]\n  perspective?: Exclude<ClientPerspective, 'raw'>\n  stega?: boolean\n  /**\n   * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.\n   * @see https://www.sanity.io/docs/reference-api-request-tags\n   * @defaultValue 'next-loader.fetch'\n   */\n  requestTag?: string\n}) => Promise<{\n  data: ClientReturn<QueryString>\n  sourceMap: ContentSourceMap | null\n  tags: string[]\n}>\n\n/**\n * @public\n */\nexport interface DefinedSanityLiveProps {\n  /**\n   * Automatic refresh of RSC when the component <SanityLive /> is mounted.\n   * Note that this is different from revalidation, which is based on tags and causes `sanityFetch` calls to be re-fetched.\n   * @defaultValue `true`\n   */\n  refreshOnMount?: boolean\n  /**\n   * Automatically refresh when window gets focused\n   * Note that this is different from revalidation, which is based on tags and causes `sanityFetch` calls to be re-fetched.\n   * @defaultValue `false` if draftMode().isEnabled, otherwise `true` if not inside an iframe\n   */\n  refreshOnFocus?: boolean\n  /**\n   * Automatically refresh when the browser regains a network connection (via navigator.onLine)\n   * Note that this is different from revalidation, which is based on tags and causes `sanityFetch` calls to be re-fetched.\n   * @defaultValue `true`\n   */\n  refreshOnReconnect?: boolean\n  /**\n   * Automatically refresh on an interval when the Live Event API emits a `goaway` event, which indicates that the connection is rejected or closed.\n   * This typically happens if the connection limit is reached, or if the connection is idle for too long.\n   * To disable this long polling fallback behavior set `intervalOnGoAway` to `false` or `0`.\n   * You can also use `onGoAway` to handle the `goaway` event in your own way, and read the reason why the event was emitted.\n   * @defaultValue `30_000` 30 seconds interval\n   */\n  intervalOnGoAway?: number | false\n\n  /**\n   * This request tag is used to identify the request when viewing request logs from your Sanity Content Lake.\n   * @see https://www.sanity.io/docs/reference-api-request-tags\n   * @defaultValue 'next-loader.live'\n   */\n  requestTag?: string\n\n  /**\n   * Handle errors from the Live Events subscription.\n   * By default it's reported using `console.error`, you can override this prop to handle it in your own way.\n   */\n  onError?: (error: unknown) => void\n\n  /**\n   * Handle the `goaway` event if the connection is rejected/closed.\n   * `event.reason` will be a string of why the event was emitted, for example `'connection limit reached'`.\n   * When this happens the `<SanityLive />` will fallback to long polling with a default interval of 30 seconds, providing your own `onGoAway` handler does not change this behavior.\n   * If you want to disable long polling set `intervalOnGoAway` to `false` or `0`.\n   */\n  onGoAway?: (event: LiveEventGoAway, intervalOnGoAway: number | false) => void\n\n  /**\n   * Override how cache tags are invalidated, you need to pass a server action here.\n   * You can also pass a `use client` function here, and have `router.refresh()` be called if the promise resolves to `'refresh'`.\n   */\n  revalidateSyncTags?: (tags: SyncTag[]) => Promise<void | 'refresh'>\n}\n\n/**\n * @public\n */\nexport interface DefineSanityLiveOptions {\n  /**\n   * Required for `sanityFetch` and `SanityLive` to work\n   */\n  client: SanityClient\n  /**\n   * Optional. If provided then the token needs to have permissions to query documents with `drafts.` prefixes in order for `perspective: 'drafts'` to work.\n   * This token is not shared with the browser.\n   */\n  serverToken?: string | false\n  /**\n   * Optional. This token is shared with the browser, and should only have access to query published documents.\n   * It is used to setup a `Live Draft Content` EventSource connection, and enables live previewing drafts stand-alone, outside of Presentation Tool.\n   */\n  browserToken?: string | false\n  /**\n   * Fetch options used by `sanityFetch`\n   */\n  fetchOptions?: {\n    /**\n     * Optional, enables time based revalidation in addition to the EventSource connection.\n     * @defaultValue `false`\n     */\n    revalidate?: number | false\n  }\n  /**\n   * Optional. Include stega encoding when draft mode is enabled.\n   *  @defaultValue `true`\n   */\n  stega?: boolean\n}\n\nexport function defineLive(config: DefineSanityLiveOptions): {\n  /**\n   * @deprecated use `fetch` instead, and define your own `sanityFetch` function with logic for when to toggle `stega` and `perspective`\n   */\n  sanityFetch: DefinedSanityFetchType\n  /**\n   * @deprecated use `Live` instead, and define your own `SanityLive` component with logic for when to toggle `perspective`\n   */\n  SanityLive: React.ComponentType<DefinedSanityLiveProps>\n  // fetch: DefinedFetchType\n  // Live: React.ComponentType<DefinedLiveProps>\n} {\n  const {\n    client: _client,\n    serverToken,\n    browserToken,\n    fetchOptions,\n    stega: stegaEnabled = true,\n  } = config\n\n  if (!_client) {\n    throw new Error('`client` is required for `defineLive` to function')\n  }\n\n  if (process.env.NODE_ENV !== 'production' && !serverToken && serverToken !== false) {\n    console.warn(\n      'No `serverToken` provided to `defineLive`. This means that only published content will be fetched and respond to live events. You can silence this warning by setting `serverToken: false`.',\n    )\n  }\n\n  if (process.env.NODE_ENV !== 'production' && !browserToken && browserToken !== false) {\n    console.warn(\n      'No `browserToken` provided to `defineLive`. This means that live previewing drafts will only work when using the Presentation Tool in your Sanity Studio. To support live previewing drafts stand-alone, provide a `browserToken`. It is shared with the browser so it should only have Viewer rights or lower. You can silence this warning by setting `browserToken: false`.',\n    )\n  }\n\n  const client = _client.withConfig({allowReconfigure: false, useCdn: false})\n  const {token: originalToken} = client.config()\n  const studioUrlDefined = typeof client.config().stega.studioUrl !== 'undefined'\n\n  const sanityFetch: DefinedSanityFetchType = async function sanityFetch<\n    const QueryString extends string,\n  >({\n    query,\n    params = {},\n    stega: _stega,\n    tags = ['sanity'],\n    perspective: _perspective,\n    tag,\n    requestTag = tag ?? 'next-loader.fetch',\n  }: {\n    query: QueryString\n    params?: QueryParams | Promise<QueryParams>\n    stega?: boolean\n    tags?: string[]\n    perspective?: Exclude<ClientPerspective, 'raw'>\n    tag?: string\n    requestTag?: string\n  }) {\n    const stega = _stega ?? (stegaEnabled && studioUrlDefined && (await draftMode()).isEnabled)\n    const perspective = _perspective ?? (await resolveCookiePerspective())\n    const useCdn = perspective === 'published'\n    const revalidate =\n      fetchOptions?.revalidate !== undefined\n        ? fetchOptions.revalidate\n        : process.env.NODE_ENV === 'production'\n          ? false\n          : undefined\n\n    // fetch the tags first, with revalidate to 1s to ensure we get the latest tags, eventually\n    const {syncTags} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective: perspective as ClientPerspective,\n      stega: false,\n      returnQuery: false,\n      next: {revalidate, tags: [...tags, 'sanity:fetch-sync-tags']},\n      useCdn,\n      cacheMode: useCdn ? 'noStale' : undefined,\n      tag: [requestTag, 'fetch-sync-tags'].filter(Boolean).join('.'),\n    })\n\n    const cacheTags = [...tags, ...(syncTags?.map((tag) => `sanity:${tag}`) || [])]\n\n    const {result, resultSourceMap} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective: perspective as ClientPerspective,\n      stega,\n      token: perspective !== 'published' && serverToken ? serverToken : originalToken,\n      next: {revalidate, tags: cacheTags},\n      useCdn,\n      cacheMode: useCdn ? 'noStale' : undefined,\n      tag: requestTag,\n    })\n    return {data: result, sourceMap: resultSourceMap || null, tags: cacheTags}\n  }\n\n  const SanityLive: React.ComponentType<DefinedSanityLiveProps> = async function SanityLive(props) {\n    const {\n      // handleDraftModeAction = handleDraftModeActionMissing\n      refreshOnMount,\n      refreshOnFocus,\n      refreshOnReconnect,\n      requestTag,\n      onError,\n      onGoAway,\n      intervalOnGoAway,\n      revalidateSyncTags,\n    } = props\n    const {projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix} =\n      client.config()\n    const {isEnabled: isDraftModeEnabled} = await draftMode()\n\n    // Preconnect to the Live Event API origin, or at least prefetch the DNS if preconenct is not supported\n    const {origin} = new URL(client.getUrl('', false))\n    preconnect(origin)\n    prefetchDNS(origin)\n\n    return (\n      <SanityLiveClientComponent\n        projectId={projectId}\n        dataset={dataset}\n        apiHost={apiHost}\n        apiVersion={apiVersion}\n        useProjectHostname={useProjectHostname}\n        requestTagPrefix={requestTagPrefix}\n        requestTag={requestTag}\n        token={typeof browserToken === 'string' && isDraftModeEnabled ? browserToken : undefined}\n        draftModeEnabled={isDraftModeEnabled}\n        // handleDraftModeAction={handleDraftModeAction}\n        draftModePerspective={await resolveCookiePerspective()}\n        refreshOnMount={refreshOnMount}\n        refreshOnFocus={refreshOnFocus}\n        refreshOnReconnect={refreshOnReconnect}\n        onError={onError}\n        onGoAway={onGoAway}\n        intervalOnGoAway={intervalOnGoAway}\n        revalidateSyncTags={revalidateSyncTags}\n      />\n    )\n  }\n\n  return {\n    sanityFetch,\n    SanityLive,\n  }\n}\n"],"mappings":";;;;;;;;;AASA,eAAsB,2BAAuE;AAC3F,SAAQ,MAAM,WAAW,EAAE,aACtB,MAAM,SAAS,EAAE,IAAI,sBAAsB,GAC1C,qBAAqB,MAAM,SAAS,EAAE,IAAI,sBAAsB,EAAE,OAAO,SAAS,GAClF,WACF;;AC4HN,SAAgB,WAAW,QAWzB;CACA,MAAM,EACJ,QAAQ,SACR,aACA,cACA,cACA,OAAO,eAAe,SACpB;AAEJ,KAAI,CAAC,QACH,OAAM,IAAI,MAAM,oDAAoD;AAGtE,KAAI,QAAQ,IAAI,aAAa,gBAAgB,CAAC,eAAe,gBAAgB,MAC3E,SAAQ,KACN,8LACD;AAGH,KAAI,QAAQ,IAAI,aAAa,gBAAgB,CAAC,gBAAgB,iBAAiB,MAC7E,SAAQ,KACN,iXACD;CAGH,MAAM,SAAS,QAAQ,WAAW;EAAC,kBAAkB;EAAO,QAAQ;EAAM,CAAC;CAC3E,MAAM,EAAC,OAAO,kBAAiB,OAAO,QAAQ;CAC9C,MAAM,mBAAmB,OAAO,OAAO,QAAQ,CAAC,MAAM,cAAc;AAuGpE,QAAO;EACL,aAtG0C,eAAe,YAEzD,EACA,OACA,SAAS,EAAE,EACX,OAAO,QACP,OAAO,CAAC,SAAS,EACjB,aAAa,cACb,KACA,aAAa,OAAO,uBASnB;GACD,MAAM,QAAQ,WAAW,gBAAgB,qBAAqB,MAAM,WAAW,EAAE;GACjF,MAAM,cAAc,gBAAiB,MAAM,0BAA0B;GACrE,MAAM,SAAS,gBAAgB;GAC/B,MAAM,aACJ,cAAc,eAAe,KAAA,IACzB,aAAa,aACb,QAAQ,IAAI,aAAa,eACvB,QACA,KAAA;GAGR,MAAM,EAAC,aAAY,MAAM,OAAO,MAAM,OAAO,MAAM,QAAQ;IACzD,gBAAgB;IACH;IACb,OAAO;IACP,aAAa;IACb,MAAM;KAAC;KAAY,MAAM,CAAC,GAAG,MAAM,yBAAyB;KAAC;IAC7D;IACA,WAAW,SAAS,YAAY,KAAA;IAChC,KAAK,CAAC,YAAY,kBAAkB,CAAC,OAAO,QAAQ,CAAC,KAAK,IAAI;IAC/D,CAAC;GAEF,MAAM,YAAY,CAAC,GAAG,MAAM,GAAI,UAAU,KAAK,UAAQ,UAAUA,QAAM,IAAI,EAAE,CAAE;GAE/E,MAAM,EAAC,QAAQ,oBAAmB,MAAM,OAAO,MAAM,OAAO,MAAM,QAAQ;IACxE,gBAAgB;IACH;IACb;IACA,OAAO,gBAAgB,eAAe,cAAc,cAAc;IAClE,MAAM;KAAC;KAAY,MAAM;KAAU;IACnC;IACA,WAAW,SAAS,YAAY,KAAA;IAChC,KAAK;IACN,CAAC;AACF,UAAO;IAAC,MAAM;IAAQ,WAAW,mBAAmB;IAAM,MAAM;IAAU;;EAkD1E,YA/C8D,eAAe,WAAW,OAAO;GAC/F,MAAM,EAEJ,gBACA,gBACA,oBACA,YACA,SACA,UACA,kBACA,uBACE;GACJ,MAAM,EAAC,WAAW,SAAS,SAAS,YAAY,oBAAoB,qBAClE,OAAO,QAAQ;GACjB,MAAM,EAAC,WAAW,uBAAsB,MAAM,WAAW;GAGzD,MAAM,EAAC,WAAU,IAAI,IAAI,OAAO,OAAO,IAAI,MAAM,CAAC;AAClD,cAAW,OAAO;AAClB,eAAY,OAAO;AAEnB,UACE,oBAAC,2BAAA;IACY;IACF;IACA;IACG;IACQ;IACF;IACN;IACZ,OAAO,OAAO,iBAAiB,YAAY,qBAAqB,eAAe,KAAA;IAC/E,kBAAkB;IAElB,sBAAsB,MAAM,0BAA0B;IACtC;IACA;IACI;IACX;IACC;IACQ;IACE;KACpB;;EAOL"}

package/dist/visual-editing/server-actions/index.js

@@ -1,6 +1,6 @@
 "use server";
-import { revalidatePath } from "next/cache";
 import { draftMode } from "next/headers";
+import { revalidatePath } from "next/cache";
 async function revalidateRootLayout() {
 	if (!(await draftMode()).isEnabled) {
 		console.warn("Skipped revalidatePath request because draft mode is not enabled");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-sanity",
-  "version": "13.0.0-cache-components.5",
+  "version": "13.0.0-cache-components.7",
   "description": "Sanity.io toolkit for Next.js",
   "keywords": [
     "live",
@@ -15,23 +15,28 @@
   "bugs": {
     "url": "https://github.com/sanity-io/next-sanity/issues"
   },
+  "license": "MIT",
+  "author": "Sanity.io <hello@sanity.io>",
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com/sanity-io/next-sanity.git",
     "directory": "packages/next-sanity"
   },
-  "author": "Sanity.io <hello@sanity.io>",
-  "license": "MIT",
-  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "imports": {
     "#client-components/*": "./src/shared/client-components/*.tsx",
     "#live/*": "./src/shared/live/*.ts"
   },
   "exports": {
     ".": "./dist/index.js",
-    "./debug": "./dist/debug.js",
+    "./cache-life": "./dist/cache-life.js",
     "./draft-mode": "./dist/draft-mode/index.js",
     "./experimental/client-components/live": "./dist/experimental/client-components/live.js",
     "./hooks": "./dist/hooks/index.js",
@@ -51,11 +56,6 @@
     "./webhook": "./dist/webhook/index.js",
     "./package.json": "./package.json"
   },
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
   "dependencies": {
     "@portabletext/react": "^6.0.0",
     "@sanity/client": "^7.13.2",
@@ -75,7 +75,7 @@
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "@vitest/coverage-v8": "^4.0.16",
-    "next": "16.1.0-canary.34",
+    "next": "16.1.1-canary.0",
     "publint": "^0.3.16",
     "react": "^19.2.3",
     "react-dom": "^19.2.3",

package/dist/constants.d.ts

@@ -1,4 +0,0 @@
-declare const PUBLISHED_SYNC_TAG_PREFIX = "sp:";
-declare const DRAFT_SYNC_TAG_PREFIX = "sd:";
-export { PUBLISHED_SYNC_TAG_PREFIX as n, DRAFT_SYNC_TAG_PREFIX as t };
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../src/experimental/constants.ts"],"sourcesContent":[],"mappings":"AAAa,cAAA,yBAAA,GAAA,KAAA;AACA,cAAA,qBAAA,GAAA,KAAA"}

package/dist/debug.d.ts

@@ -1,7 +0,0 @@
-declare const tag = "sanity:debug";
-declare function debug(): Promise<{
-  data: number;
-  cacheTags: [typeof tag];
-}>;
-export { debug };
-//# sourceMappingURL=debug.d.ts.map

package/dist/debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.d.ts","names":[],"sources":["../src/debug.ts"],"sourcesContent":[],"mappings":"cAEM,GAAA,GAAA,cAAA;AAEgB,iBAAA,KAAA,CAAA,CAAS,EAAA,OAAA,CAAA;;qBAA0C"}

package/dist/debug.js

@@ -1,14 +0,0 @@
-import { cacheTag } from "next/cache";
-const tag = "sanity:debug";
-async function debug() {
-	const { resolve, promise } = Promise.withResolvers();
-	cacheTag(tag);
-	setTimeout(() => resolve(Math.random()), 1e3);
-	return {
-		data: await promise,
-		cacheTags: [tag]
-	};
-}
-export { debug };
-
-//# sourceMappingURL=debug.js.map

package/dist/debug.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.js","names":[],"sources":["../src/debug.ts"],"sourcesContent":["import {cacheTag} from 'next/cache'\n\nconst tag = 'sanity:debug'\n\nexport async function debug(): Promise<{data: number; cacheTags: [typeof tag]}> {\n  const {resolve, promise} = Promise.withResolvers<number>()\n  \n  cacheTag(tag)\n\n  setTimeout(() => resolve(Math.random()), 1_000)\n\n  return {\n    data: await promise,\n    cacheTags: [tag],\n  }\n}"],"mappings":";AAEA,MAAM,MAAM;AAEZ,eAAsB,QAA0D;CAC9E,MAAM,EAAC,SAAS,YAAW,QAAQ,eAAuB;AAE1D,UAAS,IAAI;AAEb,kBAAiB,QAAQ,KAAK,QAAQ,CAAC,EAAE,IAAM;AAE/C,QAAO;EACL,MAAM,MAAM;EACZ,WAAW,CAAC,IAAI;EACjB"}

package/dist/resolvePerspectiveFromCookies.d.ts

@@ -1,26 +0,0 @@
-import { cookies } from "next/headers";
-import { ClientPerspective } from "@sanity/client";
-type ResolvePerspectiveFromCookies = (options: {
-  /**
-  * You must await the cookies() function from next/headers
-  * and pass it here.
-  * Example:
-  * ```ts
-  * import { cookies } from 'next/headers'
-  *
-  * const perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})
-  * ```
-  */
-  cookies: Awaited<ReturnType<typeof cookies>>;
-}) => Promise<Exclude<ClientPerspective, "raw">>;
-/**
-* Resolves the perspective from the cookie that is set by `import { defineEnableDraftMode } from "next-sanity/draft-mode"`
-* @public
-*/
-declare const resolvePerspectiveFromCookies: ({
-  cookies: jar
-}: {
-  cookies: Awaited<ReturnType<typeof cookies>>;
-}) => Promise<Exclude<ClientPerspective, "raw">>;
-export { resolvePerspectiveFromCookies as n, ResolvePerspectiveFromCookies as t };
-//# sourceMappingURL=resolvePerspectiveFromCookies.d.ts.map

package/dist/resolvePerspectiveFromCookies.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolvePerspectiveFromCookies.d.ts","names":[],"sources":["../src/shared/live/resolvePerspectiveFromCookies.ts"],"sourcesContent":[],"mappings":";;KAMY,6BAAA;EAAZ;;;;;;;;AAkBA;;EAGqC,OAAA,EAV1B,OAU0B,CAVlB,UAUkB,CAAA,OAVA,OAUA,CAAA,CAAA;CAAlB,EAAA,GATb,OASa,CATL,OASK,CATG,iBASH,EAAA,KAAA,CAAA,CAAA;;;;;AACf,cAJS,6BAIT,EAAA,CAAA;EAAA,OAAA,EAHO;CAGP,EAAA;WADO,QAAQ,kBAAkB;MACjC,QAAQ,QAAQ"}