@payloadcms/tanstack-start 4.0.0-beta.0

package/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018-2026 Payload CMS, LLC <info@payloadcms.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/adapters/handleServerFunctions.d.ts

@@ -0,0 +1,2 @@
+export declare const handleServerFunctions: import("payload").ServerFunctionHandler;
+//# sourceMappingURL=handleServerFunctions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleServerFunctions.d.ts","sourceRoot":"","sources":["../../src/adapters/handleServerFunctions.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,qBAAqB,yCAGhC,CAAA"}

package/dist/adapters/handleServerFunctions.js

@@ -0,0 +1,9 @@
+import { createServerFunctionHandler } from '@payloadcms/ui/utilities/handleServerFunctions';
+import { initAdminContext } from '../utilities/initAdminContext.server.js';
+import { serializeForRsc } from '../utilities/serializeForRsc.js';
+export const handleServerFunctions = createServerFunctionHandler({
+    initAdminContext,
+    transformResult: serializeForRsc
+});
+
+//# sourceMappingURL=handleServerFunctions.js.map

package/dist/adapters/handleServerFunctions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/handleServerFunctions.ts"],"sourcesContent":["import { createServerFunctionHandler } from '@payloadcms/ui/utilities/handleServerFunctions'\n\nimport { initAdminContext } from '../utilities/initAdminContext.server.js'\nimport { serializeForRsc } from '../utilities/serializeForRsc.js'\n\nexport const handleServerFunctions = createServerFunctionHandler({\n  initAdminContext,\n  transformResult: serializeForRsc,\n})\n"],"names":["createServerFunctionHandler","initAdminContext","serializeForRsc","handleServerFunctions","transformResult"],"mappings":"AAAA,SAASA,2BAA2B,QAAQ,iDAAgD;AAE5F,SAASC,gBAAgB,QAAQ,0CAAyC;AAC1E,SAASC,eAAe,QAAQ,kCAAiC;AAEjE,OAAO,MAAMC,wBAAwBH,4BAA4B;IAC/DC;IACAG,iBAAiBF;AACnB,GAAE"}

package/dist/adapters/layout/index.d.ts

