@payloadcms/tanstack-start 4.0.0-internal.a0ef1b8 → 4.0.0-internal.a1317b2

package/dist/routes/adminRoutes.js

@@ -0,0 +1,115 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { NotFoundClient, useRouteTransition } from '@payloadcms/ui';
+import { notFound, redirect, useLoaderData } from '@tanstack/react-router';
+import { Fragment, useDeferredValue, useEffect } from 'react';
+import { getAdminMeta } from '../utilities/meta.js';
+const searchToRecord = (searchStr)=>Object.fromEntries(new URLSearchParams(searchStr));
+const runLoader = async (load, splat, searchStr)=>{
+    const data = await load({
+        data: {
+            _splat: splat,
+            search: searchToRecord(searchStr)
+        }
+    });
+    if (data?._redirect) {
+        // eslint-disable-next-line @typescript-eslint/only-throw-error -- TanStack Router requires throwing redirect objects
+        throw redirect({
+            to: data._redirect
+        });
+    }
+    return data;
+};
+function AdminPage() {
+    // Note: React key intentionally omitted here so the persistent template (nav, header) doesn't remount and flash on navigation.
+    // The per-route view key is attached server-side to the view subtree instead, via `renderRoot`'s `key` in `loadAdminPage`.
+    const data = useLoaderData({
+        strict: false
+    });
+    // Route state comes from an external store, so a new RSC payload that suspends
+    // on code-split client references can reveal the router's null fallback.
+    // Keep the current payload painted until the next one is renderable.
+    const rscPayload = useDeferredValue(data?.rscPayload);
+    const { holdRouteTransition } = useRouteTransition();
+    const isRscPayloadDeferred = rscPayload !== data?.rscPayload;
+    useEffect(()=>{
+        if (!isRscPayloadDeferred) {
+            return;
+        }
+        const releaseRouteTransition = holdRouteTransition();
+        return ()=>releaseRouteTransition();
+    }, [
+        holdRouteTransition,
+        isRscPayloadDeferred
+    ]);
+    return /*#__PURE__*/ _jsx(Fragment, {
+        children: rscPayload
+    });
+}
+function AdminNotFound({ data }) {
+    // TanStack exposes not-found data as unknown; this route only receives the shape thrown below.
+    const { routeKey, rscPayload } = data ?? {};
+    if (!rscPayload) {
+        return /*#__PURE__*/ _jsx(NotFoundClient, {});
+    }
+    return /*#__PURE__*/ _jsx(Fragment, {
+        children: rscPayload
+    }, routeKey);
+}
+const adminRouteOptions = ({ forwardNotFoundPayload, load, resolveSplat })=>({
+        component: AdminPage,
+        head: ({ loaderData })=>getAdminMeta(loaderData?.metadata),
+        // Both admin routes must use the same boundary type so index ↔ splat
+        // navigation preserves the existing admin subtree.
+        notFoundComponent: AdminNotFound,
+        // `staleReloadMode: 'blocking'` (a property of the loader *object*, not a
+        // sibling route option — router-core only reads it off a non-function loader)
+        // makes stale-match revalidation await the fresh loader before committing,
+        // instead of the default background SWR that flashes the pre-navigation list
+        // (e.g. a just-created doc missing) until the reload lands.
+        loader: {
+            handler: async ({ location, params })=>{
+                const data = await runLoader(load, resolveSplat(params), location.searchStr);
+                if (data?._notFound) {
+                    // eslint-disable-next-line @typescript-eslint/only-throw-error -- TanStack Router requires throwing notFound objects
+                    throw notFound(forwardNotFoundPayload ? {
+                        data: {
+                            routeKey: data.routeKey,
+                            rscPayload: data.rscPayload
+                        }
+                    } : undefined);
+                }
+                return data;
+            },
+            staleReloadMode: 'blocking'
+        },
+        // Surface query params in `loaderDeps` so `?locale=es` re-runs the loader.
+        loaderDeps: ({ search })=>({
+                searchKey: JSON.stringify(search)
+            }),
+        validateSearch: (search)=>search
+    });
+/**
+ * Route options for the admin splat route (`/_payload/admin/$`). Renders Payload's
+ * server-built NotFound page (shipped via the `notFound()` error's
+ * `data.rscPayload`) for unknown/access-denied routes, falling back to the bare
+ * client view.
+ */ export function payloadAdminSplatRoute({ load }) {
+    return adminRouteOptions({
+        forwardNotFoundPayload: true,
+        load,
+        resolveSplat: (params)=>params._splat ?? ''
+    });
+}
+/**
+ * Route options for the admin index route (`/_payload/admin/`). Not-found
+ * results omit the RSC payload and fall back to `NotFoundClient`.
+ */ export function payloadAdminIndexRoute({ load }) {
+    return adminRouteOptions({
+        forwardNotFoundPayload: false,
+        load,
+        resolveSplat: ()=>''
+    });
+}
+
+//# sourceMappingURL=adminRoutes.js.map

