next-sanity 13.0.0-cache-components.48 → 13.0.0-cache-components.49

package/dist/NextStudio.js

@@ -1,6 +1,6 @@
 import { n as NextStudioLayout, t as NextStudioNoScript } from "./NextStudioNoScript.js";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { useMemo, useSyncExternalStore } from "react";
+import { useDeferredValue, useMemo, useSyncExternalStore } from "react";
 import { Studio } from "sanity";
 import { createHashHistory } from "history";
 /** @internal */
@@ -43,7 +43,7 @@ function createHashHistoryForStudio() {
 }
 /** @internal */
 function useIsMounted() {
-	return useSyncExternalStore(emptySubscribe, () => true, () => false);
+	return useDeferredValue(useSyncExternalStore(emptySubscribe, () => true, () => false), false);
 }
 const emptySubscribe = () => () => {};
 /**

package/dist/NextStudio.js.map

@@ -1 +1 @@
-{"version":3,"file":"NextStudio.js","names":[],"sources":["../src/studio/client-component/createHashHistoryForStudio.ts","../src/studio/client-component/useIsMounted.ts","../src/studio/client-component/NextStudio.tsx"],"sourcesContent":["// oxlint-disable unbound-method\nimport {createHashHistory, type History, type Listener} from 'history'\n\n/** @internal */\nexport function createHashHistoryForStudio(): History {\n  const history = createHashHistory()\n  return {\n    get action() {\n      return history.action\n    },\n    get location() {\n      return history.location\n    },\n    get createHref() {\n      return history.createHref\n    },\n    get push() {\n      return history.push\n    },\n    get replace() {\n      return history.replace\n    },\n    get go() {\n      return history.go\n    },\n    get back() {\n      return history.back\n    },\n    get forward() {\n      return history.forward\n    },\n    get block() {\n      return history.block\n    },\n    // Overriding listen to workaround a problem where native history provides history.listen(location => void), but the npm package is history.listen(({action, location}) => void)\n    listen(listener: Listener) {\n      // return history.listen(({ action, location }) => {\n      return history.listen(({location}) => {\n        // console.debug('history.listen', action, location)\n        // @ts-expect-error -- working around a bug? in studio\n        listener(location)\n      })\n    },\n  }\n}\n","import {useSyncExternalStore} from 'react'\n\n/** @internal */\nexport function useIsMounted(): boolean {\n  return useSyncExternalStore(\n    emptySubscribe,\n    () => true,\n    () => false,\n  )\n}\nconst emptySubscribe = () => () => {}\n","import {useMemo} from 'react'\nimport {Studio, type StudioProps} from 'sanity'\n\nimport {NextStudioLayout} from '../NextStudioLayout'\nimport {NextStudioNoScript} from '../NextStudioNoScript'\nimport {createHashHistoryForStudio} from './createHashHistoryForStudio'\nimport {useIsMounted} from './useIsMounted'\n\n/** @public */\nexport interface NextStudioProps extends StudioProps {\n  children?: React.ReactNode\n  /**\n   * Render the <noscript> tag\n   * @defaultValue true\n   * @alpha\n   */\n  unstable__noScript?: boolean\n  /**\n   * The 'hash' option is new feature that is not yet stable for production, but is available for testing and its API won't change in a breaking way.\n   * If 'hash' doesn't work for you, or if you want to use a memory based history, you can use the `unstable_history` prop instead.\n   * @alpha\n   * @defaultValue 'browser'\n   */\n  history?: 'browser' | 'hash'\n}\n/**\n * Override how the Studio renders by passing children.\n * This is useful for advanced use cases where you're using StudioProvider and StudioLayout instead of Studio:\n * ```\n * import {StudioProvider, StudioLayout} from 'sanity'\n * import {NextStudio} from 'next-sanity/studio'\n * <NextStudio config={config}>\n *   <StudioProvider config={config}>\n *     <CustomComponentThatUsesContextFromStudioProvider />\n *     <StudioLayout />\n *   </StudioProvider>\n * </NextStudio>\n * ```\n * @public\n */\nexport default function NextStudioComponent({\n  children,\n  config,\n  unstable__noScript = true,\n  scheme,\n  history,\n  ...props\n}: NextStudioProps): React.JSX.Element {\n  const isMounted = useIsMounted()\n  const unstableHistory = useMemo<typeof props.unstable_history>(() => {\n    if (props.unstable_history && history) {\n      throw new Error('Cannot use both `unstable_history` and `history` props at the same time')\n    }\n\n    if (isMounted && history === 'hash') {\n      return createHashHistoryForStudio()\n    }\n    return props.unstable_history\n  }, [history, isMounted, props.unstable_history])\n\n  return (\n    <>\n      {unstable__noScript && <NextStudioNoScript />}\n      <NextStudioLayout>\n        {history === 'hash' && !isMounted\n          ? null\n          : children || (\n              <Studio\n                config={config}\n                scheme={scheme}\n                unstable_globalStyles\n                {...props}\n                unstable_history={unstableHistory}\n              />\n            )}\n      </NextStudioLayout>\n    </>\n  )\n}\n"],"mappings":";;;;;;AAIA,SAAgB,6BAAsC;CACpD,MAAM,UAAU,mBAAmB;AACnC,QAAO;EACL,IAAI,SAAS;AACX,UAAO,QAAQ;;EAEjB,IAAI,WAAW;AACb,UAAO,QAAQ;;EAEjB,IAAI,aAAa;AACf,UAAO,QAAQ;;EAEjB,IAAI,OAAO;AACT,UAAO,QAAQ;;EAEjB,IAAI,UAAU;AACZ,UAAO,QAAQ;;EAEjB,IAAI,KAAK;AACP,UAAO,QAAQ;;EAEjB,IAAI,OAAO;AACT,UAAO,QAAQ;;EAEjB,IAAI,UAAU;AACZ,UAAO,QAAQ;;EAEjB,IAAI,QAAQ;AACV,UAAO,QAAQ;;EAGjB,OAAO,UAAoB;AAEzB,UAAO,QAAQ,QAAQ,EAAC,eAAc;AAGpC,aAAS,SAAS;KAClB;;EAEL;;;ACxCH,SAAgB,eAAwB;AACtC,QAAO,qBACL,sBACM,YACA,MACP;;AAEH,MAAM,6BAA6B;;;;;;;;;;;;;;;;AC8BnC,SAAwB,oBAAoB,EAC1C,UACA,QACA,qBAAqB,MACrB,QACA,SACA,GAAG,SACkC;CACrC,MAAM,YAAY,cAAc;CAChC,MAAM,kBAAkB,cAA6C;AACnE,MAAI,MAAM,oBAAoB,QAC5B,OAAM,IAAI,MAAM,0EAA0E;AAG5F,MAAI,aAAa,YAAY,OAC3B,QAAO,4BAA4B;AAErC,SAAO,MAAM;IACZ;EAAC;EAAS;EAAW,MAAM;EAAiB,CAAC;AAEhD,QACE,qBAAA,UAAA,EAAA,UAAA,CACG,sBAAsB,oBAAC,oBAAD,EAAsB,CAAA,EAC7C,oBAAC,kBAAD,EAAA,UACG,YAAY,UAAU,CAAC,YACpB,OACA,YACE,oBAAC,QAAD;EACU;EACA;EACR,uBAAA;EACA,GAAI;EACJ,kBAAkB;EAClB,CAAA,EAES,CAAA,CAClB,EAAA,CAAA"}
+{"version":3,"file":"NextStudio.js","names":[],"sources":["../src/studio/client-component/createHashHistoryForStudio.ts","../src/studio/client-component/useIsMounted.ts","../src/studio/client-component/NextStudio.tsx"],"sourcesContent":["// oxlint-disable unbound-method\nimport {createHashHistory, type History, type Listener} from 'history'\n\n/** @internal */\nexport function createHashHistoryForStudio(): History {\n  const history = createHashHistory()\n  return {\n    get action() {\n      return history.action\n    },\n    get location() {\n      return history.location\n    },\n    get createHref() {\n      return history.createHref\n    },\n    get push() {\n      return history.push\n    },\n    get replace() {\n      return history.replace\n    },\n    get go() {\n      return history.go\n    },\n    get back() {\n      return history.back\n    },\n    get forward() {\n      return history.forward\n    },\n    get block() {\n      return history.block\n    },\n    // Overriding listen to workaround a problem where native history provides history.listen(location => void), but the npm package is history.listen(({action, location}) => void)\n    listen(listener: Listener) {\n      // return history.listen(({ action, location }) => {\n      return history.listen(({location}) => {\n        // console.debug('history.listen', action, location)\n        // @ts-expect-error -- working around a bug? in studio\n        listener(location)\n      })\n    },\n  }\n}\n","import {useDeferredValue, useSyncExternalStore} from 'react'\n\n/** @internal */\nexport function useIsMounted(): boolean {\n  return useDeferredValue(\n    useSyncExternalStore(\n      emptySubscribe,\n      () => true,\n      () => false,\n    ),\n    false,\n  )\n}\nconst emptySubscribe = () => () => {}\n","import {useMemo} from 'react'\nimport {Studio, type StudioProps} from 'sanity'\n\nimport {NextStudioLayout} from '../NextStudioLayout'\nimport {NextStudioNoScript} from '../NextStudioNoScript'\nimport {createHashHistoryForStudio} from './createHashHistoryForStudio'\nimport {useIsMounted} from './useIsMounted'\n\n/** @public */\nexport interface NextStudioProps extends StudioProps {\n  children?: React.ReactNode\n  /**\n   * Render the <noscript> tag\n   * @defaultValue true\n   * @alpha\n   */\n  unstable__noScript?: boolean\n  /**\n   * The 'hash' option is new feature that is not yet stable for production, but is available for testing and its API won't change in a breaking way.\n   * If 'hash' doesn't work for you, or if you want to use a memory based history, you can use the `unstable_history` prop instead.\n   * @alpha\n   * @defaultValue 'browser'\n   */\n  history?: 'browser' | 'hash'\n}\n/**\n * Override how the Studio renders by passing children.\n * This is useful for advanced use cases where you're using StudioProvider and StudioLayout instead of Studio:\n * ```\n * import {StudioProvider, StudioLayout} from 'sanity'\n * import {NextStudio} from 'next-sanity/studio'\n * <NextStudio config={config}>\n *   <StudioProvider config={config}>\n *     <CustomComponentThatUsesContextFromStudioProvider />\n *     <StudioLayout />\n *   </StudioProvider>\n * </NextStudio>\n * ```\n * @public\n */\nexport default function NextStudioComponent({\n  children,\n  config,\n  unstable__noScript = true,\n  scheme,\n  history,\n  ...props\n}: NextStudioProps): React.JSX.Element {\n  const isMounted = useIsMounted()\n  const unstableHistory = useMemo<typeof props.unstable_history>(() => {\n    if (props.unstable_history && history) {\n      throw new Error('Cannot use both `unstable_history` and `history` props at the same time')\n    }\n\n    if (isMounted && history === 'hash') {\n      return createHashHistoryForStudio()\n    }\n    return props.unstable_history\n  }, [history, isMounted, props.unstable_history])\n\n  return (\n    <>\n      {unstable__noScript && <NextStudioNoScript />}\n      <NextStudioLayout>\n        {history === 'hash' && !isMounted\n          ? null\n          : children || (\n              <Studio\n                config={config}\n                scheme={scheme}\n                unstable_globalStyles\n                {...props}\n                unstable_history={unstableHistory}\n              />\n            )}\n      </NextStudioLayout>\n    </>\n  )\n}\n"],"mappings":";;;;;;AAIA,SAAgB,6BAAsC;CACpD,MAAM,UAAU,mBAAmB;AACnC,QAAO;EACL,IAAI,SAAS;AACX,UAAO,QAAQ;;EAEjB,IAAI,WAAW;AACb,UAAO,QAAQ;;EAEjB,IAAI,aAAa;AACf,UAAO,QAAQ;;EAEjB,IAAI,OAAO;AACT,UAAO,QAAQ;;EAEjB,IAAI,UAAU;AACZ,UAAO,QAAQ;;EAEjB,IAAI,KAAK;AACP,UAAO,QAAQ;;EAEjB,IAAI,OAAO;AACT,UAAO,QAAQ;;EAEjB,IAAI,UAAU;AACZ,UAAO,QAAQ;;EAEjB,IAAI,QAAQ;AACV,UAAO,QAAQ;;EAGjB,OAAO,UAAoB;AAEzB,UAAO,QAAQ,QAAQ,EAAC,eAAc;AAGpC,aAAS,SAAS;KAClB;;EAEL;;;ACxCH,SAAgB,eAAwB;AACtC,QAAO,iBACL,qBACE,sBACM,YACA,MACP,EACD,MACD;;AAEH,MAAM,6BAA6B;;;;;;;;;;;;;;;;AC2BnC,SAAwB,oBAAoB,EAC1C,UACA,QACA,qBAAqB,MACrB,QACA,SACA,GAAG,SACkC;CACrC,MAAM,YAAY,cAAc;CAChC,MAAM,kBAAkB,cAA6C;AACnE,MAAI,MAAM,oBAAoB,QAC5B,OAAM,IAAI,MAAM,0EAA0E;AAG5F,MAAI,aAAa,YAAY,OAC3B,QAAO,4BAA4B;AAErC,SAAO,MAAM;IACZ;EAAC;EAAS;EAAW,MAAM;EAAiB,CAAC;AAEhD,QACE,qBAAA,UAAA,EAAA,UAAA,CACG,sBAAsB,oBAAC,oBAAD,EAAsB,CAAA,EAC7C,oBAAC,kBAAD,EAAA,UACG,YAAY,UAAU,CAAC,YACpB,OACA,YACE,oBAAC,QAAD;EACU;EACA;EACR,uBAAA;EACA,GAAI;EACJ,kBAAkB;EAClB,CAAA,EAES,CAAA,CAClB,EAAA,CAAA"}

package/dist/live/conditions/default/index.d.ts

@@ -251,21 +251,52 @@ declare function defineLive(config: DefineLiveOptions & {
 * @example
 * ```tsx
 * import {cookies, draftMode} from 'next/headers'
+* import {defineQuery} from 'next-sanity'
 * import {resolvePerspectiveFromCookies, type LivePerspective} from 'next-sanity/live'
-* import {sanityFetch} from '#sanity/live'
+* import {sanityFetch, sanityFetchStaticParams} from '#sanity/live'
+*
+* export async function generateStaticParams() {
+*   const query = defineQuery(`*[_type == "page" && defined(slug.current)]{"slug": slug.current}`)
+*   return await sanityFetchStaticParams({query})
+* }
 *
-* function Page() {
+* export default async function Page({params}: PageProps<'/[slug]'>) {
 *   const {isEnabled: isDraftMode} = await draftMode()
-*   let perspective: LivePerspective = 'published'
-*   if(isDraftMode) {
-*     perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})
+*
+*   if (isDraftMode) {
+*     return (
+*       <Suspense>
+*         <DynamicPage params={params} />
+*       </Suspense>
+*     )
 *   }
-*   const {data} = await cachedFetch({query, perspective, stega: isDraftMode})
+*
+*   const {slug} = await params
+*
+*   return <CachedPage slug={slug} perspective="published" stega={false} />
 * }
-* function cachedFetch({query, params, perspective, stega}: {query: string, perspective: LivePerspective, stega: boolean}) {}) {
+*
+* async function DynamicPage({params}: Pick<PageProps<'/[slug]'>, 'params'>) {
+*   const {slug} = await params
+*   const perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})
+*
+*   return <CachedPage slug={slug} perspective={perspective} stega />
+* }
+*
+* async function CachedPage({
+*   slug,
+*   perspective,
+*   stega,
+* }: Awaited<PageProps<'/[slug]'>['params']> & {
+*   perspective: LivePerspective
+*   stega: boolean
+* }) {
 *   'use cache'
-*   const {data} = await sanityFetch({query, params, perspective, stega})
-*   return {data}
+*
+*   const query = defineQuery(`*[_type == "page" && slug.current == $slug][0]`)
+*   const {data} = await sanityFetch({query, params: {slug}, perspective, stega})
+*
+*   return <article>...</article>
 * }
 * ```
 *

package/dist/live/conditions/default/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/live/conditions/default/index.ts"],"mappings":";;;;;AA8JA;;;;;;;;;;;;;;;;;;;;AAqFA;;;;;;;;;;;;;;;;;;;;AAuDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA5IgB,UAAA,CAAW,MAAA,EAAQ,iBAAA;EAAqB,MAAA;AAAA;EACtD,WAAA,EAAa,sBAAA;EACb,UAAA,EAAY,KAAA,CAAM,aAAA,CAAc,sBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFlB,UAAA,CAAW,MAAA,EAAQ,iBAAA;EAAqB,MAAA;AAAA;EACtD,WAAA,EAAa,gBAAA;EACb,UAAA,EAAY,KAAA,CAAM,aAAA,CAAc,gBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqDrB,6BAAA,SAAsC,+BAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/live/conditions/default/index.ts"],"mappings":";;;;;AA8JA;;;;;;;;;;;;;;;;;;;;AAqFA;;;;;;;;;;;;;;;;;;;;AAsFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA3KgB,UAAA,CAAW,MAAA,EAAQ,iBAAA;EAAqB,MAAA;AAAA;EACtD,WAAA,EAAa,sBAAA;EACb,UAAA,EAAY,KAAA,CAAM,aAAA,CAAc,sBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFlB,UAAA,CAAW,MAAA,EAAQ,iBAAA;EAAqB,MAAA;AAAA;EACtD,WAAA,EAAa,gBAAA;EACb,UAAA,EAAY,KAAA,CAAM,aAAA,CAAc,gBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoFrB,6BAAA,SAAsC,+BAAA"}

package/dist/live/conditions/default/index.js

@@ -11,21 +11,52 @@ function defineLive(_config) {
 * @example
 * ```tsx
 * import {cookies, draftMode} from 'next/headers'
+* import {defineQuery} from 'next-sanity'
 * import {resolvePerspectiveFromCookies, type LivePerspective} from 'next-sanity/live'
-* import {sanityFetch} from '#sanity/live'
+* import {sanityFetch, sanityFetchStaticParams} from '#sanity/live'
 *
-* function Page() {
+* export async function generateStaticParams() {
+*   const query = defineQuery(`*[_type == "page" && defined(slug.current)]{"slug": slug.current}`)
+*   return await sanityFetchStaticParams({query})
+* }
+*
+* export default async function Page({params}: PageProps<'/[slug]'>) {
 *   const {isEnabled: isDraftMode} = await draftMode()
-*   let perspective: LivePerspective = 'published'
-*   if(isDraftMode) {
-*     perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})
+*
+*   if (isDraftMode) {
+*     return (
+*       <Suspense>
+*         <DynamicPage params={params} />
+*       </Suspense>
+*     )
 *   }
-*   const {data} = await cachedFetch({query, perspective, stega: isDraftMode})
+*
+*   const {slug} = await params
+*
+*   return <CachedPage slug={slug} perspective="published" stega={false} />
 * }
-* function cachedFetch({query, params, perspective, stega}: {query: string, perspective: LivePerspective, stega: boolean}) {}) {
+*
+* async function DynamicPage({params}: Pick<PageProps<'/[slug]'>, 'params'>) {
+*   const {slug} = await params
+*   const perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})
+*
+*   return <CachedPage slug={slug} perspective={perspective} stega />
+* }
+*
+* async function CachedPage({
+*   slug,
+*   perspective,
+*   stega,
+* }: Awaited<PageProps<'/[slug]'>['params']> & {
+*   perspective: LivePerspective
+*   stega: boolean
+* }) {
 *   'use cache'
-*   const {data} = await sanityFetch({query, params, perspective, stega})
-*   return {data}
+*
+*   const query = defineQuery(`*[_type == "page" && slug.current == $slug][0]`)
+*   const {data} = await sanityFetch({query, params: {slug}, perspective, stega})
+*
+*   return <article>...</article>
 * }
 * ```
 *

package/dist/live/conditions/default/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../../src/live/conditions/default/index.ts"],"sourcesContent":["import type {resolvePerspectiveFromCookies as _resolvePerspectiveFromCookies} from '#live/resolvePerspectiveFromCookies'\nimport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\n/**\n * Set up Sanity Live for Cache Components. `defineLive` returns `sanityFetch`\n * and `<SanityLive />`, which connect your Sanity client to the Live Content API\n * so cached pages can update in response to fine-grained content changes.\n *\n * With `strict: true`, `perspective` and `stega` become required\n * `sanityFetch` options, and `includeDrafts` becomes required on\n * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`\n * outside `'use cache'` boundaries, then pass them into cached components.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * // sanity/live.ts\n * import {cookies, draftMode} from 'next/headers'\n * import {createClient} from 'next-sanity'\n * import {\n *   defineLive,\n *   resolvePerspectiveFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n *   strict: true,\n * })\n *\n * export interface DynamicFetchOptions {\n *   perspective: LivePerspective\n *   stega: boolean\n * }\n *\n * // Resolve dynamic values outside 'use cache' boundaries.\n * export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (!isDraftMode) {\n *     return {perspective: 'published', stega: false}\n *   }\n *\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   return {perspective: perspective ?? 'drafts', stega: true}\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {draftMode} from 'next/headers'\n *\n * import {SanityLive} from '@/sanity/live'\n *\n * export default async function RootLayout({children}: {children: React.ReactNode}) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive includeDrafts={isDraftMode} />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {draftMode} from 'next/headers'\n * import {Suspense} from 'react'\n * import {defineQuery} from 'next-sanity'\n *\n * import {\n *   getDynamicFetchOptions,\n *   sanityFetch,\n *   type DynamicFetchOptions,\n * } from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (isDraftMode) {\n *     return (\n *       <Suspense fallback={<div>Loading...</div>}>\n *         <DynamicPage params={props.params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await props.params\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage(props: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await props.params\n *   const {perspective, stega} = await getDynamicFetchOptions()\n *\n *   return <CachedPage slug={slug} perspective={perspective} stega={stega} />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   stega,\n * }: {slug: string} & DynamicFetchOptions) {\n *   'use cache'\n *\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *     perspective,\n *     stega,\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict: true}): {\n  sanityFetch: StrictDefinedFetchType\n  SanityLive: React.ComponentType<StrictDefinedLiveProps>\n}\n/**\n * Set up Sanity Live. `defineLive` returns `sanityFetch` and `<SanityLive />`,\n * which connect your Sanity client to the Live Content API so pages can serve\n * cached content and update in response to fine-grained content changes.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * import {createClient} from 'next-sanity'\n * import {defineLive} from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n * })\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {SanityLive} from '@/sanity/live'\n *\n * export default function RootLayout({children}: {children: React.ReactNode}) {\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {defineQuery} from 'next-sanity'\n * import {sanityFetch} from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {slug} = await props.params\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict?: false}): {\n  sanityFetch: DefinedFetchType\n  SanityLive: React.ComponentType<DefinedLiveProps>\n}\nexport function defineLive(_config: DefineLiveOptions): never {\n  throw new Error(`defineLive can't be imported by a client component`)\n}\n\nexport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  LivePerspective,\n  SanityLiveAction,\n  SanityLiveActionContext,\n  SanityLiveOnError,\n  SanityLiveOnGoaway,\n  SanityLiveOnReconnect,\n  SanityLiveOnRestart,\n  SanityLiveOnWelcome,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\nexport {isCorsOriginError} from '#live/isCorsOriginError'\nexport {parseTags} from '#live/parseTags'\n\n/**\n * This helper is intended for use with Next.js Cache Components (`cacheComponents: true`),\n * where `cookies()` and `draftMode()` cannot be called inside `'use cache'` boundaries.\n * Resolve the perspective once outside the cache boundary and pass it in as a prop / cache key.\n *\n * @example\n * ```tsx\n * import {cookies, draftMode} from 'next/headers'\n * import {resolvePerspectiveFromCookies, type LivePerspective} from 'next-sanity/live'\n * import {sanityFetch} from '#sanity/live'\n *\n * function Page() {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   let perspective: LivePerspective = 'published'\n *   if(isDraftMode) {\n *     perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})\n *   }\n *   const {data} = await cachedFetch({query, perspective, stega: isDraftMode})\n * }\n * function cachedFetch({query, params, perspective, stega}: {query: string, perspective: LivePerspective, stega: boolean}) {}) {\n *   'use cache'\n *   const {data} = await sanityFetch({query, params, perspective, stega})\n *   return {data}\n * }\n * ```\n *\n * @public\n */\nexport const resolvePerspectiveFromCookies: typeof _resolvePerspectiveFromCookies = () => {\n  throw new Error(`resolvePerspectiveFromCookies can't be imported by a client component`)\n}\n"],"mappings":";;AAuPA,SAAgB,WAAW,SAAmC;AAC5D,OAAM,IAAI,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDvE,MAAa,sCAA6E;AACxF,OAAM,IAAI,MAAM,wEAAwE"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/live/conditions/default/index.ts"],"sourcesContent":["import type {resolvePerspectiveFromCookies as _resolvePerspectiveFromCookies} from '#live/resolvePerspectiveFromCookies'\nimport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\n/**\n * Set up Sanity Live for Cache Components. `defineLive` returns `sanityFetch`\n * and `<SanityLive />`, which connect your Sanity client to the Live Content API\n * so cached pages can update in response to fine-grained content changes.\n *\n * With `strict: true`, `perspective` and `stega` become required\n * `sanityFetch` options, and `includeDrafts` becomes required on\n * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`\n * outside `'use cache'` boundaries, then pass them into cached components.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * // sanity/live.ts\n * import {cookies, draftMode} from 'next/headers'\n * import {createClient} from 'next-sanity'\n * import {\n *   defineLive,\n *   resolvePerspectiveFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n *   strict: true,\n * })\n *\n * export interface DynamicFetchOptions {\n *   perspective: LivePerspective\n *   stega: boolean\n * }\n *\n * // Resolve dynamic values outside 'use cache' boundaries.\n * export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (!isDraftMode) {\n *     return {perspective: 'published', stega: false}\n *   }\n *\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   return {perspective: perspective ?? 'drafts', stega: true}\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {draftMode} from 'next/headers'\n *\n * import {SanityLive} from '@/sanity/live'\n *\n * export default async function RootLayout({children}: {children: React.ReactNode}) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive includeDrafts={isDraftMode} />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {draftMode} from 'next/headers'\n * import {Suspense} from 'react'\n * import {defineQuery} from 'next-sanity'\n *\n * import {\n *   getDynamicFetchOptions,\n *   sanityFetch,\n *   type DynamicFetchOptions,\n * } from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (isDraftMode) {\n *     return (\n *       <Suspense fallback={<div>Loading...</div>}>\n *         <DynamicPage params={props.params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await props.params\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage(props: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await props.params\n *   const {perspective, stega} = await getDynamicFetchOptions()\n *\n *   return <CachedPage slug={slug} perspective={perspective} stega={stega} />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   stega,\n * }: {slug: string} & DynamicFetchOptions) {\n *   'use cache'\n *\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *     perspective,\n *     stega,\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict: true}): {\n  sanityFetch: StrictDefinedFetchType\n  SanityLive: React.ComponentType<StrictDefinedLiveProps>\n}\n/**\n * Set up Sanity Live. `defineLive` returns `sanityFetch` and `<SanityLive />`,\n * which connect your Sanity client to the Live Content API so pages can serve\n * cached content and update in response to fine-grained content changes.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * import {createClient} from 'next-sanity'\n * import {defineLive} from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n * })\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {SanityLive} from '@/sanity/live'\n *\n * export default function RootLayout({children}: {children: React.ReactNode}) {\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {defineQuery} from 'next-sanity'\n * import {sanityFetch} from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {slug} = await props.params\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict?: false}): {\n  sanityFetch: DefinedFetchType\n  SanityLive: React.ComponentType<DefinedLiveProps>\n}\nexport function defineLive(_config: DefineLiveOptions): never {\n  throw new Error(`defineLive can't be imported by a client component`)\n}\n\nexport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  LivePerspective,\n  SanityLiveAction,\n  SanityLiveActionContext,\n  SanityLiveOnError,\n  SanityLiveOnGoaway,\n  SanityLiveOnReconnect,\n  SanityLiveOnRestart,\n  SanityLiveOnWelcome,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\nexport {isCorsOriginError} from '#live/isCorsOriginError'\nexport {parseTags} from '#live/parseTags'\n\n/**\n * This helper is intended for use with Next.js Cache Components (`cacheComponents: true`),\n * where `cookies()` and `draftMode()` cannot be called inside `'use cache'` boundaries.\n * Resolve the perspective once outside the cache boundary and pass it in as a prop / cache key.\n *\n * @example\n * ```tsx\n * import {cookies, draftMode} from 'next/headers'\n * import {defineQuery} from 'next-sanity'\n * import {resolvePerspectiveFromCookies, type LivePerspective} from 'next-sanity/live'\n * import {sanityFetch, sanityFetchStaticParams} from '#sanity/live'\n *\n * export async function generateStaticParams() {\n *   const query = defineQuery(`*[_type == \"page\" && defined(slug.current)]{\"slug\": slug.current}`)\n *   return await sanityFetchStaticParams({query})\n * }\n *\n * export default async function Page({params}: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   if (isDraftMode) {\n *     return (\n *       <Suspense>\n *         <DynamicPage params={params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await params\n *\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage({params}: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await params\n *   const perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})\n *\n *   return <CachedPage slug={slug} perspective={perspective} stega />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   stega,\n * }: Awaited<PageProps<'/[slug]'>['params']> & {\n *   perspective: LivePerspective\n *   stega: boolean\n * }) {\n *   'use cache'\n *\n *   const query = defineQuery(`*[_type == \"page\" && slug.current == $slug][0]`)\n *   const {data} = await sanityFetch({query, params: {slug}, perspective, stega})\n *\n *   return <article>...</article>\n * }\n * ```\n *\n * @public\n */\nexport const resolvePerspectiveFromCookies: typeof _resolvePerspectiveFromCookies = () => {\n  throw new Error(`resolvePerspectiveFromCookies can't be imported by a client component`)\n}\n"],"mappings":";;AAuPA,SAAgB,WAAW,SAAmC;AAC5D,OAAM,IAAI,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFvE,MAAa,sCAA6E;AACxF,OAAM,IAAI,MAAM,wEAAwE"}

package/dist/live/conditions/react-server/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/live/conditions/react-server/defineLive.tsx"],"mappings":";;;;;;AAwKA;;;;;;;;;;;;;;;;;;;;AAqFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBArFgB,UAAA,CAAW,MAAA,EAAQ,iBAAA;EAAqB,MAAA;AAAA;EACtD,WAAA,EAAa,sBAAA;EACb,UAAA,EAAY,KAAA,CAAM,aAAA,CAAc,sBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFlB,UAAA,CAAW,MAAA,EAAQ,iBAAA;EAAqB,MAAA;AAAA;EACtD,WAAA,EAAa,gBAAA;EACb,UAAA,EAAY,KAAA,CAAM,aAAA,CAAc,gBAAA;AAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../../src/live/conditions/react-server/defineLive.tsx"],"mappings":";;;;;;AAyKA;;;;;;;;;;;;;;;;;;;;AAqFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBArFgB,UAAA,CAAW,MAAA,EAAQ,iBAAA;EAAqB,MAAA;AAAA;EACtD,WAAA,EAAa,sBAAA;EACb,UAAA,EAAY,KAAA,CAAM,aAAA,CAAc,sBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmFlB,UAAA,CAAW,MAAA,EAAQ,iBAAA;EAAqB,MAAA;AAAA;EACtD,WAAA,EAAa,gBAAA;EACb,UAAA,EAAY,KAAA,CAAM,aAAA,CAAc,gBAAA;AAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["SanityLive","SanityLiveClientComponent"],"sources":["../../../../src/live/conditions/react-server/defineLive.tsx"],"sourcesContent":["import {type ClientPerspective} from '@sanity/client'\nimport {perspectiveCookieName} from '@sanity/preview-url-secret/constants'\nimport {SanityLive as SanityLiveClientComponent} from 'next-sanity/live/client-components'\nimport {refreshAction, revalidateSyncTagsAction} from 'next-sanity/live/server-actions'\nimport {PHASE_PRODUCTION_BUILD} from 'next/constants'\nimport {cookies, draftMode} from 'next/headers'\nimport {preconnect} from 'react-dom'\n\nimport {cacheTagPrefixes} from '#live/constants'\nimport {sanitizePerspective} from '#live/sanitizePerspective'\nimport {validateStrictFetchOptions, validateStrictSanityLiveProps} from '#live/strictValidation'\nimport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\n/**\n * Set up Sanity Live for Cache Components. `defineLive` returns `sanityFetch`\n * and `<SanityLive />`, which connect your Sanity client to the Live Content API\n * so cached pages can update in response to fine-grained content changes.\n *\n * With `strict: true`, `perspective` and `stega` become required\n * `sanityFetch` options, and `includeDrafts` becomes required on\n * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`\n * outside `'use cache'` boundaries, then pass them into cached components.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * // sanity/live.ts\n * import {cookies, draftMode} from 'next/headers'\n * import {createClient} from 'next-sanity'\n * import {\n *   defineLive,\n *   resolvePerspectiveFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n *   strict: true,\n * })\n *\n * export interface DynamicFetchOptions {\n *   perspective: LivePerspective\n *   stega: boolean\n * }\n *\n * // Resolve dynamic values outside 'use cache' boundaries.\n * export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (!isDraftMode) {\n *     return {perspective: 'published', stega: false}\n *   }\n *\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   return {perspective: perspective ?? 'drafts', stega: true}\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {draftMode} from 'next/headers'\n *\n * import {SanityLive} from '@/sanity/live'\n *\n * export default async function RootLayout({children}: {children: React.ReactNode}) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive includeDrafts={isDraftMode} />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {draftMode} from 'next/headers'\n * import {Suspense} from 'react'\n * import {defineQuery} from 'next-sanity'\n *\n * import {\n *   getDynamicFetchOptions,\n *   sanityFetch,\n *   type DynamicFetchOptions,\n * } from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (isDraftMode) {\n *     return (\n *       <Suspense fallback={<div>Loading...</div>}>\n *         <DynamicPage params={props.params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await props.params\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage(props: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await props.params\n *   const {perspective, stega} = await getDynamicFetchOptions()\n *\n *   return <CachedPage slug={slug} perspective={perspective} stega={stega} />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   stega,\n * }: {slug: string} & DynamicFetchOptions) {\n *   'use cache'\n *\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *     perspective,\n *     stega,\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict: true}): {\n  sanityFetch: StrictDefinedFetchType\n  SanityLive: React.ComponentType<StrictDefinedLiveProps>\n}\n/**\n * Set up Sanity Live. `defineLive` returns `sanityFetch` and `<SanityLive />`,\n * which connect your Sanity client to the Live Content API so pages can serve\n * cached content and update in response to fine-grained content changes.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * import {createClient} from 'next-sanity'\n * import {defineLive} from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n * })\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {SanityLive} from '@/sanity/live'\n *\n * export default function RootLayout({children}: {children: React.ReactNode}) {\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {defineQuery} from 'next-sanity'\n * import {sanityFetch} from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {slug} = await props.params\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict?: false}): {\n  sanityFetch: DefinedFetchType\n  SanityLive: React.ComponentType<DefinedLiveProps>\n}\nexport function defineLive(config: DefineLiveOptions) {\n  const {\n    client: _client,\n    serverToken,\n    browserToken,\n    stega: stegaEnabled = true,\n    strict = false,\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, perspective: originalPerspective = 'published'} = client.config()\n  const studioUrlDefined = typeof client.config().stega.studioUrl !== 'undefined'\n\n  const sanityFetch: DefinedFetchType = async function sanityFetch({\n    query,\n    params = {},\n    stega: _stega,\n    tags = [],\n    perspective: _perspective,\n    requestTag = 'next-loader.fetch',\n  }) {\n    if (strict) {\n      validateStrictFetchOptions({perspective: _perspective, stega: _stega})\n    }\n    const stega = strict\n      ? _stega!\n      : (_stega ?? (stegaEnabled && studioUrlDefined && (await draftMode()).isEnabled))\n    const perspective = strict\n      ? _perspective!\n      : (_perspective ??\n        (await resolveCookiePerspective(\n          originalPerspective === 'raw' ? 'published' : originalPerspective,\n        )))\n    const useCdn = perspective === 'published'\n    const isBuildPhase = process.env['NEXT_PHASE'] === PHASE_PRODUCTION_BUILD\n    const cacheMode = useCdn && !isBuildPhase ? 'noStale' : undefined\n    const cacheTagPrefix =\n      perspective === 'published' ? cacheTagPrefixes.published : cacheTagPrefixes.drafts\n\n    // 1. Fetch the tags first, with an uncached request, but that does not count towards the Sanity API quota\n    const {syncTags} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective: perspective as ClientPerspective,\n      stega: false,\n      returnQuery: false,\n      useCdn,\n      cacheMode,\n      tag: [requestTag, 'fetch-sync-tags'].filter(Boolean).join('.'),\n    })\n\n    const cacheTags = [...tags, ...(syncTags?.map((tag) => `${cacheTagPrefix}${tag}`) || [])]\n\n    // 2. Then fetch the data, using the fetch cache with specified tags\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: false, tags: cacheTags},\n      useCdn,\n      cacheMode,\n      tag: requestTag,\n    })\n    return {data: result, sourceMap: resultSourceMap || null, tags: cacheTags}\n  }\n\n  const SanityLive: React.ComponentType<DefinedLiveProps> = async function SanityLive(props) {\n    if (strict) {\n      validateStrictSanityLiveProps(props)\n    }\n    const {\n      includeDrafts = (await draftMode()).isEnabled,\n      waitFor,\n      requestTag = 'next-loader.live',\n\n      action,\n      onReconnect = refreshAction,\n      onRestart = refreshAction,\n      onWelcome = false,\n      onError = false,\n      onGoAway = false,\n\n      refreshOnMount,\n      refreshOnFocus,\n      refreshOnReconnect,\n    } = props\n    const {projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix} =\n      client.config()\n    const shouldIncludeDrafts = typeof browserToken === 'string' && includeDrafts\n    const shouldWaitFor = waitFor === 'function' && !shouldIncludeDrafts ? waitFor : undefined\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    const {origin} = new URL(client.getUrl('', false))\n    preconnect(origin)\n\n    return (\n      <SanityLiveClientComponent\n        config={{\n          projectId,\n          dataset,\n          apiHost,\n          apiVersion,\n          useProjectHostname,\n          requestTagPrefix,\n          token: shouldIncludeDrafts ? browserToken : undefined,\n        }}\n        includeDrafts={shouldIncludeDrafts}\n        waitFor={shouldWaitFor}\n        action={action ?? (shouldWaitFor === 'function' ? refreshAction : revalidateSyncTagsAction)}\n        onReconnect={onReconnect}\n        onRestart={onRestart}\n        onWelcome={onWelcome}\n        onError={onError}\n        onGoAway={onGoAway}\n        requestTag={requestTag}\n        refreshOnMount={refreshOnMount}\n        refreshOnFocus={refreshOnFocus}\n        refreshOnReconnect={refreshOnReconnect}\n      />\n    )\n  }\n  SanityLive.displayName = 'SanityLiveServerComponent'\n\n  return {sanityFetch, SanityLive}\n}\n\nasync function resolveCookiePerspective(\n  fallback: Exclude<ClientPerspective, 'raw'>,\n): 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    : fallback\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["SanityLive","SanityLiveClientComponent"],"sources":["../../../../src/live/conditions/react-server/defineLive.tsx"],"sourcesContent":["import {type ClientPerspective} from '@sanity/client'\nimport {perspectiveCookieName} from '@sanity/preview-url-secret/constants'\nimport {SanityLive as SanityLiveClientComponent} from 'next-sanity/live/client-components'\nimport {refreshAction, revalidateSyncTagsAction} from 'next-sanity/live/server-actions'\nimport {PHASE_PRODUCTION_BUILD} from 'next/constants'\nimport {cookies, draftMode} from 'next/headers'\nimport {preconnect} from 'react-dom'\n\nimport {cacheTagPrefixes} from '#live/constants'\nimport {sanitizePerspective} from '#live/sanitizePerspective'\nimport {validateStrictFetchOptions, validateStrictSanityLiveProps} from '#live/strictValidation'\nimport type {\n  DefinedFetchType,\n  DefinedLiveProps,\n  DefineLiveOptions,\n  LivePerspective,\n  StrictDefinedFetchType,\n  StrictDefinedLiveProps,\n} from '#live/types'\n\n/**\n * Set up Sanity Live for Cache Components. `defineLive` returns `sanityFetch`\n * and `<SanityLive />`, which connect your Sanity client to the Live Content API\n * so cached pages can update in response to fine-grained content changes.\n *\n * With `strict: true`, `perspective` and `stega` become required\n * `sanityFetch` options, and `includeDrafts` becomes required on\n * `<SanityLive />`. Resolve dynamic values from `draftMode()` and `cookies()`\n * outside `'use cache'` boundaries, then pass them into cached components.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * // sanity/live.ts\n * import {cookies, draftMode} from 'next/headers'\n * import {createClient} from 'next-sanity'\n * import {\n *   defineLive,\n *   resolvePerspectiveFromCookies,\n *   type LivePerspective,\n * } from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n *   strict: true,\n * })\n *\n * export interface DynamicFetchOptions {\n *   perspective: LivePerspective\n *   stega: boolean\n * }\n *\n * // Resolve dynamic values outside 'use cache' boundaries.\n * export async function getDynamicFetchOptions(): Promise<DynamicFetchOptions> {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (!isDraftMode) {\n *     return {perspective: 'published', stega: false}\n *   }\n *\n *   const jar = await cookies()\n *   const perspective = await resolvePerspectiveFromCookies({cookies: jar})\n *   return {perspective: perspective ?? 'drafts', stega: true}\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {draftMode} from 'next/headers'\n *\n * import {SanityLive} from '@/sanity/live'\n *\n * export default async function RootLayout({children}: {children: React.ReactNode}) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive includeDrafts={isDraftMode} />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {draftMode} from 'next/headers'\n * import {Suspense} from 'react'\n * import {defineQuery} from 'next-sanity'\n *\n * import {\n *   getDynamicFetchOptions,\n *   sanityFetch,\n *   type DynamicFetchOptions,\n * } from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   if (isDraftMode) {\n *     return (\n *       <Suspense fallback={<div>Loading...</div>}>\n *         <DynamicPage params={props.params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await props.params\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage(props: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await props.params\n *   const {perspective, stega} = await getDynamicFetchOptions()\n *\n *   return <CachedPage slug={slug} perspective={perspective} stega={stega} />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   stega,\n * }: {slug: string} & DynamicFetchOptions) {\n *   'use cache'\n *\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *     perspective,\n *     stega,\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict: true}): {\n  sanityFetch: StrictDefinedFetchType\n  SanityLive: React.ComponentType<StrictDefinedLiveProps>\n}\n/**\n * Set up Sanity Live. `defineLive` returns `sanityFetch` and `<SanityLive />`,\n * which connect your Sanity client to the Live Content API so pages can serve\n * cached content and update in response to fine-grained content changes.\n *\n * @see [Live Content API](https://www.sanity.io/docs/content-lake/live-content-api)\n * @see [Sanity Live](https://www.sanity.io/live)\n *\n * @example\n * ```tsx\n * import {createClient} from 'next-sanity'\n * import {defineLive} from 'next-sanity/live'\n *\n * const client = createClient({\n *   projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,\n *   dataset: process.env.NEXT_PUBLIC_SANITY_DATASET,\n *   useCdn: true,\n *   perspective: 'published',\n * })\n * const token = process.env.SANITY_API_READ_TOKEN\n *\n * export const {sanityFetch, SanityLive} = defineLive({\n *   client,\n *   browserToken: token,\n *   serverToken: token,\n * })\n * ```\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import {SanityLive} from '@/sanity/live'\n *\n * export default function RootLayout({children}: {children: React.ReactNode}) {\n *   return (\n *     <html lang=\"en\">\n *       <body>\n *         {children}\n *         <SanityLive />\n *       </body>\n *     </html>\n *   )\n * }\n * ```\n *\n * @example\n * ```tsx\n * // app/[slug]/page.tsx\n * import {defineQuery} from 'next-sanity'\n * import {sanityFetch} from '@/sanity/live'\n *\n * const POSTS_SLUGS_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current]{\"slug\": slug.current}\n * `)\n * const POST_QUERY = defineQuery(`\n *   *[_type == \"post\" && slug.current == $slug][0]\n * `)\n *\n * export async function generateStaticParams() {\n *   const {data} = await sanityFetch({\n *     query: POSTS_SLUGS_QUERY,\n *     perspective: 'published',\n *     stega: false,\n *   })\n *\n *   return data\n * }\n *\n * export default async function Page(props: PageProps<'/[slug]'>) {\n *   const {slug} = await props.params\n *   const {data} = await sanityFetch({\n *     query: POST_QUERY,\n *     params: {slug},\n *   })\n *\n *   return <pre>{JSON.stringify(data, null, 2)}</pre>\n * }\n * ```\n *\n * @public\n */\nexport function defineLive(config: DefineLiveOptions & {strict?: false}): {\n  sanityFetch: DefinedFetchType\n  SanityLive: React.ComponentType<DefinedLiveProps>\n}\nexport function defineLive(config: DefineLiveOptions) {\n  const {\n    client: _client,\n    serverToken,\n    browserToken,\n    stega: stegaEnabled = true,\n    strict = false,\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, perspective: originalPerspective = 'published'} = client.config()\n  const studioUrlDefined = typeof client.config().stega.studioUrl !== 'undefined'\n\n  const sanityFetch: DefinedFetchType = async function sanityFetch({\n    query,\n    params = {},\n    stega: _stega,\n    tags = [],\n    perspective: _perspective,\n    requestTag = 'next-loader.fetch',\n  }) {\n    if (strict) {\n      validateStrictFetchOptions({perspective: _perspective, stega: _stega})\n    }\n    const stega = strict\n      ? _stega!\n      : (_stega ?? (stegaEnabled && studioUrlDefined && (await draftMode()).isEnabled))\n    const perspective = strict\n      ? _perspective!\n      : (_perspective ??\n        (await resolveCookiePerspective(\n          originalPerspective === 'raw' ? 'published' : originalPerspective,\n        )))\n    const useCdn = perspective === 'published'\n    const isBuildPhase = process.env['NEXT_PHASE'] === PHASE_PRODUCTION_BUILD\n    const cacheMode = useCdn && !isBuildPhase ? 'noStale' : undefined\n    const cacheTagPrefix =\n      perspective === 'published' ? cacheTagPrefixes.published : cacheTagPrefixes.drafts\n\n    // 1. Fetch the tags first, with an uncached request, but that does not count towards the Sanity API quota\n    const {syncTags} = await client.fetch(query, await params, {\n      filterResponse: false,\n      perspective: perspective as ClientPerspective,\n      stega: false,\n      returnQuery: false,\n      useCdn,\n      cacheMode,\n      tag: [requestTag, 'fetch-sync-tags'].filter(Boolean).join('.'),\n    })\n\n    const cacheTags = [...tags, ...(syncTags?.map((tag) => `${cacheTagPrefix}${tag}`) || [])]\n\n    // 2. Then fetch the data, using the fetch cache with specified tags\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: false, tags: cacheTags},\n      useCdn,\n      cacheMode,\n      tag: requestTag,\n    })\n    return {data: result, sourceMap: resultSourceMap || null, tags: cacheTags}\n  }\n\n  const SanityLive: React.ComponentType<DefinedLiveProps> = async function SanityLive(props) {\n    if (strict) {\n      validateStrictSanityLiveProps(props)\n    }\n    const {\n      includeDrafts = (await draftMode()).isEnabled,\n      waitFor,\n      requestTag = 'next-loader.live',\n\n      action,\n      onReconnect = refreshAction,\n      onRestart = refreshAction,\n      onWelcome = false,\n      onError = false,\n      onGoAway = false,\n\n      refreshOnMount,\n      refreshOnFocus,\n      refreshOnReconnect,\n    } = props\n    const {projectId, dataset, apiHost, apiVersion, useProjectHostname, requestTagPrefix} =\n      client.config()\n    const shouldIncludeDrafts = typeof browserToken === 'string' && includeDrafts\n    const shouldWaitFor = waitFor === 'function' && !shouldIncludeDrafts ? waitFor : undefined\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    const {origin} = new URL(client.getUrl('', false))\n    preconnect(origin)\n\n    return (\n      <SanityLiveClientComponent\n        config={{\n          projectId,\n          dataset,\n          apiHost,\n          apiVersion,\n          useProjectHostname,\n          requestTagPrefix,\n          token: shouldIncludeDrafts ? browserToken : undefined,\n        }}\n        includeDrafts={shouldIncludeDrafts}\n        waitFor={shouldWaitFor}\n        action={action ?? (shouldWaitFor === 'function' ? refreshAction : revalidateSyncTagsAction)}\n        onReconnect={onReconnect}\n        onRestart={onRestart}\n        onWelcome={onWelcome}\n        onError={onError}\n        onGoAway={onGoAway}\n        requestTag={requestTag}\n        refreshOnMount={refreshOnMount}\n        refreshOnFocus={refreshOnFocus}\n        refreshOnReconnect={refreshOnReconnect}\n      />\n    )\n  }\n  SanityLive.displayName = 'SanityLiveServerComponent'\n\n  return {sanityFetch, SanityLive}\n}\n\nasync function resolveCookiePerspective(fallback: LivePerspective): Promise<LivePerspective> {\n  return (await draftMode()).isEnabled\n    ? (await cookies()).has(perspectiveCookieName)\n      ? sanitizePerspective((await cookies()).get(perspectiveCookieName)?.value, 'drafts')\n      : 'drafts'\n    : fallback\n}\n"],"mappings":"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"}

package/dist/parseTags.d.ts

@@ -1,5 +1,6 @@
+import { i as LivePerspective } from "./types.js";
 import { cookies } from "next/headers";
-import { ClientPerspective, SyncTag } from "@sanity/client";
+import { SyncTag } from "@sanity/client";
 /**
 * This helper is intended for use with Next.js Cache Components (`cacheComponents: true`),
 * where `cookies()` and `draftMode()` cannot be called inside `'use cache'` boundaries.
@@ -8,21 +9,52 @@ import { ClientPerspective, SyncTag } from "@sanity/client";
 * @example
 * ```tsx
 * import {cookies, draftMode} from 'next/headers'
+* import {defineQuery} from 'next-sanity'
 * import {resolvePerspectiveFromCookies, type LivePerspective} from 'next-sanity/live'
-* import {sanityFetch} from '#sanity/live'
+* import {sanityFetch, sanityFetchStaticParams} from '#sanity/live'
 *
-* function Page() {
+* export async function generateStaticParams() {
+*   const query = defineQuery(`*[_type == "page" && defined(slug.current)]{"slug": slug.current}`)
+*   return await sanityFetchStaticParams({query})
+* }
+*
+* export default async function Page({params}: PageProps<'/[slug]'>) {
 *   const {isEnabled: isDraftMode} = await draftMode()
-*   let perspective: LivePerspective = 'published'
-*   if(isDraftMode) {
-*     perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})
+*
+*   if (isDraftMode) {
+*     return (
+*       <Suspense>
+*         <DynamicPage params={params} />
+*       </Suspense>
+*     )
 *   }
-*   const {data} = await cachedFetch({query, perspective, stega: isDraftMode})
+*
+*   const {slug} = await params
+*
+*   return <CachedPage slug={slug} perspective="published" stega={false} />
 * }
-* function cachedFetch({query, params, perspective, stega}: {query: string, perspective: LivePerspective, stega: boolean}) {}) {
+*
+* async function DynamicPage({params}: Pick<PageProps<'/[slug]'>, 'params'>) {
+*   const {slug} = await params
+*   const perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})
+*
+*   return <CachedPage slug={slug} perspective={perspective} stega />
+* }
+*
+* async function CachedPage({
+*   slug,
+*   perspective,
+*   stega,
+* }: Awaited<PageProps<'/[slug]'>['params']> & {
+*   perspective: LivePerspective
+*   stega: boolean
+* }) {
 *   'use cache'
-*   const {data} = await sanityFetch({query, params, perspective, stega})
-*   return {data}
+*
+*   const query = defineQuery(`*[_type == "page" && slug.current == $slug][0]`)
+*   const {data} = await sanityFetch({query, params: {slug}, perspective, stega})
+*
+*   return <article>...</article>
 * }
 * ```
 *
@@ -32,7 +64,7 @@ declare function resolvePerspectiveFromCookies({
   cookies: jar
 }: {
   cookies: Awaited<ReturnType<typeof cookies>>;
-}): Promise<Exclude<ClientPerspective, "raw">>;
+}): Promise<LivePerspective>;
 declare const cacheTagPrefixes: {
   published: string;
   drafts: string;

package/dist/parseTags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseTags.d.ts","names":[],"sources":["../src/live/shared/resolvePerspectiveFromCookies.ts","../src/live/shared/constants.ts","../src/live/shared/parseTags.ts"],"mappings":";;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;AC3BA;;;iBD2BsB,6BAAA,CAAA;EACpB,OAAA,EAAS;AAAA;EAET,OAAA,EAAS,OAAA,CAAQ,UAAA,QAAkB,OAAA;AAAA,IACjC,OAAA,CAAQ,OAAA,CAAQ,iBAAA;AAAA,cC/BP,gBAAA;EACX,SAAA;EACA,MAAA;AAAA;AAAA,UCLQ,mBAAA;EACR,IAAA,YAAgB,gBAAA,CAAiB,SAAA,GAAY,OAAA;EAC7C,MAAA,SAAe,gBAAA,CAAiB,SAAA;EAChC,UAAA;AAAA;AAAA,UAEQ,eAAA;EACR,IAAA,YAAgB,gBAAA,CAAiB,MAAA,GAAS,OAAA;EAC1C,MAAA,SAAe,gBAAA,CAAiB,MAAA;EAChC,UAAA;AAAA;AAAA,KAEG,UAAA,GAAa,mBAAA,GAAsB,eAAA;;;;;;;;;;;;;;;ADPxC;;;;;;ACL+B;iBAmCf,SAAA,CAAU,UAAA,YAAsB,UAAA"}
+{"version":3,"file":"parseTags.d.ts","names":[],"sources":["../src/live/shared/resolvePerspectiveFromCookies.ts","../src/live/shared/constants.ts","../src/live/shared/parseTags.ts"],"mappings":";;;;;AAiEA;;;;;;;;;;;;;;;;;;;;;;AC1DA;;;;;;ACL+B;;;;;;;;;;;;;;;;;;AAK7B;;;;;;;;;;;iBF0DoB,6BAAA,CAAA;EACpB,OAAA,EAAS;AAAA;EAET,OAAA,EAAS,OAAA,CAAQ,UAAA,QAAkB,OAAA;AAAA,IACjC,OAAA,CAAQ,eAAA;AAAA,cC9DC,gBAAA;EACX,SAAA;EACA,MAAA;AAAA;AAAA,UCLQ,mBAAA;EACR,IAAA,YAAgB,gBAAA,CAAiB,SAAA,GAAY,OAAA;EAC7C,MAAA,SAAe,gBAAA,CAAiB,SAAA;EAChC,UAAA;AAAA;AAAA,UAEQ,eAAA;EACR,IAAA,YAAgB,gBAAA,CAAiB,MAAA,GAAS,OAAA;EAC1C,MAAA,SAAe,gBAAA,CAAiB,MAAA;EAChC,UAAA;AAAA;AAAA,KAEG,UAAA,GAAa,mBAAA,GAAsB,eAAA;;;;;;;;;;;;;;ADPxC;;;;;;ACL+B;;iBAmCf,SAAA,CAAU,UAAA,YAAsB,UAAA"}

package/dist/resolvePerspectiveFromCookies.js

@@ -16,21 +16,52 @@ function validateStrictFetchOptions(options) {
 * @example
 * ```tsx
 * import {cookies, draftMode} from 'next/headers'
+* import {defineQuery} from 'next-sanity'
 * import {resolvePerspectiveFromCookies, type LivePerspective} from 'next-sanity/live'
-* import {sanityFetch} from '#sanity/live'
+* import {sanityFetch, sanityFetchStaticParams} from '#sanity/live'
 *
-* function Page() {
+* export async function generateStaticParams() {
+*   const query = defineQuery(`*[_type == "page" && defined(slug.current)]{"slug": slug.current}`)
+*   return await sanityFetchStaticParams({query})
+* }
+*
+* export default async function Page({params}: PageProps<'/[slug]'>) {
 *   const {isEnabled: isDraftMode} = await draftMode()
-*   let perspective: LivePerspective = 'published'
-*   if(isDraftMode) {
-*     perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})
+*
+*   if (isDraftMode) {
+*     return (
+*       <Suspense>
+*         <DynamicPage params={params} />
+*       </Suspense>
+*     )
 *   }
-*   const {data} = await cachedFetch({query, perspective, stega: isDraftMode})
+*
+*   const {slug} = await params
+*
+*   return <CachedPage slug={slug} perspective="published" stega={false} />
 * }
-* function cachedFetch({query, params, perspective, stega}: {query: string, perspective: LivePerspective, stega: boolean}) {}) {
+*
+* async function DynamicPage({params}: Pick<PageProps<'/[slug]'>, 'params'>) {
+*   const {slug} = await params
+*   const perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})
+*
+*   return <CachedPage slug={slug} perspective={perspective} stega />
+* }
+*
+* async function CachedPage({
+*   slug,
+*   perspective,
+*   stega,
+* }: Awaited<PageProps<'/[slug]'>['params']> & {
+*   perspective: LivePerspective
+*   stega: boolean
+* }) {
 *   'use cache'
-*   const {data} = await sanityFetch({query, params, perspective, stega})
-*   return {data}
+*
+*   const query = defineQuery(`*[_type == "page" && slug.current == $slug][0]`)
+*   const {data} = await sanityFetch({query, params: {slug}, perspective, stega})
+*
+*   return <article>...</article>
 * }
 * ```
 *

package/dist/resolvePerspectiveFromCookies.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolvePerspectiveFromCookies.js","names":[],"sources":["../src/live/shared/strictValidation.ts","../src/live/shared/resolvePerspectiveFromCookies.ts"],"sourcesContent":["import {generateHelpUrl} from '@sanity/generate-help-url'\n\nexport function validateStrictSanityLiveProps(props: {includeDrafts?: unknown}): void {\n  if (typeof props.includeDrafts !== 'boolean') {\n    throw new Error(\n      `<SanityLive> requires an explicit \\`includeDrafts\\` prop (true or false) when \\`strict: true\\` is set on \\`defineLive\\`.\\n\\nMore information: ${generateHelpUrl('next-sanity-live-strict')}`,\n      {cause: props},\n    )\n  }\n}\n\nexport function validateStrictFetchOptions(options: {\n  perspective?: unknown\n  stega?: unknown\n}): void {\n  if (typeof options.perspective === 'undefined' || options.perspective === null) {\n    throw new Error(\n      `sanityFetch() requires an explicit \\`perspective\\` option when \\`strict: true\\` is set on \\`defineLive\\`.\\n\\nMore information: ${generateHelpUrl('next-sanity-fetch-strict')}`,\n      {cause: options},\n    )\n  }\n  if (typeof options.stega !== 'boolean') {\n    throw new Error(\n      `sanityFetch() requires an explicit \\`stega\\` option (true or false) when \\`strict: true\\` is set on \\`defineLive\\`.\\n\\nMore information: ${generateHelpUrl('next-sanity-fetch-strict')}`,\n      {cause: options},\n    )\n  }\n}\n","import type {ClientPerspective} from '@sanity/client'\nimport {perspectiveCookieName} from '@sanity/preview-url-secret/constants'\nimport type {cookies} from 'next/headers'\n\nimport {sanitizePerspective} from '#live/sanitizePerspective'\n\n/**\n * This helper is intended for use with Next.js Cache Components (`cacheComponents: true`),\n * where `cookies()` and `draftMode()` cannot be called inside `'use cache'` boundaries.\n * Resolve the perspective once outside the cache boundary and pass it in as a prop / cache key.\n *\n * @example\n * ```tsx\n * import {cookies, draftMode} from 'next/headers'\n * import {resolvePerspectiveFromCookies, type LivePerspective} from 'next-sanity/live'\n * import {sanityFetch} from '#sanity/live'\n *\n * function Page() {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *   let perspective: LivePerspective = 'published'\n *   if(isDraftMode) {\n *     perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})\n *   }\n *   const {data} = await cachedFetch({query, perspective, stega: isDraftMode})\n * }\n * function cachedFetch({query, params, perspective, stega}: {query: string, perspective: LivePerspective, stega: boolean}) {}) {\n *   'use cache'\n *   const {data} = await sanityFetch({query, params, perspective, stega})\n *   return {data}\n * }\n * ```\n *\n * @public\n */\nexport async function resolvePerspectiveFromCookies({\n  cookies: jar,\n}: {\n  cookies: Awaited<ReturnType<typeof cookies>>\n}): Promise<Exclude<ClientPerspective, 'raw'>> {\n  return jar.has(perspectiveCookieName)\n    ? sanitizePerspective(jar.get(perspectiveCookieName)?.value, 'drafts')\n    : 'drafts'\n}\n"],"mappings":";;;AAEA,SAAgB,8BAA8B,OAAwC;AACpF,KAAI,OAAO,MAAM,kBAAkB,UACjC,OAAM,IAAI,MACR,iJAAiJ,gBAAgB,0BAA0B,IAC3L,EAAC,OAAO,OAAM,CACf;;AAIL,SAAgB,2BAA2B,SAGlC;AACP,KAAI,OAAO,QAAQ,gBAAgB,eAAe,QAAQ,gBAAgB,KACxE,OAAM,IAAI,MACR,kIAAkI,gBAAgB,2BAA2B,IAC7K,EAAC,OAAO,SAAQ,CACjB;AAEH,KAAI,OAAO,QAAQ,UAAU,UAC3B,OAAM,IAAI,MACR,4IAA4I,gBAAgB,2BAA2B,IACvL,EAAC,OAAO,SAAQ,CACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACSL,eAAsB,8BAA8B,EAClD,SAAS,OAGoC;AAC7C,QAAO,IAAI,IAAI,sBAAsB,GACjC,oBAAoB,IAAI,IAAI,sBAAsB,EAAE,OAAO,SAAS,GACpE"}
+{"version":3,"file":"resolvePerspectiveFromCookies.js","names":[],"sources":["../src/live/shared/strictValidation.ts","../src/live/shared/resolvePerspectiveFromCookies.ts"],"sourcesContent":["import {generateHelpUrl} from '@sanity/generate-help-url'\n\nexport function validateStrictSanityLiveProps(props: {includeDrafts?: unknown}): void {\n  if (typeof props.includeDrafts !== 'boolean') {\n    throw new Error(\n      `<SanityLive> requires an explicit \\`includeDrafts\\` prop (true or false) when \\`strict: true\\` is set on \\`defineLive\\`.\\n\\nMore information: ${generateHelpUrl('next-sanity-live-strict')}`,\n      {cause: props},\n    )\n  }\n}\n\nexport function validateStrictFetchOptions(options: {\n  perspective?: unknown\n  stega?: unknown\n}): void {\n  if (typeof options.perspective === 'undefined' || options.perspective === null) {\n    throw new Error(\n      `sanityFetch() requires an explicit \\`perspective\\` option when \\`strict: true\\` is set on \\`defineLive\\`.\\n\\nMore information: ${generateHelpUrl('next-sanity-fetch-strict')}`,\n      {cause: options},\n    )\n  }\n  if (typeof options.stega !== 'boolean') {\n    throw new Error(\n      `sanityFetch() requires an explicit \\`stega\\` option (true or false) when \\`strict: true\\` is set on \\`defineLive\\`.\\n\\nMore information: ${generateHelpUrl('next-sanity-fetch-strict')}`,\n      {cause: options},\n    )\n  }\n}\n","import {perspectiveCookieName} from '@sanity/preview-url-secret/constants'\nimport type {cookies} from 'next/headers'\n\nimport {sanitizePerspective} from '#live/sanitizePerspective'\nimport type {LivePerspective} from '#live/types'\n\n/**\n * This helper is intended for use with Next.js Cache Components (`cacheComponents: true`),\n * where `cookies()` and `draftMode()` cannot be called inside `'use cache'` boundaries.\n * Resolve the perspective once outside the cache boundary and pass it in as a prop / cache key.\n *\n * @example\n * ```tsx\n * import {cookies, draftMode} from 'next/headers'\n * import {defineQuery} from 'next-sanity'\n * import {resolvePerspectiveFromCookies, type LivePerspective} from 'next-sanity/live'\n * import {sanityFetch, sanityFetchStaticParams} from '#sanity/live'\n *\n * export async function generateStaticParams() {\n *   const query = defineQuery(`*[_type == \"page\" && defined(slug.current)]{\"slug\": slug.current}`)\n *   return await sanityFetchStaticParams({query})\n * }\n *\n * export default async function Page({params}: PageProps<'/[slug]'>) {\n *   const {isEnabled: isDraftMode} = await draftMode()\n *\n *   if (isDraftMode) {\n *     return (\n *       <Suspense>\n *         <DynamicPage params={params} />\n *       </Suspense>\n *     )\n *   }\n *\n *   const {slug} = await params\n *\n *   return <CachedPage slug={slug} perspective=\"published\" stega={false} />\n * }\n *\n * async function DynamicPage({params}: Pick<PageProps<'/[slug]'>, 'params'>) {\n *   const {slug} = await params\n *   const perspective = await resolvePerspectiveFromCookies({cookies: await cookies()})\n *\n *   return <CachedPage slug={slug} perspective={perspective} stega />\n * }\n *\n * async function CachedPage({\n *   slug,\n *   perspective,\n *   stega,\n * }: Awaited<PageProps<'/[slug]'>['params']> & {\n *   perspective: LivePerspective\n *   stega: boolean\n * }) {\n *   'use cache'\n *\n *   const query = defineQuery(`*[_type == \"page\" && slug.current == $slug][0]`)\n *   const {data} = await sanityFetch({query, params: {slug}, perspective, stega})\n *\n *   return <article>...</article>\n * }\n * ```\n *\n * @public\n */\nexport async function resolvePerspectiveFromCookies({\n  cookies: jar,\n}: {\n  cookies: Awaited<ReturnType<typeof cookies>>\n}): Promise<LivePerspective> {\n  return jar.has(perspectiveCookieName)\n    ? sanitizePerspective(jar.get(perspectiveCookieName)?.value, 'drafts')\n    : 'drafts'\n}\n"],"mappings":";;;AAEA,SAAgB,8BAA8B,OAAwC;AACpF,KAAI,OAAO,MAAM,kBAAkB,UACjC,OAAM,IAAI,MACR,iJAAiJ,gBAAgB,0BAA0B,IAC3L,EAAC,OAAO,OAAM,CACf;;AAIL,SAAgB,2BAA2B,SAGlC;AACP,KAAI,OAAO,QAAQ,gBAAgB,eAAe,QAAQ,gBAAgB,KACxE,OAAM,IAAI,MACR,kIAAkI,gBAAgB,2BAA2B,IAC7K,EAAC,OAAO,SAAQ,CACjB;AAEH,KAAI,OAAO,QAAQ,UAAU,UAC3B,OAAM,IAAI,MACR,4IAA4I,gBAAgB,2BAA2B,IACvL,EAAC,OAAO,SAAQ,CACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACwCL,eAAsB,8BAA8B,EAClD,SAAS,OAGkB;AAC3B,QAAO,IAAI,IAAI,sBAAsB,GACjC,oBAAoB,IAAI,IAAI,sBAAsB,EAAE,OAAO,SAAS,GACpE"}

package/dist/sanitizePerspective.js.map

@@ -1 +1 @@
-{"version":3,"file":"sanitizePerspective.js","names":[],"sources":["../src/live/shared/sanitizePerspective.ts"],"sourcesContent":["import {validateApiPerspective, type ClientPerspective} from '@sanity/client'\n\n// @TODO split into sanitizePerspective and parsePerspective, expose parsePerspective on the /live export\nexport function sanitizePerspective(\n  _perspective: unknown,\n  fallback: 'drafts' | 'published',\n): Exclude<ClientPerspective, 'raw'> {\n  const perspective =\n    typeof _perspective === 'string' && _perspective.includes(',')\n      ? _perspective.split(',')\n      : Array.isArray(_perspective)\n        ? _perspective.filter(Boolean)\n        : _perspective\n  try {\n    validateApiPerspective(perspective)\n    return perspective === 'raw' ? fallback : perspective\n  } catch (err) {\n    console.warn(`Invalid perspective:`, _perspective, perspective, err)\n    return fallback\n  }\n}\n"],"mappings":";AAGA,SAAgB,oBACd,cACA,UACmC;CACnC,MAAM,cACJ,OAAO,iBAAiB,YAAY,aAAa,SAAS,IAAI,GAC1D,aAAa,MAAM,IAAI,GACvB,MAAM,QAAQ,aAAa,GACzB,aAAa,OAAO,QAAQ,GAC5B;AACR,KAAI;AACF,yBAAuB,YAAY;AACnC,SAAO,gBAAgB,QAAQ,WAAW;UACnC,KAAK;AACZ,UAAQ,KAAK,wBAAwB,cAAc,aAAa,IAAI;AACpE,SAAO"}
+{"version":3,"file":"sanitizePerspective.js","names":[],"sources":["../src/live/shared/sanitizePerspective.ts"],"sourcesContent":["import {validateApiPerspective} from '@sanity/client'\n\nimport type {LivePerspective} from '#live/types'\n\n// @TODO split into sanitizePerspective and parsePerspective, expose parsePerspective on the /live export\nexport function sanitizePerspective(\n  _perspective: unknown,\n  fallback: 'drafts' | 'published',\n): LivePerspective {\n  const perspective =\n    typeof _perspective === 'string' && _perspective.includes(',')\n      ? _perspective.split(',')\n      : Array.isArray(_perspective)\n        ? _perspective.filter(Boolean)\n        : _perspective\n  try {\n    validateApiPerspective(perspective)\n    return perspective === 'raw' ? fallback : perspective\n  } catch (err) {\n    console.warn(`Invalid perspective:`, _perspective, perspective, err)\n    return fallback\n  }\n}\n"],"mappings":";AAKA,SAAgB,oBACd,cACA,UACiB;CACjB,MAAM,cACJ,OAAO,iBAAiB,YAAY,aAAa,SAAS,IAAI,GAC1D,aAAa,MAAM,IAAI,GACvB,MAAM,QAAQ,aAAa,GACzB,aAAa,OAAO,QAAQ,GAC5B;AACR,KAAI;AACF,yBAAuB,YAAY;AACnC,SAAO,gBAAgB,QAAQ,WAAW;UACnC,KAAK;AACZ,UAAQ,KAAK,wBAAwB,cAAc,aAAa,IAAI;AACpE,SAAO"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-sanity",
-  "version": "13.0.0-cache-components.48",
+  "version": "13.0.0-cache-components.49",
   "description": "Sanity.io toolkit for Next.js",
   "keywords": [
     "live",
@@ -76,7 +76,7 @@
     "@vitejs/plugin-react": "^6.0.1",
     "@vitest/coverage-v8": "^4.1.5",
     "js-yaml": "^4.1.1",
-    "next": "16.3.0-canary.13",
+    "next": "16.3.0-canary.14",
     "publint": "^0.3.18",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",