@@ -0,0 +1,66 @@
+import type { ServerFunctionClient } from 'payload';
+import React from 'react';
+import type { LoadLayoutDataResult } from './server.js';
+export type PayloadAdminShellProps = {
+    readonly children: React.ReactNode;
+};
+/**
+ * The `<html>` document shell for Payload admin routes — the TanStack Start
+ * equivalent of `@payloadcms/next`'s root layout `<html>`. Sets
+ * `data-theme`/`lang`/`dir` on `<html>` from the server-computed layout data
+ * (`getLayoutData`, exposed on the `/_payload` route loader), so the admin
+ * panel shares document rendering and request preferences with Next's `RootLayout`.
+ * A blocking script resolves the default theme from the browser preference before first paint.
+ */
+export declare function PayloadAdminShell({ children }: PayloadAdminShellProps): React.JSX.Element;
+export type WithPayloadRootOptions = {
+    /**
+     * Path prefix that mounts the Payload admin panel (`config.routes.admin`).
+     * Routes under it render the Payload admin document shell; everything else
+     * renders your own shell. Defaults to `'/admin'`.
+     */
+    adminRoute?: string;
+};
+/**
+ * Wraps your application's root document shell so Payload owns its own
+ * `<html>` chrome on admin routes while your shell renders everywhere else.
+ *
+ * Attach the result to the root route's `shellComponent`; it is the single
+ * integration touch point — no root loader and no manual data threading:
+ *
+ * ```tsx
+ * export const Route = createRootRoute({
+ *   shellComponent: withPayloadRoot(MarketingRoot),
+ * })
+ * ```
+ */
+export declare function withPayloadRoot(RootShell: React.ComponentType<{
+    children: React.ReactNode;
+}>, options?: WithPayloadRootOptions): ({ children }: {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+/**
+ * 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`). The app supplies
+ * `load` (the layout-data server fn) and `serverFunction` (the server-function
+ * client wired into `RootProviders`); everything else is adapter-owned.
+ */
+export declare function payloadLayoutRoute({ load, serverFunction, }: {
+    load: LayoutLoad;
+    serverFunction: ServerFunctionClient;
+}): {
+    component: {
+        (): React.JSX.Element;
+        preload: (() => Promise<void> | undefined) | undefined;
+    };
+    loader: {
+        handler: () => Promise<import("../../utilities/toSerializable.js").SerializableRecord>;
+        staleReloadMode: 'blocking';
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/layout/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/layout/index.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAInD,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAEvD,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CACnC,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,QAAQ,EAAE,EAAE,sBAAsB,qBA+BrE;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,CAAC,EAC7D,OAAO,GAAE,sBAA2B,kBAIW;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,uBAc7E;AAED;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAAA;AAM5D;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,cAAc,GACf,EAAE;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,cAAc,EAAE,oBAAoB,CAAA;CACrC;IAUG,SAAS;;;;IACT,MAAM;QAAI,OAAO;QAAgB,eAAe,EAAE,UAAU;;EAE/D"}

package/dist/adapters/layout/index.js

@@ -0,0 +1,105 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DocumentRoot } from '@payloadcms/ui/layouts/DocumentRoot';
+import { HeadContent, lazyRouteComponent, Scripts, useRouterState } from '@tanstack/react-router';
+import React from 'react';
+/**
+ * The `<html>` document shell for Payload admin routes — the TanStack Start
+ * equivalent of `@payloadcms/next`'s root layout `<html>`. Sets
+ * `data-theme`/`lang`/`dir` on `<html>` from the server-computed layout data
+ * (`getLayoutData`, exposed on the `/_payload` route loader), so the admin
+ * panel shares document rendering and request preferences with Next's `RootLayout`.
+ * A blocking script resolves the default theme from the browser preference before first paint.
+ */ export function PayloadAdminShell({ children }) {
+    const documentProps = useRouterState({
+        select: (state)=>{
+            for (const match of state.matches){
+                const data = match.loaderData;
+                if (data?.theme && data?.languageCode) {
+                    return {
+                        dir: data.dir,
+                        highContrastMode: data.highContrastMode,
+                        languageCode: data.languageCode,
+                        suppressHydrationWarning: data.suppressHydrationWarning,
+                        theme: data.theme,
+                        themeSource: data.themeSource ?? 'default'
+                    };
+                }
+            }
+            // No layout data yet (fresh session before the loader resolves): default
+            // to `ltr` so the `[dir='ltr']`-scoped admin layout rules (e.g. the
+            // document sidebar divider) still match, matching Next's `ltr` default.
+            return {
+                dir: 'ltr',
+                suppressHydrationWarning: true,
+                themeSource: 'default'
+            };
+        }
+    });
+    return /*#__PURE__*/ _jsxs(DocumentRoot, {
+        ...documentProps,
+        head: /*#__PURE__*/ _jsx(HeadContent, {}),
+        children: [
+            children,
+            /*#__PURE__*/ _jsx(Scripts, {})
+        ]
+    });
+}
+/**
+ * Wraps your application's root document shell so Payload owns its own
+ * `<html>` chrome on admin routes while your shell renders everywhere else.
+ *
+ * Attach the result to the root route's `shellComponent`; it is the single
+ * integration touch point — no root loader and no manual data threading:
+ *
+ * ```tsx
+ * export const Route = createRootRoute({
+ *   shellComponent: withPayloadRoot(MarketingRoot),
+ * })
+ * ```
+ */ export function withPayloadRoot(RootShell, options = {}) {
+    const { adminRoute = '/admin' } = options;
+    return function PayloadRootShell({ children }) {
+        const isAdminRoute = useRouterState({
+            select: (s)=>{
+                const { pathname } = s.location;
+                return pathname === adminRoute || pathname.startsWith(`${adminRoute}/`);
+            }
+        });
+        if (isAdminRoute) {
+            return /*#__PURE__*/ _jsx(PayloadAdminShell, {
+                children: children
+            });
+        }
+        return /*#__PURE__*/ _jsx(RootShell, {
+            children: children
+        });
+    };
+}
+// The admin UI loads with the admin routes only, so front-end routes never download it. The
+// router preloads lazy route components before rendering, so admin pages don't flash.
+const PayloadLayout = lazyRouteComponent(()=>import('./lazy.js'), 'PayloadLayout');
+/**
+ * Route options for the Payload admin layout (`/_payload`). The app supplies
+ * `load` (the layout-data server fn) and `serverFunction` (the server-function
+ * client wired into `RootProviders`); everything else is adapter-owned.
+ */ export function payloadLayoutRoute({ load, serverFunction }) {
+    function PayloadLayoutRoute() {
+        return /*#__PURE__*/ _jsx(PayloadLayout, {
+            serverFunction: serverFunction
+        });
+    }
+    PayloadLayoutRoute.preload = PayloadLayout.preload;
+    // `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: PayloadLayoutRoute,
+        loader: {
+            handler: ()=>load(),
+            staleReloadMode: 'blocking'
+        }
+    };
+}
+
+//# sourceMappingURL=index.js.map

package/dist/adapters/layout/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/layout/index.tsx"],"sourcesContent":["'use client'\nimport type { DocumentRootProps } from '@payloadcms/ui/layouts/DocumentRoot'\nimport type { RootLayoutData } from '@payloadcms/ui/layouts/Root/getRootLayoutData'\nimport type { ServerFunctionClient } from 'payload'\n\nimport { DocumentRoot } from '@payloadcms/ui/layouts/DocumentRoot'\nimport { HeadContent, lazyRouteComponent, Scripts, useRouterState } from '@tanstack/react-router'\nimport React from 'react'\n\nimport type { LoadLayoutDataResult } from './server.js'\n\nexport type PayloadAdminShellProps = {\n  readonly children: React.ReactNode\n}\n\n/**\n * The `<html>` document shell for Payload admin routes — the TanStack Start\n * equivalent of `@payloadcms/next`'s root layout `<html>`. Sets\n * `data-theme`/`lang`/`dir` on `<html>` from the server-computed layout data\n * (`getLayoutData`, exposed on the `/_payload` route loader), so the admin\n * panel shares document rendering and request preferences with Next's `RootLayout`.\n * A blocking script resolves the default theme from the browser preference before first paint.\n */\nexport function PayloadAdminShell({ children }: PayloadAdminShellProps) {\n  const documentProps = useRouterState({\n    select: (state): Partial<DocumentRootProps> => {\n      for (const match of state.matches) {\n        const data = match.loaderData as Partial<RootLayoutData> | undefined\n\n        if (data?.theme && data?.languageCode) {\n          return {\n            dir: data.dir,\n            highContrastMode: data.highContrastMode,\n            languageCode: data.languageCode,\n            suppressHydrationWarning: data.suppressHydrationWarning,\n            theme: data.theme,\n            themeSource: data.themeSource ?? 'default',\n          }\n        }\n      }\n\n      // No layout data yet (fresh session before the loader resolves): default\n      // to `ltr` so the `[dir='ltr']`-scoped admin layout rules (e.g. the\n      // document sidebar divider) still match, matching Next's `ltr` default.\n      return { dir: 'ltr', suppressHydrationWarning: true, themeSource: 'default' }\n    },\n  })\n\n  return (\n    <DocumentRoot {...documentProps} head={<HeadContent />}>\n      {children}\n      <Scripts />\n    </DocumentRoot>\n  )\n}\n\nexport type WithPayloadRootOptions = {\n  /**\n   * Path prefix that mounts the Payload admin panel (`config.routes.admin`).\n   * Routes under it render the Payload admin document shell; everything else\n   * renders your own shell. Defaults to `'/admin'`.\n   */\n  adminRoute?: string\n}\n\n/**\n * Wraps your application's root document shell so Payload owns its own\n * `<html>` chrome on admin routes while your shell renders everywhere else.\n *\n * Attach the result to the root route's `shellComponent`; it is the single\n * integration touch point — no root loader and no manual data threading:\n *\n * ```tsx\n * export const Route = createRootRoute({\n *   shellComponent: withPayloadRoot(MarketingRoot),\n * })\n * ```\n */\nexport function withPayloadRoot(\n  RootShell: React.ComponentType<{ children: React.ReactNode }>,\n  options: WithPayloadRootOptions = {},\n) {\n  const { adminRoute = '/admin' } = options\n\n  return function PayloadRootShell({ children }: { children: React.ReactNode }) {\n    const isAdminRoute = useRouterState({\n      select: (s) => {\n        const { pathname } = s.location\n        return pathname === adminRoute || pathname.startsWith(`${adminRoute}/`)\n      },\n    })\n\n    if (isAdminRoute) {\n      return <PayloadAdminShell>{children}</PayloadAdminShell>\n    }\n\n    return <RootShell>{children}</RootShell>\n  }\n}\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// The admin UI loads with the admin routes only, so front-end routes never download it. The\n// router preloads lazy route components before rendering, so admin pages don't flash.\nconst PayloadLayout = lazyRouteComponent(() => import('./lazy.js'), 'PayloadLayout')\n\n/**\n * Route options for the Payload admin layout (`/_payload`). The app supplies\n * `load` (the layout-data server fn) and `serverFunction` (the server-function\n * client wired into `RootProviders`); everything else is adapter-owned.\n */\nexport function payloadLayoutRoute({\n  load,\n  serverFunction,\n}: {\n  load: LayoutLoad\n  serverFunction: ServerFunctionClient\n}) {\n  function PayloadLayoutRoute() {\n    return <PayloadLayout serverFunction={serverFunction} />\n  }\n  PayloadLayoutRoute.preload = PayloadLayout.preload\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: PayloadLayoutRoute,\n    loader: { handler: () => load(), staleReloadMode: 'blocking' as const },\n  }\n}\n"],"names":["DocumentRoot","HeadContent","lazyRouteComponent","Scripts","useRouterState","React","PayloadAdminShell","children","documentProps","select","state","match","matches","data","loaderData","theme","languageCode","dir","highContrastMode","suppressHydrationWarning","themeSource","head","withPayloadRoot","RootShell","options","adminRoute","PayloadRootShell","isAdminRoute","s","pathname","location","startsWith","PayloadLayout","payloadLayoutRoute","load","serverFunction","PayloadLayoutRoute","preload","component","loader","handler","staleReloadMode"],"mappings":"AAAA;;AAKA,SAASA,YAAY,QAAQ,sCAAqC;AAClE,SAASC,WAAW,EAAEC,kBAAkB,EAAEC,OAAO,EAAEC,cAAc,QAAQ,yBAAwB;AACjG,OAAOC,WAAW,QAAO;AAQzB;;;;;;;CAOC,GACD,OAAO,SAASC,kBAAkB,EAAEC,QAAQ,EAA0B;IACpE,MAAMC,gBAAgBJ,eAAe;QACnCK,QAAQ,CAACC;YACP,KAAK,MAAMC,SAASD,MAAME,OAAO,CAAE;gBACjC,MAAMC,OAAOF,MAAMG,UAAU;gBAE7B,IAAID,MAAME,SAASF,MAAMG,cAAc;oBACrC,OAAO;wBACLC,KAAKJ,KAAKI,GAAG;wBACbC,kBAAkBL,KAAKK,gBAAgB;wBACvCF,cAAcH,KAAKG,YAAY;wBAC/BG,0BAA0BN,KAAKM,wBAAwB;wBACvDJ,OAAOF,KAAKE,KAAK;wBACjBK,aAAaP,KAAKO,WAAW,IAAI;oBACnC;gBACF;YACF;YAEA,yEAAyE;YACzE,oEAAoE;YACpE,wEAAwE;YACxE,OAAO;gBAAEH,KAAK;gBAAOE,0BAA0B;gBAAMC,aAAa;YAAU;QAC9E;IACF;IAEA,qBACE,MAACpB;QAAc,GAAGQ,aAAa;QAAEa,oBAAM,KAACpB;;YACrCM;0BACD,KAACJ;;;AAGP;AAWA;;;;;;;;;;;;CAYC,GACD,OAAO,SAASmB,gBACdC,SAA6D,EAC7DC,UAAkC,CAAC,CAAC;IAEpC,MAAM,EAAEC,aAAa,QAAQ,EAAE,GAAGD;IAElC,OAAO,SAASE,iBAAiB,EAAEnB,QAAQ,EAAiC;QAC1E,MAAMoB,eAAevB,eAAe;YAClCK,QAAQ,CAACmB;gBACP,MAAM,EAAEC,QAAQ,EAAE,GAAGD,EAAEE,QAAQ;gBAC/B,OAAOD,aAAaJ,cAAcI,SAASE,UAAU,CAAC,GAAGN,WAAW,CAAC,CAAC;YACxE;QACF;QAEA,IAAIE,cAAc;YAChB,qBAAO,KAACrB;0BAAmBC;;QAC7B;QAEA,qBAAO,KAACgB;sBAAWhB;;IACrB;AACF;AASA,4FAA4F;AAC5F,sFAAsF;AACtF,MAAMyB,gBAAgB9B,mBAAmB,IAAM,MAAM,CAAC,cAAc;AAEpE;;;;CAIC,GACD,OAAO,SAAS+B,mBAAmB,EACjCC,IAAI,EACJC,cAAc,EAIf;IACC,SAASC;QACP,qBAAO,KAACJ;YAAcG,gBAAgBA;;IACxC;IACAC,mBAAmBC,OAAO,GAAGL,cAAcK,OAAO;IAElD,6EAA6E;IAC7E,8EAA8E;IAC9E,+EAA+E;IAC/E,OAAO;QACLC,WAAWF;QACXG,QAAQ;YAAEC,SAAS,IAAMN;YAAQO,iBAAiB;QAAoB;IACxE;AACF"}

package/dist/adapters/layout/lazy.d.ts

@@ -0,0 +1,11 @@
+import type { ServerFunctionClient } from 'payload';
+import React from 'react';
+/**
+ * The admin layout route's component. Maps the layout loader data onto `RootProviders` and
+ * renders the admin chrome (progress bar, custom-provider tree or router `<Outlet />`, portal
+ * mount). `payloadLayoutRoute` loads it lazily, so front-end routes never download the admin UI.
+ */
+export declare function PayloadLayout({ serverFunction }: {
+    serverFunction: ServerFunctionClient;
+}): React.JSX.Element;
+//# sourceMappingURL=lazy.d.ts.map

package/dist/adapters/layout/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../../src/adapters/layout/lazy.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAInD,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAAE,cAAc,EAAE,EAAE;IAAE,cAAc,EAAE,oBAAoB,CAAA;CAAE,qBAYzF"}

package/dist/adapters/layout/lazy.js

@@ -0,0 +1,23 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RootProviders } from '@payloadcms/ui';
+import { Outlet, useLoaderData } from '@tanstack/react-router';
+import React from 'react';
+import { TanStackRouterAdapter } from '../router.js';
+/**
+ * The admin layout route's component. Maps the layout loader data onto `RootProviders` and
+ * renders the admin chrome (progress bar, custom-provider tree or router `<Outlet />`, portal
+ * mount). `payloadLayoutRoute` loads it lazily, so front-end routes never download the admin UI.
+ */ export function PayloadLayout({ serverFunction }) {
+    const data = useLoaderData({
+        strict: false
+    });
+    return /*#__PURE__*/ _jsx(RootProviders, {
+        data: data,
+        RouterAdapter: TanStackRouterAdapter,
+        serverFunction: serverFunction,
+        children: data.providers ?? /*#__PURE__*/ _jsx(Outlet, {})
+    });
+}
+
+//# sourceMappingURL=lazy.js.map

package/dist/adapters/layout/lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/layout/lazy.tsx"],"sourcesContent":["'use client'\nimport type { ServerFunctionClient } from 'payload'\n\nimport { RootProviders } from '@payloadcms/ui'\nimport { Outlet, useLoaderData } from '@tanstack/react-router'\nimport React from 'react'\n\nimport { TanStackRouterAdapter } from '../router.js'\n\n/**\n * The admin layout route's component. Maps the layout loader data onto `RootProviders` and\n * renders the admin chrome (progress bar, custom-provider tree or router `<Outlet />`, portal\n * mount). `payloadLayoutRoute` loads it lazily, so front-end routes never download the admin UI.\n */\nexport function PayloadLayout({ serverFunction }: { serverFunction: ServerFunctionClient }) {\n  const data = useLoaderData({ strict: false })\n\n  return (\n    <RootProviders\n      data={data}\n      RouterAdapter={TanStackRouterAdapter}\n      serverFunction={serverFunction}\n    >\n      {data.providers ?? <Outlet />}\n    </RootProviders>\n  )\n}\n"],"names":["RootProviders","Outlet","useLoaderData","React","TanStackRouterAdapter","PayloadLayout","serverFunction","data","strict","RouterAdapter","providers"],"mappings":"AAAA;;AAGA,SAASA,aAAa,QAAQ,iBAAgB;AAC9C,SAASC,MAAM,EAAEC,aAAa,QAAQ,yBAAwB;AAC9D,OAAOC,WAAW,QAAO;AAEzB,SAASC,qBAAqB,QAAQ,eAAc;AAEpD;;;;CAIC,GACD,OAAO,SAASC,cAAc,EAAEC,cAAc,EAA4C;IACxF,MAAMC,OAAOL,cAAc;QAAEM,QAAQ;IAAM;IAE3C,qBACE,KAACR;QACCO,MAAMA;QACNE,eAAeL;QACfE,gBAAgBA;kBAEfC,KAAKG,SAAS,kBAAI,KAACT;;AAG1B"}

package/dist/adapters/layout/server.d.ts

@@ -0,0 +1,29 @@
+import type { RootLayoutData as UIRootLayoutData } from '@payloadcms/ui/layouts/Root/getRootLayoutData';
+import type { ImportMap, SanitizedConfig } from 'payload';
+import type { ReactNode } from 'react';
+import type { SerializableRecord } from '../../utilities/toSerializable.js';
+export type LoadLayoutDataResult = SerializableRecord;
+export type RootLayoutData = {
+    /** Custom admin providers wrapping the Outlet, rendered to an RSC payload before serialization. */
+    providers?: ReactNode;
+} & UIRootLayoutData;
+export type GetLayoutDataArgs = {
+    configPromise: Promise<SanitizedConfig> | SanitizedConfig;
+    importMap: ImportMap;
+};
+/** Fetches the admin layout data for the TanStack layout route loader. */
+export declare function getLayoutData({ configPromise, importMap, }: GetLayoutDataArgs): Promise<RootLayoutData>;
+/**
+ * Resolves the admin layout data for TanStack Start and returns a serializable
+ * payload for the `/_payload` route loader. The framework adapter wraps this in
+ * a `createServerFn` that supplies the app's `config` and generated `importMap`.
+ *
+ * `toSerializable` strips React elements, so the custom-providers element tree
+ * (`config.admin.components.providers`) is rendered to an RSC payload separately
+ * and re-attached.
+ */
+export declare function loadLayoutData({ config, importMap, }: {
+    config: SanitizedConfig;
+    importMap: ImportMap;
+}): Promise<LoadLayoutDataResult>;
+//# sourceMappingURL=server.d.ts.map

package/dist/adapters/layout/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/adapters/layout/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,IAAI,gBAAgB,EAAE,MAAM,+CAA+C,CAAA;AACvG,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAe,MAAM,SAAS,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAQtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAK3E,MAAM,MAAM,oBAAoB,GAAG,kBAAkB,CAAA;AAErD,MAAM,MAAM,cAAc,GAAG;IAC3B,mGAAmG;IACnG,SAAS,CAAC,EAAE,SAAS,CAAA;CACtB,GAAG,gBAAgB,CAAA;AAEpB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,aAAa,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAA;IACzD,SAAS,EAAE,SAAS,CAAA;CACrB,CAAA;AAED,0EAA0E;AAC1E,wBAAsB,aAAa,CAAC,EAClC,aAAa,EACb,SAAS,GACV,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAqC7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,EACnC,MAAM,EACN,SAAS,GACV,EAAE;IACD,MAAM,EAAE,eAAe,CAAA;IACvB,SAAS,EAAE,SAAS,CAAA;CACrB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAMhC"}

package/dist/adapters/layout/server.js

@@ -0,0 +1,63 @@
+import { NestProviders } from '@payloadcms/ui/layouts/NestProviders';
+import { getRootLayoutData } from '@payloadcms/ui/layouts/Root/getRootLayoutData';
+import { Outlet } from '@tanstack/react-router';
+import { renderServerComponent } from '@tanstack/react-start/rsc';
+import { createElement } from 'react';
+import { initAdminContext } from '../../utilities/initAdminContext.server.js';
+import { toSerializable } from '../../utilities/toSerializable.js';
+/** Fetches the admin layout data for the TanStack layout route loader. */ export async function getLayoutData({ configPromise, importMap }) {
+    const context = await initAdminContext({
+        configPromise,
+        importMap
+    });
+    const { cookies, permissions, req, user } = context;
+    const data = await getRootLayoutData({
+        cookies,
+        importMap,
+        permissions,
+        req,
+        user
+    });
+    const providerPaths = req.payload.config.admin?.components?.providers;
+    let providers;
+    if (Array.isArray(providerPaths) && providerPaths.length > 0) {
+        const serverProps = {
+            i18n: req.i18n,
+            params: {},
+            payload: req.payload,
+            permissions,
+            searchParams: {},
+            server: req.server,
+            user: user ?? undefined
+        };
+        providers = createElement(NestProviders, {
+            children: createElement(Outlet),
+            importMap,
+            providers: providerPaths,
+            serverProps
+        });
+    }
+    return {
+        ...data,
+        providers
+    };
+}
+/**
+ * Resolves the admin layout data for TanStack Start and returns a serializable
+ * payload for the `/_payload` route loader. The framework adapter wraps this in
+ * a `createServerFn` that supplies the app's `config` and generated `importMap`.
+ *
+ * `toSerializable` strips React elements, so the custom-providers element tree
+ * (`config.admin.components.providers`) is rendered to an RSC payload separately
+ * and re-attached.
+ */ export async function loadLayoutData({ config, importMap }) {
+    const { providers, ...data } = await getLayoutData({
+        configPromise: config,
+        importMap
+    });
+    return toSerializable(data, {
+        providers: providers ? await renderServerComponent(providers) : undefined
+    });
+}
+
+//# sourceMappingURL=server.js.map

package/dist/adapters/layout/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/layout/server.ts"],"sourcesContent":["import type { RootLayoutData as UIRootLayoutData } from '@payloadcms/ui/layouts/Root/getRootLayoutData'\nimport type { ImportMap, SanitizedConfig, ServerProps } from 'payload'\nimport type { ReactNode } from 'react'\n\nimport { NestProviders } from '@payloadcms/ui/layouts/NestProviders'\nimport { getRootLayoutData } from '@payloadcms/ui/layouts/Root/getRootLayoutData'\nimport { Outlet } from '@tanstack/react-router'\nimport { renderServerComponent } from '@tanstack/react-start/rsc'\nimport { createElement } from 'react'\n\nimport type { SerializableRecord } from '../../utilities/toSerializable.js'\n\nimport { initAdminContext } from '../../utilities/initAdminContext.server.js'\nimport { toSerializable } from '../../utilities/toSerializable.js'\n\nexport type LoadLayoutDataResult = SerializableRecord\n\nexport type RootLayoutData = {\n  /** Custom admin providers wrapping the Outlet, rendered to an RSC payload before serialization. */\n  providers?: ReactNode\n} & UIRootLayoutData\n\nexport type GetLayoutDataArgs = {\n  configPromise: Promise<SanitizedConfig> | SanitizedConfig\n  importMap: ImportMap\n}\n\n/** Fetches the admin layout data for the TanStack layout route loader. */\nexport async function getLayoutData({\n  configPromise,\n  importMap,\n}: GetLayoutDataArgs): Promise<RootLayoutData> {\n  const context = await initAdminContext({ configPromise, importMap })\n\n  const { cookies, permissions, req, user } = context\n\n  const data = await getRootLayoutData({\n    cookies,\n    importMap,\n    permissions,\n    req,\n    user,\n  })\n\n  const providerPaths = req.payload.config.admin?.components?.providers\n\n  let providers: ReactNode\n\n  if (Array.isArray(providerPaths) && providerPaths.length > 0) {\n    const serverProps: ServerProps = {\n      i18n: req.i18n,\n      params: {},\n      payload: req.payload,\n      permissions,\n      searchParams: {},\n      server: req.server!,\n      user: user ?? undefined,\n    }\n\n    providers = createElement(NestProviders, {\n      children: createElement(Outlet),\n      importMap,\n      providers: providerPaths,\n      serverProps,\n    })\n  }\n\n  return { ...data, providers }\n}\n\n/**\n * Resolves the admin layout data for TanStack Start and returns a serializable\n * payload for the `/_payload` route loader. The framework adapter wraps this in\n * a `createServerFn` that supplies the app's `config` and generated `importMap`.\n *\n * `toSerializable` strips React elements, so the custom-providers element tree\n * (`config.admin.components.providers`) is rendered to an RSC payload separately\n * and re-attached.\n */\nexport async function loadLayoutData({\n  config,\n  importMap,\n}: {\n  config: SanitizedConfig\n  importMap: ImportMap\n}): Promise<LoadLayoutDataResult> {\n  const { providers, ...data } = await getLayoutData({ configPromise: config, importMap })\n\n  return toSerializable(data, {\n    providers: providers ? await renderServerComponent(providers as any) : undefined,\n  })\n}\n"],"names":["NestProviders","getRootLayoutData","Outlet","renderServerComponent","createElement","initAdminContext","toSerializable","getLayoutData","configPromise","importMap","context","cookies","permissions","req","user","data","providerPaths","payload","config","admin","components","providers","Array","isArray","length","serverProps","i18n","params","searchParams","server","undefined","children","loadLayoutData"],"mappings":"AAIA,SAASA,aAAa,QAAQ,uCAAsC;AACpE,SAASC,iBAAiB,QAAQ,gDAA+C;AACjF,SAASC,MAAM,QAAQ,yBAAwB;AAC/C,SAASC,qBAAqB,QAAQ,4BAA2B;AACjE,SAASC,aAAa,QAAQ,QAAO;AAIrC,SAASC,gBAAgB,QAAQ,6CAA4C;AAC7E,SAASC,cAAc,QAAQ,oCAAmC;AAclE,wEAAwE,GACxE,OAAO,eAAeC,cAAc,EAClCC,aAAa,EACbC,SAAS,EACS;IAClB,MAAMC,UAAU,MAAML,iBAAiB;QAAEG;QAAeC;IAAU;IAElE,MAAM,EAAEE,OAAO,EAAEC,WAAW,EAAEC,GAAG,EAAEC,IAAI,EAAE,GAAGJ;IAE5C,MAAMK,OAAO,MAAMd,kBAAkB;QACnCU;QACAF;QACAG;QACAC;QACAC;IACF;IAEA,MAAME,gBAAgBH,IAAII,OAAO,CAACC,MAAM,CAACC,KAAK,EAAEC,YAAYC;IAE5D,IAAIA;IAEJ,IAAIC,MAAMC,OAAO,CAACP,kBAAkBA,cAAcQ,MAAM,GAAG,GAAG;QAC5D,MAAMC,cAA2B;YAC/BC,MAAMb,IAAIa,IAAI;YACdC,QAAQ,CAAC;YACTV,SAASJ,IAAII,OAAO;YACpBL;YACAgB,cAAc,CAAC;YACfC,QAAQhB,IAAIgB,MAAM;YAClBf,MAAMA,QAAQgB;QAChB;QAEAT,YAAYjB,cAAcJ,eAAe;YACvC+B,UAAU3B,cAAcF;YACxBO;YACAY,WAAWL;YACXS;QACF;IACF;IAEA,OAAO;QAAE,GAAGV,IAAI;QAAEM;IAAU;AAC9B;AAEA;;;;;;;;CAQC,GACD,OAAO,eAAeW,eAAe,EACnCd,MAAM,EACNT,SAAS,EAIV;IACC,MAAM,EAAEY,SAAS,EAAE,GAAGN,MAAM,GAAG,MAAMR,cAAc;QAAEC,eAAeU;QAAQT;IAAU;IAEtF,OAAOH,eAAeS,MAAM;QAC1BM,WAAWA,YAAY,MAAMlB,sBAAsBkB,aAAoBS;IACzE;AACF"}

package/dist/adapters/metadata.d.ts

@@ -0,0 +1,80 @@
+import type { MetaConfig } from 'payload';
+type MetaEntry = {
+    charSet: string;
+} | {
+    content: string;
+    name: string;
+} | {
+    content: string;
+    property: string;
+} | {
+    title: string;
+};
+type LinkEntry = {
+    href: string;
+    media?: string;
+    rel: string;
+    sizes?: string;
+    type?: string;
+};
+type AdminPageIcon = {
+    media?: string;
+    rel?: string;
+    sizes?: string;
+    type?: string;
+    url: string;
+};
+type AdminPageOGImage = {
+    alt?: string;
+    height?: number;
+    url: string;
+    width?: number;
+};
+/**
+ * Resolved admin-page metadata produced by the admin-page server function.
+ *
+ * The server function resolves the framework-agnostic `MetaConfig` (via the
+ * shared `generatePageMetadata` in `@payloadcms/ui`) down to plain serializable
+ * values, so the route loader can ship it across the wire and feed it to
+ * `getAdminMeta` in `head()`.
+ */
+export type AdminPageMetadata = {
+    description?: string;
+    icons?: AdminPageIcon[];
+    keywords?: string;
+    openGraph?: {
+        description?: string;
+        images?: AdminPageOGImage[];
+        siteName?: string;
+        title?: string;
+    };
+    robots?: string;
+    title?: string;
+    viewport?: string;
+};
+/**
+ * Builds TanStack Router `head()` `meta` + `links` entries for an admin page
+ * from the resolved `AdminPageMetadata`, mirroring the tags Next.js renders
+ * natively from the same `MetaConfig` (title, description, robots, keywords,
+ * OpenGraph, Twitter — derived from OpenGraph — and icon links).
+ *
+ * ```ts
+ * export const Route = createFileRoute('/admin/$')({
+ *   head: ({ loaderData }) => getAdminMeta(loaderData?.metadata),
+ * })
+ * ```
+ */
+export declare function getAdminMeta(metadata?: AdminPageMetadata): {
+    links: LinkEntry[];
+    meta: MetaEntry[];
+};
+/**
+ * Flattens the framework-agnostic `MetaConfig` (Next.js `Metadata` shape) into
+ * the plain, serializable `AdminPageMetadata` the route loader ships to the
+ * client. The full `MetaConfig` carries a `URL` `metadataBase`, functions and
+ * other non-serializable values that seroval cannot cross the wire, so only the
+ * fields `getAdminMeta` renders are extracted.
+ */
+export declare const toAdminPageMetadata: (meta: MetaConfig) => AdminPageMetadata;
+export {};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/adapters/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/adapters/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAIzC,KAAK,SAAS,GACV;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACrC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAErB,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,KAAK,aAAa,GAAG;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,KAAK,gBAAgB,GAAG;IACtB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EAAE,aAAa,EAAE,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE;QACV,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,MAAM,CAAC,EAAE,gBAAgB,EAAE,CAAA;QAC3B,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,CAAA;IACD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,CAAC,EAAE,iBAAiB,GAAG;IAC1D,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,IAAI,EAAE,SAAS,EAAE,CAAA;CAClB,CA0EA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,SAAU,UAAU,KAAG,iBAkEtD,CAAA"}