package/dist/routes/adminRoutes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/routes/adminRoutes.tsx"],"sourcesContent":["'use client'\n\nimport type { NotFoundRouteProps } from '@tanstack/react-router'\n\nimport { NotFoundClient, useRouteTransition } from '@payloadcms/ui'\nimport { notFound, redirect, useLoaderData } from '@tanstack/react-router'\nimport { Fragment, type ReactNode, useDeferredValue, useEffect } from 'react'\n\nimport { getAdminMeta } from '../utilities/meta.js'\n\n/**\n * Loader supplied by the app — a TanStack Start `createServerFn` that delegates\n * to `loadAdminPage`. Typed loosely because the server-fn's call signature is\n * generated by the Start compiler.\n */\nexport type AdminLoad = (opts: {\n  data: { _splat: string; search: Record<string, string | string[]> }\n}) => Promise<any>\n\nconst searchToRecord = (searchStr: string): Record<string, string | string[]> =>\n  Object.fromEntries(new URLSearchParams(searchStr)) as Record<string, string | string[]>\n\nconst runLoader = async (load: AdminLoad, splat: string, searchStr: string) => {\n  const data = await load({ data: { _splat: splat, search: searchToRecord(searchStr) } })\n  if (data?._redirect) {\n    // eslint-disable-next-line @typescript-eslint/only-throw-error -- TanStack Router requires throwing redirect objects\n    throw redirect({ to: data._redirect })\n  }\n  return data\n}\n\nfunction AdminPage() {\n  // Note: React key intentionally omitted here so the persistent template (nav, header) doesn't remount and flash on navigation.\n  // The per-route view key is attached server-side to the view subtree instead, via `renderRoot`'s `key` in `loadAdminPage`.\n  const data = useLoaderData({ strict: false })\n\n  // Route state comes from an external store, so a new RSC payload that suspends\n  // on code-split client references can reveal the router's null fallback.\n  // Keep the current payload painted until the next one is renderable.\n  const rscPayload = useDeferredValue(data?.rscPayload)\n  const { holdRouteTransition } = useRouteTransition()\n  const isRscPayloadDeferred = rscPayload !== data?.rscPayload\n\n  useEffect(() => {\n    if (!isRscPayloadDeferred) {\n      return\n    }\n\n    const releaseRouteTransition = holdRouteTransition()\n\n    return () => releaseRouteTransition()\n  }, [holdRouteTransition, isRscPayloadDeferred])\n\n  return <Fragment>{rscPayload}</Fragment>\n}\n\ntype AdminNotFoundData = { routeKey?: string; rscPayload?: ReactNode }\n\nfunction AdminNotFound({ data }: NotFoundRouteProps) {\n  // TanStack exposes not-found data as unknown; this route only receives the shape thrown below.\n  const { routeKey, rscPayload } = (data ?? {}) as AdminNotFoundData\n  if (!rscPayload) {\n    return <NotFoundClient />\n  }\n  return <Fragment key={routeKey}>{rscPayload}</Fragment>\n}\n\nconst adminRouteOptions = ({\n  forwardNotFoundPayload,\n  load,\n  resolveSplat,\n}: {\n  /**\n   * Ships the server-rendered NotFound tree through `notFound()`'s `data` so a\n   * `notFoundComponent` can render it with the full admin chrome. Routes without\n   * one throw bare.\n   */\n  forwardNotFoundPayload: boolean\n  load: AdminLoad\n  /** The route's splat, i.e. the path after `/admin/`. */\n  resolveSplat: (params: any) => string\n}) => ({\n  component: AdminPage,\n  head: ({ loaderData }: { loaderData?: any }) => getAdminMeta(loaderData?.metadata),\n  // Both admin routes must use the same boundary type so index ↔ splat\n  // navigation preserves the existing admin subtree.\n  notFoundComponent: AdminNotFound,\n  // `staleReloadMode: 'blocking'` (a property of the loader *object*, not a\n  // sibling route option — router-core only reads it off a non-function loader)\n  // makes stale-match revalidation await the fresh loader before committing,\n  // instead of the default background SWR that flashes the pre-navigation list\n  // (e.g. a just-created doc missing) until the reload lands.\n  loader: {\n    handler: async ({ location, params }: { location: any; params: any }) => {\n      const data = await runLoader(load, resolveSplat(params), location.searchStr)\n      if (data?._notFound) {\n        // eslint-disable-next-line @typescript-eslint/only-throw-error -- TanStack Router requires throwing notFound objects\n        throw notFound(\n          forwardNotFoundPayload\n            ? { data: { routeKey: data.routeKey, rscPayload: data.rscPayload } }\n            : undefined,\n        )\n      }\n      return data\n    },\n    staleReloadMode: 'blocking' as const,\n  },\n  // Surface query params in `loaderDeps` so `?locale=es` re-runs the loader.\n  loaderDeps: ({ search }: { search: Record<string, unknown> }) => ({\n    searchKey: JSON.stringify(search),\n  }),\n  validateSearch: (search: Record<string, unknown>) => search,\n})\n\n/**\n * Route options for the admin splat route (`/_payload/admin/$`). Renders Payload's\n * server-built NotFound page (shipped via the `notFound()` error's\n * `data.rscPayload`) for unknown/access-denied routes, falling back to the bare\n * client view.\n */\nexport function payloadAdminSplatRoute({ load }: { load: AdminLoad }) {\n  return adminRouteOptions({\n    forwardNotFoundPayload: true,\n    load,\n    resolveSplat: (params) => params._splat ?? '',\n  })\n}\n\n/**\n * Route options for the admin index route (`/_payload/admin/`). Not-found\n * results omit the RSC payload and fall back to `NotFoundClient`.\n */\nexport function payloadAdminIndexRoute({ load }: { load: AdminLoad }) {\n  return adminRouteOptions({\n    forwardNotFoundPayload: false,\n    load,\n    resolveSplat: () => '',\n  })\n}\n"],"names":["NotFoundClient","useRouteTransition","notFound","redirect","useLoaderData","Fragment","useDeferredValue","useEffect","getAdminMeta","searchToRecord","searchStr","Object","fromEntries","URLSearchParams","runLoader","load","splat","data","_splat","search","_redirect","to","AdminPage","strict","rscPayload","holdRouteTransition","isRscPayloadDeferred","releaseRouteTransition","AdminNotFound","routeKey","adminRouteOptions","forwardNotFoundPayload","resolveSplat","component","head","loaderData","metadata","notFoundComponent","loader","handler","location","params","_notFound","undefined","staleReloadMode","loaderDeps","searchKey","JSON","stringify","validateSearch","payloadAdminSplatRoute","payloadAdminIndexRoute"],"mappings":"AAAA;;AAIA,SAASA,cAAc,EAAEC,kBAAkB,QAAQ,iBAAgB;AACnE,SAASC,QAAQ,EAAEC,QAAQ,EAAEC,aAAa,QAAQ,yBAAwB;AAC1E,SAASC,QAAQ,EAAkBC,gBAAgB,EAAEC,SAAS,QAAQ,QAAO;AAE7E,SAASC,YAAY,QAAQ,uBAAsB;AAWnD,MAAMC,iBAAiB,CAACC,YACtBC,OAAOC,WAAW,CAAC,IAAIC,gBAAgBH;AAEzC,MAAMI,YAAY,OAAOC,MAAiBC,OAAeN;IACvD,MAAMO,OAAO,MAAMF,KAAK;QAAEE,MAAM;YAAEC,QAAQF;YAAOG,QAAQV,eAAeC;QAAW;IAAE;IACrF,IAAIO,MAAMG,WAAW;QACnB,qHAAqH;QACrH,MAAMjB,SAAS;YAAEkB,IAAIJ,KAAKG,SAAS;QAAC;IACtC;IACA,OAAOH;AACT;AAEA,SAASK;IACP,+HAA+H;IAC/H,2HAA2H;IAC3H,MAAML,OAAOb,cAAc;QAAEmB,QAAQ;IAAM;IAE3C,+EAA+E;IAC/E,yEAAyE;IACzE,qEAAqE;IACrE,MAAMC,aAAalB,iBAAiBW,MAAMO;IAC1C,MAAM,EAAEC,mBAAmB,EAAE,GAAGxB;IAChC,MAAMyB,uBAAuBF,eAAeP,MAAMO;IAElDjB,UAAU;QACR,IAAI,CAACmB,sBAAsB;YACzB;QACF;QAEA,MAAMC,yBAAyBF;QAE/B,OAAO,IAAME;IACf,GAAG;QAACF;QAAqBC;KAAqB;IAE9C,qBAAO,KAACrB;kBAAUmB;;AACpB;AAIA,SAASI,cAAc,EAAEX,IAAI,EAAsB;IACjD,+FAA+F;IAC/F,MAAM,EAAEY,QAAQ,EAAEL,UAAU,EAAE,GAAIP,QAAQ,CAAC;IAC3C,IAAI,CAACO,YAAY;QACf,qBAAO,KAACxB;IACV;IACA,qBAAO,KAACK;kBAAyBmB;OAAXK;AACxB;AAEA,MAAMC,oBAAoB,CAAC,EACzBC,sBAAsB,EACtBhB,IAAI,EACJiB,YAAY,EAWb,GAAM,CAAA;QACLC,WAAWX;QACXY,MAAM,CAAC,EAAEC,UAAU,EAAwB,GAAK3B,aAAa2B,YAAYC;QACzE,qEAAqE;QACrE,mDAAmD;QACnDC,mBAAmBT;QACnB,0EAA0E;QAC1E,8EAA8E;QAC9E,2EAA2E;QAC3E,6EAA6E;QAC7E,4DAA4D;QAC5DU,QAAQ;YACNC,SAAS,OAAO,EAAEC,QAAQ,EAAEC,MAAM,EAAkC;gBAClE,MAAMxB,OAAO,MAAMH,UAAUC,MAAMiB,aAAaS,SAASD,SAAS9B,SAAS;gBAC3E,IAAIO,MAAMyB,WAAW;oBACnB,qHAAqH;oBACrH,MAAMxC,SACJ6B,yBACI;wBAAEd,MAAM;4BAAEY,UAAUZ,KAAKY,QAAQ;4BAAEL,YAAYP,KAAKO,UAAU;wBAAC;oBAAE,IACjEmB;gBAER;gBACA,OAAO1B;YACT;YACA2B,iBAAiB;QACnB;QACA,2EAA2E;QAC3EC,YAAY,CAAC,EAAE1B,MAAM,EAAuC,GAAM,CAAA;gBAChE2B,WAAWC,KAAKC,SAAS,CAAC7B;YAC5B,CAAA;QACA8B,gBAAgB,CAAC9B,SAAoCA;IACvD,CAAA;AAEA;;;;;CAKC,GACD,OAAO,SAAS+B,uBAAuB,EAAEnC,IAAI,EAAuB;IAClE,OAAOe,kBAAkB;QACvBC,wBAAwB;QACxBhB;QACAiB,cAAc,CAACS,SAAWA,OAAOvB,MAAM,IAAI;IAC7C;AACF;AAEA;;;CAGC,GACD,OAAO,SAASiC,uBAAuB,EAAEpC,IAAI,EAAuB;IAClE,OAAOe,kBAAkB;QACvBC,wBAAwB;QACxBhB;QACAiB,cAAc,IAAM;IACtB;AACF"}

package/dist/routes/apiRoute.d.ts

@@ -0,0 +1,34 @@
+import type { SanitizedConfig } from 'payload';
+type ApiRouteHandler = (ctx: {
+    request: Request;
+}) => Promise<Response>;
+/**
+ * Builds the method handlers for the Payload REST/GraphQL catch-all
+ * (`/_payload/api/$`). The app supplies `getConfig` (an `@payload-config`
+ * import) since the package cannot resolve the consumer's config.
+ *
+ * Imported from `@payloadcms/tanstack-start/server` (not the root barrel) so
+ * the server-only `handleAPIRoute` graph never reaches the client bundle.
+ *
+ * Spread the result into a literal `server.handlers` key so TanStack Start's
+ * client compiler can statically see — and prune — the server-only route:
+ *
+ * ```ts
+ * import { payloadApiHandlers } from '@payloadcms/tanstack-start/server'
+ *
+ * export const Route = createFileRoute('/_payload/api/$')({
+ *   server: {
+ *     handlers: payloadApiHandlers({ getConfig: async () => (await import('@payload-config')).default }),
+ *   },
+ * })
+ * ```
+ *
+ * The compiler only strips a literal `server:` key from a route-options object
+ * expression; wrapping the whole options object in a factory call hides the
+ * key, leaking the config graph into the client bundle.
+ */
+export declare function payloadApiHandlers({ getConfig, }: {
+    getConfig: () => Promise<SanitizedConfig>;
+}): Record<'DELETE' | 'GET' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT', ApiRouteHandler>;
+export {};
+//# sourceMappingURL=apiRoute.d.ts.map

package/dist/routes/apiRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiRoute.d.ts","sourceRoot":"","sources":["../../src/routes/apiRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,KAAK,eAAe,GAAG,CAAC,GAAG,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,SAAS,GACV,EAAE;IACD,SAAS,EAAE,MAAM,OAAO,CAAC,eAAe,CAAC,CAAA;CAC1C,GAAG,MAAM,CAAC,QAAQ,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,EAAE,eAAe,CAAC,CAcnF"}

package/dist/routes/apiRoute.js

@@ -0,0 +1,43 @@
+/**
+ * Builds the method handlers for the Payload REST/GraphQL catch-all
+ * (`/_payload/api/$`). The app supplies `getConfig` (an `@payload-config`
+ * import) since the package cannot resolve the consumer's config.
+ *
+ * Imported from `@payloadcms/tanstack-start/server` (not the root barrel) so
+ * the server-only `handleAPIRoute` graph never reaches the client bundle.
+ *
+ * Spread the result into a literal `server.handlers` key so TanStack Start's
+ * client compiler can statically see — and prune — the server-only route:
+ *
+ * ```ts
+ * import { payloadApiHandlers } from '@payloadcms/tanstack-start/server'
+ *
+ * export const Route = createFileRoute('/_payload/api/$')({
+ *   server: {
+ *     handlers: payloadApiHandlers({ getConfig: async () => (await import('@payload-config')).default }),
+ *   },
+ * })
+ * ```
+ *
+ * The compiler only strips a literal `server:` key from a route-options object
+ * expression; wrapping the whole options object in a factory call hides the
+ * key, leaking the config graph into the client bundle.
+ */ export function payloadApiHandlers({ getConfig }) {
+    const handler = async ({ request })=>{
+        const { handleAPIRoute } = await import('../utilities/handleAPIRoute.server.js');
+        return handleAPIRoute({
+            config: await getConfig(),
+            request
+        });
+    };
+    return {
+        DELETE: handler,
+        GET: handler,
+        OPTIONS: handler,
+        PATCH: handler,
+        POST: handler,
+        PUT: handler
+    };
+}
+
+//# sourceMappingURL=apiRoute.js.map

package/dist/routes/apiRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/routes/apiRoute.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\ntype ApiRouteHandler = (ctx: { request: Request }) => Promise<Response>\n\n/**\n * Builds the method handlers for the Payload REST/GraphQL catch-all\n * (`/_payload/api/$`). The app supplies `getConfig` (an `@payload-config`\n * import) since the package cannot resolve the consumer's config.\n *\n * Imported from `@payloadcms/tanstack-start/server` (not the root barrel) so\n * the server-only `handleAPIRoute` graph never reaches the client bundle.\n *\n * Spread the result into a literal `server.handlers` key so TanStack Start's\n * client compiler can statically see — and prune — the server-only route:\n *\n * ```ts\n * import { payloadApiHandlers } from '@payloadcms/tanstack-start/server'\n *\n * export const Route = createFileRoute('/_payload/api/$')({\n *   server: {\n *     handlers: payloadApiHandlers({ getConfig: async () => (await import('@payload-config')).default }),\n *   },\n * })\n * ```\n *\n * The compiler only strips a literal `server:` key from a route-options object\n * expression; wrapping the whole options object in a factory call hides the\n * key, leaking the config graph into the client bundle.\n */\nexport function payloadApiHandlers({\n  getConfig,\n}: {\n  getConfig: () => Promise<SanitizedConfig>\n}): Record<'DELETE' | 'GET' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT', ApiRouteHandler> {\n  const handler: ApiRouteHandler = async ({ request }) => {\n    const { handleAPIRoute } = await import('../utilities/handleAPIRoute.server.js')\n    return handleAPIRoute({ config: await getConfig(), request })\n  }\n\n  return {\n    DELETE: handler,\n    GET: handler,\n    OPTIONS: handler,\n    PATCH: handler,\n    POST: handler,\n    PUT: handler,\n  }\n}\n"],"names":["payloadApiHandlers","getConfig","handler","request","handleAPIRoute","config","DELETE","GET","OPTIONS","PATCH","POST","PUT"],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;CAwBC,GACD,OAAO,SAASA,mBAAmB,EACjCC,SAAS,EAGV;IACC,MAAMC,UAA2B,OAAO,EAAEC,OAAO,EAAE;QACjD,MAAM,EAAEC,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC;QACxC,OAAOA,eAAe;YAAEC,QAAQ,MAAMJ;YAAaE;QAAQ;IAC7D;IAEA,OAAO;QACLG,QAAQJ;QACRK,KAAKL;QACLM,SAASN;QACTO,OAAOP;QACPQ,MAAMR;QACNS,KAAKT;IACP;AACF"}

package/dist/routes/layoutRoute.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentProps } from 'react';
+import { RootProvider } from '@payloadcms/ui';
+import type { LoadLayoutDataResult } from '../utilities/loadLayoutData.js';
+/**
+ * Loader supplied by the app — a TanStack Start `createServerFn` that delegates
+ * to `loadLayoutData`. Typed loosely because the server-fn's call signature is
+ * generated by the Start compiler.
+ */
+export type LayoutLoad = () => Promise<LoadLayoutDataResult>;
+/**
+ * Route options for the Payload admin layout (`/_payload`). Maps the layout
+ * loader data onto `RootProvider` and renders the admin chrome (progress bar,
+ * custom-provider tree or router `<Outlet />`, portal mount). The app supplies
+ * `load` (the layout-data server fn) and `serverFunction` (the server-function
+ * client wired into `RootProvider`); everything else is adapter-owned.
+ */
+export declare function payloadLayoutRoute({ load, serverFunction, }: {
+    load: LayoutLoad;
+    serverFunction: ComponentProps<typeof RootProvider>['serverFunction'];
+}): {
+    component: () => import("react").JSX.Element;
+    loader: {
+        handler: () => Promise<import("../utilities/toSerializable.js").SerializableRecord>;
+        staleReloadMode: 'blocking';
+    };
+};
+//# sourceMappingURL=layoutRoute.d.ts.map

package/dist/routes/layoutRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layoutRoute.d.ts","sourceRoot":"","sources":["../../src/routes/layoutRoute.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAE3C,OAAO,EAAe,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAG1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAA;AAI1E;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAAA;AAE5D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,cAAc,GACf,EAAE;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,cAAc,EAAE,cAAc,CAAC,OAAO,YAAY,CAAC,CAAC,gBAAgB,CAAC,CAAA;CACtE;IAsCG,SAAS;IACT,MAAM;QAAI,OAAO;QAAgB,eAAe,EAAE,UAAU;;EAE/D"}

package/dist/routes/layoutRoute.js

@@ -0,0 +1,58 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { ProgressBar, RootProvider } from '@payloadcms/ui';
+import { Outlet, useLoaderData } from '@tanstack/react-router';
+import { TanStackRouterAdapter } from '../elements/RouterAdapter/index.js';
+/**
+ * Route options for the Payload admin layout (`/_payload`). Maps the layout
+ * loader data onto `RootProvider` and renders the admin chrome (progress bar,
+ * custom-provider tree or router `<Outlet />`, portal mount). The app supplies
+ * `load` (the layout-data server fn) and `serverFunction` (the server-function
+ * client wired into `RootProvider`); everything else is adapter-owned.
+ */ export function payloadLayoutRoute({ load, serverFunction }) {
+    function PayloadLayout() {
+        const data = useLoaderData({
+            strict: false
+        });
+        return /*#__PURE__*/ _jsxs(_Fragment, {
+            children: [
+                /*#__PURE__*/ _jsxs(RootProvider, {
+                    config: data.clientConfig,
+                    dateFNSKey: data.dateFNSKey,
+                    embed: data.isEmbedded,
+                    fallbackLang: data.fallbackLang,
+                    highContrastMode: false,
+                    isNavOpen: data.isNavOpen,
+                    languageCode: data.languageCode,
+                    languageOptions: data.languageOptions,
+                    locale: data.locale,
+                    permissions: data.user ? data.permissions : null,
+                    RouterAdapter: TanStackRouterAdapter,
+                    serverFunction: serverFunction,
+                    theme: data.theme,
+                    translations: data.translations,
+                    user: data.user,
+                    children: [
+                        /*#__PURE__*/ _jsx(ProgressBar, {}),
+                        data.providers ?? /*#__PURE__*/ _jsx(Outlet, {})
+                    ]
+                }),
+                /*#__PURE__*/ _jsx("div", {
+                    id: "portal"
+                })
+            ]
+        });
+    }
+    // `staleReloadMode` lives on the loader *object* — router-core only reads it
+    // off a non-function loader — so stale-match revalidation blocks on the fresh
+    // loader instead of flashing stale layout data via the default background SWR.
+    return {
+        component: PayloadLayout,
+        loader: {
+            handler: ()=>load(),
+            staleReloadMode: 'blocking'
+        }
+    };
+}
+
+//# sourceMappingURL=layoutRoute.js.map

package/dist/routes/layoutRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/routes/layoutRoute.tsx"],"sourcesContent":["'use client'\n\nimport type { ComponentProps } from 'react'\n\nimport { ProgressBar, RootProvider } from '@payloadcms/ui'\nimport { Outlet, useLoaderData } from '@tanstack/react-router'\n\nimport type { LoadLayoutDataResult } from '../utilities/loadLayoutData.js'\n\nimport { TanStackRouterAdapter } from '../elements/RouterAdapter/index.js'\n\n/**\n * Loader supplied by the app — a TanStack Start `createServerFn` that delegates\n * to `loadLayoutData`. Typed loosely because the server-fn's call signature is\n * generated by the Start compiler.\n */\nexport type LayoutLoad = () => Promise<LoadLayoutDataResult>\n\n/**\n * Route options for the Payload admin layout (`/_payload`). Maps the layout\n * loader data onto `RootProvider` and renders the admin chrome (progress bar,\n * custom-provider tree or router `<Outlet />`, portal mount). The app supplies\n * `load` (the layout-data server fn) and `serverFunction` (the server-function\n * client wired into `RootProvider`); everything else is adapter-owned.\n */\nexport function payloadLayoutRoute({\n  load,\n  serverFunction,\n}: {\n  load: LayoutLoad\n  serverFunction: ComponentProps<typeof RootProvider>['serverFunction']\n}) {\n  function PayloadLayout() {\n    const data = useLoaderData({ strict: false })\n\n    return (\n      <>\n        <RootProvider\n          config={data.clientConfig}\n          dateFNSKey={data.dateFNSKey}\n          embed={data.isEmbedded}\n          fallbackLang={data.fallbackLang}\n          highContrastMode={false}\n          isNavOpen={data.isNavOpen}\n          languageCode={data.languageCode}\n          languageOptions={data.languageOptions}\n          locale={data.locale}\n          permissions={data.user ? data.permissions : null}\n          RouterAdapter={TanStackRouterAdapter}\n          serverFunction={serverFunction}\n          theme={data.theme}\n          translations={data.translations}\n          user={data.user}\n        >\n          <ProgressBar />\n          {/* `data.providers` is the custom-provider tree (config.admin.components.providers)\n              already wrapping the router <Outlet />; falls back to a bare <Outlet /> when\n              no custom providers are configured. */}\n          {data.providers ?? <Outlet />}\n        </RootProvider>\n        <div id=\"portal\" />\n      </>\n    )\n  }\n\n  // `staleReloadMode` lives on the loader *object* — router-core only reads it\n  // off a non-function loader — so stale-match revalidation blocks on the fresh\n  // loader instead of flashing stale layout data via the default background SWR.\n  return {\n    component: PayloadLayout,\n    loader: { handler: () => load(), staleReloadMode: 'blocking' as const },\n  }\n}\n"],"names":["ProgressBar","RootProvider","Outlet","useLoaderData","TanStackRouterAdapter","payloadLayoutRoute","load","serverFunction","PayloadLayout","data","strict","config","clientConfig","dateFNSKey","embed","isEmbedded","fallbackLang","highContrastMode","isNavOpen","languageCode","languageOptions","locale","permissions","user","RouterAdapter","theme","translations","providers","div","id","component","loader","handler","staleReloadMode"],"mappings":"AAAA;;AAIA,SAASA,WAAW,EAAEC,YAAY,QAAQ,iBAAgB;AAC1D,SAASC,MAAM,EAAEC,aAAa,QAAQ,yBAAwB;AAI9D,SAASC,qBAAqB,QAAQ,qCAAoC;AAS1E;;;;;;CAMC,GACD,OAAO,SAASC,mBAAmB,EACjCC,IAAI,EACJC,cAAc,EAIf;IACC,SAASC;QACP,MAAMC,OAAON,cAAc;YAAEO,QAAQ;QAAM;QAE3C,qBACE;;8BACE,MAACT;oBACCU,QAAQF,KAAKG,YAAY;oBACzBC,YAAYJ,KAAKI,UAAU;oBAC3BC,OAAOL,KAAKM,UAAU;oBACtBC,cAAcP,KAAKO,YAAY;oBAC/BC,kBAAkB;oBAClBC,WAAWT,KAAKS,SAAS;oBACzBC,cAAcV,KAAKU,YAAY;oBAC/BC,iBAAiBX,KAAKW,eAAe;oBACrCC,QAAQZ,KAAKY,MAAM;oBACnBC,aAAab,KAAKc,IAAI,GAAGd,KAAKa,WAAW,GAAG;oBAC5CE,eAAepB;oBACfG,gBAAgBA;oBAChBkB,OAAOhB,KAAKgB,KAAK;oBACjBC,cAAcjB,KAAKiB,YAAY;oBAC/BH,MAAMd,KAAKc,IAAI;;sCAEf,KAACvB;wBAIAS,KAAKkB,SAAS,kBAAI,KAACzB;;;8BAEtB,KAAC0B;oBAAIC,IAAG;;;;IAGd;IAEA,6EAA6E;IAC7E,8EAA8E;IAC9E,+EAA+E;IAC/E,OAAO;QACLC,WAAWtB;QACXuB,QAAQ;YAAEC,SAAS,IAAM1B;YAAQ2B,iBAAiB;QAAoB;IACxE;AACF"}

package/dist/utilities/devConfigReload.server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=devConfigReload.server.d.ts.map

package/dist/utilities/devConfigReload.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devConfigReload.server.d.ts","sourceRoot":"","sources":["../../src/utilities/devConfigReload.server.ts"],"names":[],"mappings":""}

package/dist/utilities/devConfigReload.server.js

@@ -0,0 +1,38 @@
+import { registerDevReloadStrategy } from 'payload';
+import { PAYLOAD_CONFIG_CHANGED_EVENT } from './devConfigReloadEvent.js';
+/**
+ * Subscribes the Payload instance to the config-changed event that the
+ * `payload:dev-config-reload` Vite plugin broadcasts.
+ *
+ * Imported for its side effect by `initReq.server.ts`, the adapter's only
+ * `getPayload` call site, so the strategy is registered before an instance can
+ * be built. Registration is module-scoped on both ends: this runs inside the
+ * app's server graph and so resolves the same copy of `payload` that
+ * `getPayload` is called on, and each Vite environment (`ssr`, `rsc`) registers
+ * its own listener against its own copy.
+ *
+ * Vite re-evaluates this module on a program reload, which drops the listeners
+ * the previous instance had collected. `getPayload` reconnects on its next call
+ * because the registered strategy is a new object - see `connectDevReload`.
+ *
+ * `import.meta.hot` is only defined during dev serve, so this is inert in a
+ * production build.
+ */ const hot = import.meta.hot;
+if (hot) {
+    const listeners = new Set();
+    hot.on(PAYLOAD_CONFIG_CHANGED_EVENT, ()=>{
+        for (const onReload of listeners){
+            onReload();
+        }
+    });
+    registerDevReloadStrategy({
+        connect: (onReload)=>{
+            listeners.add(onReload);
+            return ()=>{
+                listeners.delete(onReload);
+            };
+        }
+    });
+}
+
+//# sourceMappingURL=devConfigReload.server.js.map

package/dist/utilities/devConfigReload.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/devConfigReload.server.ts"],"sourcesContent":["import { registerDevReloadStrategy } from 'payload'\n\nimport { PAYLOAD_CONFIG_CHANGED_EVENT } from './devConfigReloadEvent.js'\n\n/**\n * Subscribes the Payload instance to the config-changed event that the\n * `payload:dev-config-reload` Vite plugin broadcasts.\n *\n * Imported for its side effect by `initReq.server.ts`, the adapter's only\n * `getPayload` call site, so the strategy is registered before an instance can\n * be built. Registration is module-scoped on both ends: this runs inside the\n * app's server graph and so resolves the same copy of `payload` that\n * `getPayload` is called on, and each Vite environment (`ssr`, `rsc`) registers\n * its own listener against its own copy.\n *\n * Vite re-evaluates this module on a program reload, which drops the listeners\n * the previous instance had collected. `getPayload` reconnects on its next call\n * because the registered strategy is a new object - see `connectDevReload`.\n *\n * `import.meta.hot` is only defined during dev serve, so this is inert in a\n * production build.\n */\nconst hot = (import.meta as unknown as { hot?: ViteHotContext }).hot\n\nif (hot) {\n  const listeners = new Set<() => void>()\n\n  hot.on(PAYLOAD_CONFIG_CHANGED_EVENT, () => {\n    for (const onReload of listeners) {\n      onReload()\n    }\n  })\n\n  registerDevReloadStrategy({\n    connect: (onReload) => {\n      listeners.add(onReload)\n\n      return () => {\n        listeners.delete(onReload)\n      }\n    },\n  })\n}\n\ntype ViteHotContext = {\n  on: (event: string, cb: () => void) => void\n}\n"],"names":["registerDevReloadStrategy","PAYLOAD_CONFIG_CHANGED_EVENT","hot","listeners","Set","on","onReload","connect","add","delete"],"mappings":"AAAA,SAASA,yBAAyB,QAAQ,UAAS;AAEnD,SAASC,4BAA4B,QAAQ,4BAA2B;AAExE;;;;;;;;;;;;;;;;;CAiBC,GACD,MAAMC,MAAM,AAAC,YAAoDA,GAAG;AAEpE,IAAIA,KAAK;IACP,MAAMC,YAAY,IAAIC;IAEtBF,IAAIG,EAAE,CAACJ,8BAA8B;QACnC,KAAK,MAAMK,YAAYH,UAAW;YAChCG;QACF;IACF;IAEAN,0BAA0B;QACxBO,SAAS,CAACD;YACRH,UAAUK,GAAG,CAACF;YAEd,OAAO;gBACLH,UAAUM,MAAM,CAACH;YACnB;QACF;IACF;AACF"}

package/dist/utilities/devConfigReloadEvent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Custom Vite HMR event the `payload:dev-config-reload` plugin broadcasts when
+ * the Payload config (or anything it imports) changes on disk.
+ *
+ * Kept in its own module so the Vite plugin can name the event without pulling
+ * in the server runtime — and therefore the whole CMS — when `vite.config.ts` loads.
+ */
+export declare const PAYLOAD_CONFIG_CHANGED_EVENT = "payload:config-changed";
+//# sourceMappingURL=devConfigReloadEvent.d.ts.map

package/dist/utilities/devConfigReloadEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devConfigReloadEvent.d.ts","sourceRoot":"","sources":["../../src/utilities/devConfigReloadEvent.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,2BAA2B,CAAA"}

package/dist/utilities/devConfigReloadEvent.js

@@ -0,0 +1,9 @@
+/**
+ * Custom Vite HMR event the `payload:dev-config-reload` plugin broadcasts when
+ * the Payload config (or anything it imports) changes on disk.
+ *
+ * Kept in its own module so the Vite plugin can name the event without pulling
+ * in the server runtime — and therefore the whole CMS — when `vite.config.ts` loads.
+ */ export const PAYLOAD_CONFIG_CHANGED_EVENT = 'payload:config-changed';
+
+//# sourceMappingURL=devConfigReloadEvent.js.map

package/dist/utilities/devConfigReloadEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/devConfigReloadEvent.ts"],"sourcesContent":["/**\n * Custom Vite HMR event the `payload:dev-config-reload` plugin broadcasts when\n * the Payload config (or anything it imports) changes on disk.\n *\n * Kept in its own module so the Vite plugin can name the event without pulling\n * in the server runtime — and therefore the whole CMS — when `vite.config.ts` loads.\n */\nexport const PAYLOAD_CONFIG_CHANGED_EVENT = 'payload:config-changed'\n"],"names":["PAYLOAD_CONFIG_CHANGED_EVENT"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,MAAMA,+BAA+B,yBAAwB"}

package/dist/utilities/getRequestLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getRequestLocale.d.ts","sourceRoot":"","sources":["../../src/utilities/getRequestLocale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAOrD,KAAK,oBAAoB,GAAG;IAC1B,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,wBAAsB,gBAAgB,CAAC,EAAE,GAAG,EAAE,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAkCjG"}
+{"version":3,"file":"getRequestLocale.d.ts","sourceRoot":"","sources":["../../src/utilities/getRequestLocale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAKrD,KAAK,oBAAoB,GAAG;IAC1B,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,wBAAsB,gBAAgB,CAAC,EAAE,GAAG,EAAE,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAkCjG"}

package/dist/utilities/getRequestLocale.js

@@ -1,6 +1,5 @@
-import { upsertPreferences } from '@payloadcms/ui/rsc';
+import { getPreferences, upsertPreferences } from '@payloadcms/ui/rsc';
 import { findLocaleFromCode } from '@payloadcms/ui/shared';
-import { getPreferences } from './getPreferences.js';
 export async function getRequestLocale({ req }) {
     if (req.payload.config.localization) {
         const localeFromParams = req.query.locale;

package/dist/utilities/getRequestLocale.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/getRequestLocale.ts"],"sourcesContent":["import type { Locale, PayloadRequest } from 'payload'\n\nimport { upsertPreferences } from '@payloadcms/ui/rsc'\nimport { findLocaleFromCode } from '@payloadcms/ui/shared'\n\nimport { getPreferences } from './getPreferences.js'\n\ntype GetRequestLocaleArgs = {\n  req: PayloadRequest\n}\n\nexport async function getRequestLocale({ req }: GetRequestLocaleArgs): Promise<Locale | undefined> {\n  if (req.payload.config.localization) {\n    const localeFromParams = req.query.locale as string | undefined\n\n    if (req.user && localeFromParams) {\n      await upsertPreferences<Locale['code']>({ key: 'locale', req, value: localeFromParams })\n    }\n\n    const userLocale =\n      req.user &&\n      findLocaleFromCode(\n        req.payload.config.localization,\n        localeFromParams ||\n          (\n            await getPreferences<Locale['code']>(\n              'locale',\n              req.payload,\n              req.user.id,\n              req.user.collection,\n            )\n          )?.value,\n      )\n\n    return (\n      userLocale ??\n      findLocaleFromCode(\n        req.payload.config.localization,\n        req.payload.config.localization.defaultLocale || 'en',\n      ) ??\n      undefined\n    )\n  }\n\n  return undefined\n}\n"],"names":["upsertPreferences","findLocaleFromCode","getPreferences","getRequestLocale","req","payload","config","localization","localeFromParams","query","locale","user","key","value","userLocale","id","collection","defaultLocale","undefined"],"mappings":"AAEA,SAASA,iBAAiB,QAAQ,qBAAoB;AACtD,SAASC,kBAAkB,QAAQ,wBAAuB;AAE1D,SAASC,cAAc,QAAQ,sBAAqB;AAMpD,OAAO,eAAeC,iBAAiB,EAAEC,GAAG,EAAwB;IAClE,IAAIA,IAAIC,OAAO,CAACC,MAAM,CAACC,YAAY,EAAE;QACnC,MAAMC,mBAAmBJ,IAAIK,KAAK,CAACC,MAAM;QAEzC,IAAIN,IAAIO,IAAI,IAAIH,kBAAkB;YAChC,MAAMR,kBAAkC;gBAAEY,KAAK;gBAAUR;gBAAKS,OAAOL;YAAiB;QACxF;QAEA,MAAMM,aACJV,IAAIO,IAAI,IACRV,mBACEG,IAAIC,OAAO,CAACC,MAAM,CAACC,YAAY,EAC/BC,oBAEI,CAAA,MAAMN,eACJ,UACAE,IAAIC,OAAO,EACXD,IAAIO,IAAI,CAACI,EAAE,EACXX,IAAIO,IAAI,CAACK,UAAU,CACrB,GACCH;QAGT,OACEC,cACAb,mBACEG,IAAIC,OAAO,CAACC,MAAM,CAACC,YAAY,EAC/BH,IAAIC,OAAO,CAACC,MAAM,CAACC,YAAY,CAACU,aAAa,IAAI,SAEnDC;IAEJ;IAEA,OAAOA;AACT"}
+{"version":3,"sources":["../../src/utilities/getRequestLocale.ts"],"sourcesContent":["import type { Locale, PayloadRequest } from 'payload'\n\nimport { getPreferences, upsertPreferences } from '@payloadcms/ui/rsc'\nimport { findLocaleFromCode } from '@payloadcms/ui/shared'\n\ntype GetRequestLocaleArgs = {\n  req: PayloadRequest\n}\n\nexport async function getRequestLocale({ req }: GetRequestLocaleArgs): Promise<Locale | undefined> {\n  if (req.payload.config.localization) {\n    const localeFromParams = req.query.locale as string | undefined\n\n    if (req.user && localeFromParams) {\n      await upsertPreferences<Locale['code']>({ key: 'locale', req, value: localeFromParams })\n    }\n\n    const userLocale =\n      req.user &&\n      findLocaleFromCode(\n        req.payload.config.localization,\n        localeFromParams ||\n          (\n            await getPreferences<Locale['code']>(\n              'locale',\n              req.payload,\n              req.user.id,\n              req.user.collection,\n            )\n          )?.value,\n      )\n\n    return (\n      userLocale ??\n      findLocaleFromCode(\n        req.payload.config.localization,\n        req.payload.config.localization.defaultLocale || 'en',\n      ) ??\n      undefined\n    )\n  }\n\n  return undefined\n}\n"],"names":["getPreferences","upsertPreferences","findLocaleFromCode","getRequestLocale","req","payload","config","localization","localeFromParams","query","locale","user","key","value","userLocale","id","collection","defaultLocale","undefined"],"mappings":"AAEA,SAASA,cAAc,EAAEC,iBAAiB,QAAQ,qBAAoB;AACtE,SAASC,kBAAkB,QAAQ,wBAAuB;AAM1D,OAAO,eAAeC,iBAAiB,EAAEC,GAAG,EAAwB;IAClE,IAAIA,IAAIC,OAAO,CAACC,MAAM,CAACC,YAAY,EAAE;QACnC,MAAMC,mBAAmBJ,IAAIK,KAAK,CAACC,MAAM;QAEzC,IAAIN,IAAIO,IAAI,IAAIH,kBAAkB;YAChC,MAAMP,kBAAkC;gBAAEW,KAAK;gBAAUR;gBAAKS,OAAOL;YAAiB;QACxF;QAEA,MAAMM,aACJV,IAAIO,IAAI,IACRT,mBACEE,IAAIC,OAAO,CAACC,MAAM,CAACC,YAAY,EAC/BC,oBAEI,CAAA,MAAMR,eACJ,UACAI,IAAIC,OAAO,EACXD,IAAIO,IAAI,CAACI,EAAE,EACXX,IAAIO,IAAI,CAACK,UAAU,CACrB,GACCH;QAGT,OACEC,cACAZ,mBACEE,IAAIC,OAAO,CAACC,MAAM,CAACC,YAAY,EAC/BH,IAAIC,OAAO,CAACC,MAAM,CAACC,YAAY,CAACU,aAAa,IAAI,SAEnDC;IAEJ;IAEA,OAAOA;AACT"}

package/dist/utilities/graphqlHandler.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphqlHandler.server.d.ts","sourceRoot":"","sources":["../../src/utilities/graphqlHandler.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA2B,eAAe,EAAE,MAAM,SAAS,CAAA;AAyFvE;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAU,sBAGjC;IACD,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAA;IAClD,OAAO,EAAE,OAAO,CAAA;CACjB,KAAG,OAAO,CAAC,QAAQ,CA2DnB,CAAA"}
+{"version":3,"file":"graphqlHandler.server.d.ts","sourceRoot":"","sources":["../../src/utilities/graphqlHandler.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA2B,eAAe,EAAE,MAAM,SAAS,CAAA;AAyFvE;;;;;GAKG;AACH,eAAO,MAAM,aAAa,yBAGvB;IACD,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAA;IAClD,OAAO,EAAE,OAAO,CAAA;CACjB,KAAG,OAAO,CAAC,QAAQ,CA2DnB,CAAA"}

package/dist/utilities/handleAPIRoute.server.d.ts

@@ -0,0 +1,11 @@
+import type { SanitizedConfig } from 'payload';
+/**
+ * Routes a TanStack Start API request (`/api/*`) to Payload's REST/GraphQL
+ * endpoint handler. The framework adapter wires this into the `/api/$` route's
+ * server handlers, supplying the app's resolved `config`.
+ */
+export declare function handleAPIRoute({ config, request, }: {
+    config: SanitizedConfig;
+    request: Request;
+}): Promise<Response>;
+//# sourceMappingURL=handleAPIRoute.server.d.ts.map

package/dist/utilities/handleAPIRoute.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleAPIRoute.server.d.ts","sourceRoot":"","sources":["../../src/utilities/handleAPIRoute.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAI9C;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,EACnC,MAAM,EACN,OAAO,GACR,EAAE;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,OAAO,EAAE,OAAO,CAAA;CACjB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAapB"}

package/dist/utilities/handleAPIRoute.server.js

@@ -0,0 +1,17 @@
+import { handleEndpoints } from 'payload';
+/**
+ * Routes a TanStack Start API request (`/api/*`) to Payload's REST/GraphQL
+ * endpoint handler. The framework adapter wires this into the `/api/$` route's
+ * server handlers, supplying the app's resolved `config`.
+ */ export async function handleAPIRoute({ config, request }) {
+    const url = new URL(request.url);
+    const slugParts = url.pathname.replace(/^\/api\/?/, '').split('/').filter(Boolean);
+    const path = slugParts.length ? `/api/${slugParts.join('/')}` : '/api';
+    return handleEndpoints({
+        config,
+        path,
+        request
+    });
+}
+
+//# sourceMappingURL=handleAPIRoute.server.js.map

package/dist/utilities/handleAPIRoute.server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/handleAPIRoute.server.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport { handleEndpoints } from 'payload'\n\n/**\n * Routes a TanStack Start API request (`/api/*`) to Payload's REST/GraphQL\n * endpoint handler. The framework adapter wires this into the `/api/$` route's\n * server handlers, supplying the app's resolved `config`.\n */\nexport async function handleAPIRoute({\n  config,\n  request,\n}: {\n  config: SanitizedConfig\n  request: Request\n}): Promise<Response> {\n  const url = new URL(request.url)\n  const slugParts = url.pathname\n    .replace(/^\\/api\\/?/, '')\n    .split('/')\n    .filter(Boolean)\n  const path = slugParts.length ? `/api/${slugParts.join('/')}` : '/api'\n\n  return handleEndpoints({\n    config,\n    path,\n    request,\n  })\n}\n"],"names":["handleEndpoints","handleAPIRoute","config","request","url","URL","slugParts","pathname","replace","split","filter","Boolean","path","length","join"],"mappings":"AAEA,SAASA,eAAe,QAAQ,UAAS;AAEzC;;;;CAIC,GACD,OAAO,eAAeC,eAAe,EACnCC,MAAM,EACNC,OAAO,EAIR;IACC,MAAMC,MAAM,IAAIC,IAAIF,QAAQC,GAAG;IAC/B,MAAME,YAAYF,IAAIG,QAAQ,CAC3BC,OAAO,CAAC,aAAa,IACrBC,KAAK,CAAC,KACNC,MAAM,CAACC;IACV,MAAMC,OAAON,UAAUO,MAAM,GAAG,CAAC,KAAK,EAAEP,UAAUQ,IAAI,CAAC,MAAM,GAAG;IAEhE,OAAOd,gBAAgB;QACrBE;QACAU;QACAT;IACF;AACF"}

package/dist/utilities/handleServerFunctions.d.ts

@@ -1,20 +1,2 @@
-import type { ServerFunctionHandler } from 'payload';
-/**
- * Server function dispatcher for TanStack Start.
- *
- * Mirrors `packages/next/src/utilities/handleServerFunctions.ts` and uses the
- * exact same set of handlers — both adapters share `sharedServerFunctions`
- * plus the small set of RSC-only handlers re-exported by `@payloadcms/ui`.
- *
- * Pipes the result through `serializeForRsc`, which converts any React
- * elements left in the response (e.g. `state[path].customComponents.Field`
- * produced by `buildFormState`, the `List` / `Document` nodes returned by
- * `render-list` / `render-document`) into RSC "renderable handles" via
- * `renderServerComponent` from `@tanstack/react-start/rsc`. TanStack Start's
- * `$RSC` serialization adapter then ships those handles to the client as
- * Flight payloads — so this dispatcher must be invoked from a context that
- * uses TanStack's wire format (e.g. `createServerFn`), not raw
- * `JSON.stringify`.
- */
-export declare const handleServerFunctions: ServerFunctionHandler;
+export declare const handleServerFunctions: import("payload").ServerFunctionHandler;
 //# sourceMappingURL=handleServerFunctions.d.ts.map

package/dist/utilities/handleServerFunctions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handleServerFunctions.d.ts","sourceRoot":"","sources":["../../src/utilities/handleServerFunctions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA6C,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAwB/F;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,qBAAqB,EAAE,qBAkCnC,CAAA"}
+{"version":3,"file":"handleServerFunctions.d.ts","sourceRoot":"","sources":["../../src/utilities/handleServerFunctions.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,qBAAqB,yCAGhC,CAAA"}

package/dist/utilities/handleServerFunctions.js

@@ -1,60 +1,12 @@
-import { renderTabHandler } from '@payloadcms/ui/elements/Nav/SidebarTabs/renderTabServerFn';
-import { _internal_renderFieldHandler } from '@payloadcms/ui/rsc';
-import { sharedServerFunctions } from '@payloadcms/ui/utilities/serverFunctionRegistry';
-import { getDefaultLayoutHandler } from '@payloadcms/ui/views/Dashboard/Default/ModularDashboard/renderWidget/getDefaultLayoutServerFn';
-import { renderWidgetHandler } from '@payloadcms/ui/views/Dashboard/Default/ModularDashboard/renderWidget/renderWidgetServerFn';
-import { renderDocumentSlotsHandler } from '@payloadcms/ui/views/Document/renderDocumentSlots';
-import { RenderRSCComponent } from '../rsc/renderPayloadRSC.js';
+import { createServerFunctionHandler } from '@payloadcms/ui/utilities/handleServerFunctions';
 import { initReq } from './initReq.server.js';
 import { serializeForRsc } from './serializeForRsc.js';
-import { switchLanguageHandler } from './serverFunctionHandlers.js';
-const baseServerFunctions = {
-    ...sharedServerFunctions,
-    'get-default-layout': getDefaultLayoutHandler,
-    'render-document-slots': renderDocumentSlotsHandler,
-    'render-field': _internal_renderFieldHandler,
-    'render-tab': renderTabHandler,
-    'render-widget': renderWidgetHandler,
-    'switch-language': switchLanguageHandler
-};
-/**
- * Server function dispatcher for TanStack Start.
- *
- * Mirrors `packages/next/src/utilities/handleServerFunctions.ts` and uses the
- * exact same set of handlers — both adapters share `sharedServerFunctions`
- * plus the small set of RSC-only handlers re-exported by `@payloadcms/ui`.
- *
- * Pipes the result through `serializeForRsc`, which converts any React
- * elements left in the response (e.g. `state[path].customComponents.Field`
- * produced by `buildFormState`, the `List` / `Document` nodes returned by
- * `render-list` / `render-document`) into RSC "renderable handles" via
- * `renderServerComponent` from `@tanstack/react-start/rsc`. TanStack Start's
- * `$RSC` serialization adapter then ships those handles to the client as
- * Flight payloads — so this dispatcher must be invoked from a context that
- * uses TanStack's wire format (e.g. `createServerFn`), not raw
- * `JSON.stringify`.
- */ export const handleServerFunctions = async (args)=>{
-    const { name: fnKey, args: fnArgs, config: configPromise, importMap, serverFunctions: extraServerFunctions } = args;
-    const { cookies, locale, permissions, req } = await initReq({
-        configPromise,
-        importMap
-    });
-    const augmentedArgs = {
-        ...fnArgs,
-        cookies,
-        importMap,
-        locale,
-        mode: 'rsc',
-        permissions,
-        renderComponent: RenderRSCComponent,
-        req
-    };
-    const fn = extraServerFunctions?.[fnKey] || baseServerFunctions[fnKey];
-    if (!fn) {
-        throw new Error(`Unknown Server Function: ${fnKey}`);
-    }
-    const result = await fn(augmentedArgs);
-    return await serializeForRsc(result);
-};
+export const handleServerFunctions = createServerFunctionHandler({
+    initReq: ({ configPromise, importMap })=>initReq({
+            configPromise,
+            importMap
+        }),
+    transformResult: serializeForRsc
+});
 
 //# sourceMappingURL=handleServerFunctions.js.map

package/dist/utilities/handleServerFunctions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/handleServerFunctions.ts"],"sourcesContent":["import type { DefaultServerFunctionArgs, ServerFunction, ServerFunctionHandler } from 'payload'\n\nimport { renderTabHandler } from '@payloadcms/ui/elements/Nav/SidebarTabs/renderTabServerFn'\nimport { _internal_renderFieldHandler } from '@payloadcms/ui/rsc'\nimport { sharedServerFunctions } from '@payloadcms/ui/utilities/serverFunctionRegistry'\nimport { getDefaultLayoutHandler } from '@payloadcms/ui/views/Dashboard/Default/ModularDashboard/renderWidget/getDefaultLayoutServerFn'\nimport { renderWidgetHandler } from '@payloadcms/ui/views/Dashboard/Default/ModularDashboard/renderWidget/renderWidgetServerFn'\nimport { renderDocumentSlotsHandler } from '@payloadcms/ui/views/Document/renderDocumentSlots'\n\nimport { RenderRSCComponent } from '../rsc/renderPayloadRSC.js'\nimport { initReq } from './initReq.server.js'\nimport { serializeForRsc } from './serializeForRsc.js'\nimport { switchLanguageHandler } from './serverFunctionHandlers.js'\n\nconst baseServerFunctions: Record<string, ServerFunction<any, any>> = {\n  ...sharedServerFunctions,\n  'get-default-layout': getDefaultLayoutHandler,\n  'render-document-slots': renderDocumentSlotsHandler,\n  'render-field': _internal_renderFieldHandler,\n  'render-tab': renderTabHandler,\n  'render-widget': renderWidgetHandler,\n  'switch-language': switchLanguageHandler,\n}\n\n/**\n * Server function dispatcher for TanStack Start.\n *\n * Mirrors `packages/next/src/utilities/handleServerFunctions.ts` and uses the\n * exact same set of handlers — both adapters share `sharedServerFunctions`\n * plus the small set of RSC-only handlers re-exported by `@payloadcms/ui`.\n *\n * Pipes the result through `serializeForRsc`, which converts any React\n * elements left in the response (e.g. `state[path].customComponents.Field`\n * produced by `buildFormState`, the `List` / `Document` nodes returned by\n * `render-list` / `render-document`) into RSC \"renderable handles\" via\n * `renderServerComponent` from `@tanstack/react-start/rsc`. TanStack Start's\n * `$RSC` serialization adapter then ships those handles to the client as\n * Flight payloads — so this dispatcher must be invoked from a context that\n * uses TanStack's wire format (e.g. `createServerFn`), not raw\n * `JSON.stringify`.\n */\nexport const handleServerFunctions: ServerFunctionHandler = async (args) => {\n  const {\n    name: fnKey,\n    args: fnArgs,\n    config: configPromise,\n    importMap,\n    serverFunctions: extraServerFunctions,\n  } = args\n\n  const { cookies, locale, permissions, req } = await initReq({\n    configPromise,\n    importMap,\n  })\n\n  const augmentedArgs: DefaultServerFunctionArgs = {\n    ...fnArgs,\n    cookies,\n    importMap,\n    locale,\n    mode: 'rsc',\n    permissions,\n    renderComponent: RenderRSCComponent,\n    req,\n  }\n\n  const fn = extraServerFunctions?.[fnKey] || baseServerFunctions[fnKey]\n\n  if (!fn) {\n    throw new Error(`Unknown Server Function: ${fnKey}`)\n  }\n\n  const result = await fn(augmentedArgs)\n\n  return await serializeForRsc(result)\n}\n"],"names":["renderTabHandler","_internal_renderFieldHandler","sharedServerFunctions","getDefaultLayoutHandler","renderWidgetHandler","renderDocumentSlotsHandler","RenderRSCComponent","initReq","serializeForRsc","switchLanguageHandler","baseServerFunctions","handleServerFunctions","args","name","fnKey","fnArgs","config","configPromise","importMap","serverFunctions","extraServerFunctions","cookies","locale","permissions","req","augmentedArgs","mode","renderComponent","fn","Error","result"],"mappings":"AAEA,SAASA,gBAAgB,QAAQ,4DAA2D;AAC5F,SAASC,4BAA4B,QAAQ,qBAAoB;AACjE,SAASC,qBAAqB,QAAQ,kDAAiD;AACvF,SAASC,uBAAuB,QAAQ,gGAA+F;AACvI,SAASC,mBAAmB,QAAQ,4FAA2F;AAC/H,SAASC,0BAA0B,QAAQ,oDAAmD;AAE9F,SAASC,kBAAkB,QAAQ,6BAA4B;AAC/D,SAASC,OAAO,QAAQ,sBAAqB;AAC7C,SAASC,eAAe,QAAQ,uBAAsB;AACtD,SAASC,qBAAqB,QAAQ,8BAA6B;AAEnE,MAAMC,sBAAgE;IACpE,GAAGR,qBAAqB;IACxB,sBAAsBC;IACtB,yBAAyBE;IACzB,gBAAgBJ;IAChB,cAAcD;IACd,iBAAiBI;IACjB,mBAAmBK;AACrB;AAEA;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,MAAME,wBAA+C,OAAOC;IACjE,MAAM,EACJC,MAAMC,KAAK,EACXF,MAAMG,MAAM,EACZC,QAAQC,aAAa,EACrBC,SAAS,EACTC,iBAAiBC,oBAAoB,EACtC,GAAGR;IAEJ,MAAM,EAAES,OAAO,EAAEC,MAAM,EAAEC,WAAW,EAAEC,GAAG,EAAE,GAAG,MAAMjB,QAAQ;QAC1DU;QACAC;IACF;IAEA,MAAMO,gBAA2C;QAC/C,GAAGV,MAAM;QACTM;QACAH;QACAI;QACAI,MAAM;QACNH;QACAI,iBAAiBrB;QACjBkB;IACF;IAEA,MAAMI,KAAKR,sBAAsB,CAACN,MAAM,IAAIJ,mBAAmB,CAACI,MAAM;IAEtE,IAAI,CAACc,IAAI;QACP,MAAM,IAAIC,MAAM,CAAC,yBAAyB,EAAEf,OAAO;IACrD;IAEA,MAAMgB,SAAS,MAAMF,GAAGH;IAExB,OAAO,MAAMjB,gBAAgBsB;AAC/B,EAAC"}
+{"version":3,"sources":["../../src/utilities/handleServerFunctions.ts"],"sourcesContent":["import { createServerFunctionHandler } from '@payloadcms/ui/utilities/handleServerFunctions'\n\nimport { initReq } from './initReq.server.js'\nimport { serializeForRsc } from './serializeForRsc.js'\n\nexport const handleServerFunctions = createServerFunctionHandler({\n  initReq: ({ configPromise, importMap }) => initReq({ configPromise, importMap }),\n  transformResult: serializeForRsc,\n})\n"],"names":["createServerFunctionHandler","initReq","serializeForRsc","handleServerFunctions","configPromise","importMap","transformResult"],"mappings":"AAAA,SAASA,2BAA2B,QAAQ,iDAAgD;AAE5F,SAASC,OAAO,QAAQ,sBAAqB;AAC7C,SAASC,eAAe,QAAQ,uBAAsB;AAEtD,OAAO,MAAMC,wBAAwBH,4BAA4B;IAC/DC,SAAS,CAAC,EAAEG,aAAa,EAAEC,SAAS,EAAE,GAAKJ,QAAQ;YAAEG;YAAeC;QAAU;IAC9EC,iBAAiBJ;AACnB,GAAE"}

package/dist/utilities/initReq.server.d.ts

@@ -1,5 +1,6 @@
 import type { ImportMap, InitReqResult, SanitizedConfig, ServerAdapter } from 'payload';
 import { createLocalReq } from 'payload';
+import './devConfigReload.server.js';
 /**
  * Initializes a Payload request object from the current TanStack Start server context.
  * Uses `getRequest()` from `@tanstack/react-start/server` to access the incoming request.

package/dist/utilities/initReq.server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initReq.server.d.ts","sourceRoot":"","sources":["../../src/utilities/initReq.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAIvF,OAAO,EACL,cAAc,EAMf,MAAM,SAAS,CAAA;AAMhB;;;GAGG;AACH,wBAAsB,OAAO,CAAC,EAC5B,aAAa,EACb,SAAS,EACT,SAAS,EACT,aAAqC,GACtC,EAAE;IACD,aAAa,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAA;IACzD,SAAS,EAAE,SAAS,CAAA;IACpB,SAAS,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;IAChD;;;;;OAKG;IACH,aAAa,CAAC,EAAE,aAAa,CAAA;CAC9B,GAAG,OAAO,CAAC,aAAa,CAAC,CAkFzB"}
+{"version":3,"file":"initReq.server.d.ts","sourceRoot":"","sources":["../../src/utilities/initReq.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAIvF,OAAO,EACL,cAAc,EAMf,MAAM,SAAS,CAAA;AAKhB,OAAO,6BAA6B,CAAA;AAIpC;;;GAGG;AACH,wBAAsB,OAAO,CAAC,EAC5B,aAAa,EACb,SAAS,EACT,SAAS,EACT,aAAqC,GACtC,EAAE;IACD,aAAa,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAA;IACzD,SAAS,EAAE,SAAS,CAAA;IACpB,SAAS,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;IAChD;;;;;OAKG;IACH,aAAa,CAAC,EAAE,aAAa,CAAA;CAC9B,GAAG,OAAO,CAAC,aAAa,CAAC,CAkFzB"}