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

package/dist/adapters/router.js

@@ -0,0 +1,183 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RouterAdapterContext, useRouteTransition } from '@payloadcms/ui';
+import { createLink, useLocation, useParams, useRouter, useRouterState } from '@tanstack/react-router';
+import * as qs from 'qs-esm';
+import React, { useCallback, useEffect, useMemo } from 'react';
+const TanStackLink = createLink(function Link({ ariaCurrent, children, ...props }) {
+    return /*#__PURE__*/ _jsx("a", {
+        ...props,
+        "aria-current": ariaCurrent ?? props['aria-current'],
+        children: children
+    });
+});
+const normalizeNavigationTarget = ({ path, pathname, search })=>{
+    if (path.startsWith('http')) {
+        const url = new URL(path);
+        return `${url.pathname}${url.search}${url.hash}`;
+    }
+    if (path.startsWith('?')) {
+        return `${pathname}${path}`;
+    }
+    if (path.startsWith('#')) {
+        return `${pathname}${search}${path}`;
+    }
+    return path;
+};
+// Mirror Next.js' router behavior to allow syncing client state to the URL without triggering a second server load.
+// TanStack's browser history monkeypatches `window.history.replaceState` and notifies `router.load` on every call.
+// Use `_ignoreSubscribers` to suppresses that notification — the same flag TanStack uses internally when flushing history.
+// This lives outside the component because React Compiler doesn't allow changing a value returned by a hook.
+const replaceStateWithoutLoad = ({ history, url })=>{
+    history._ignoreSubscribers = true;
+    try {
+        window.history.replaceState(null, '', url);
+    } finally{
+        history._ignoreSubscribers = false;
+    }
+};
+const TanStackLinkAdapter = ({ children, href, prefetch, ref, replace, scroll, ...rest })=>{
+    return /*#__PURE__*/ _jsx(TanStackLink, {
+        ariaCurrent: rest['aria-current'],
+        preload: prefetch === false ? false : 'intent',
+        ref: ref,
+        replace: replace,
+        resetScroll: scroll,
+        to: href,
+        ...rest,
+        children: children
+    });
+};
+export const TanStackRouterAdapter = ({ children })=>{
+    const router = useRouter();
+    const location = useLocation();
+    const params = useParams({
+        strict: false
+    });
+    const isRouterLoading = useRouterState({
+        select: (state)=>state.isLoading
+    });
+    const { holdRouteTransition } = useRouteTransition();
+    useEffect(()=>{
+        if (!isRouterLoading) {
+            return;
+        }
+        const releaseRouteTransition = holdRouteTransition();
+        return ()=>releaseRouteTransition();
+    }, [
+        holdRouteTransition,
+        isRouterLoading
+    ]);
+    const adaptedParams = useMemo(()=>{
+        const adapted = {
+            ...params
+        };
+        if ('_splat' in params && typeof params._splat === 'string') {
+            adapted.segments = params._splat.split('/').filter(Boolean);
+        }
+        return adapted;
+    }, [
+        params
+    ]);
+    // Split a target into `to` (pathname) + a parsed `search` object, so the
+    // router serializes the query via its `stringifySearch` (qs, bracket-encoded)
+    // rather than embedding the raw string in `to`. Navigating with a string `to`
+    // leaves the search *unencoded* in `window.location.search`
+    // (e.g. `where[or][0]…`), which then never matches Payload's `qs.stringify`
+    // output (`where%5Bor%5D…`) — breaking the list-view `syncPropsToURL` guard,
+    // which compares the two and would otherwise clobber optimistic query state
+    // (e.g. an in-progress filter condition) on every navigation.
+    const toNavOptions = useCallback((path)=>{
+        const relativePath = normalizeNavigationTarget({
+            path,
+            pathname: window.location.pathname,
+            search: window.location.search
+        });
+        const queryIndex = relativePath.indexOf('?');
+        if (queryIndex === -1) {
+            return {
+                to: relativePath
+            };
+        }
+        const searchObject = qs.parse(relativePath.slice(queryIndex + 1), {
+            depth: 10,
+            ignoreQueryPrefix: true
+        });
+        // Function form replaces the search entirely (no merge with current search).
+        return {
+            search: ()=>searchObject,
+            to: relativePath.slice(0, queryIndex)
+        };
+    }, []);
+    const back = useCallback(()=>router.history.back(), [
+        router
+    ]);
+    const push = useCallback((path, options)=>{
+        void router.navigate({
+            ...toNavOptions(path),
+            resetScroll: options?.scroll
+        });
+    }, [
+        router,
+        toNavOptions
+    ]);
+    const refresh = useCallback(()=>{
+        void router.invalidate();
+    }, [
+        router
+    ]);
+    const replace = useCallback((path, options)=>{
+        return router.navigate({
+            ...toNavOptions(path),
+            replace: true,
+            resetScroll: options?.scroll
+        });
+    }, [
+        router,
+        toNavOptions
+    ]);
+    const replaceState = useCallback((url)=>replaceStateWithoutLoad({
+            history: router.history,
+            url
+        }), [
+        router
+    ]);
+    const adaptedRouter = useMemo(()=>({
+            back,
+            push,
+            refresh,
+            replace,
+            replaceState
+        }), [
+        back,
+        push,
+        refresh,
+        replace,
+        replaceState
+    ]);
+    // `location.searchStr` is the serialized query string; `location.search` is
+    // the parsed object (a nested structure once the router uses `qs` for search
+    // serialization), which `URLSearchParams` cannot consume. Build from the
+    // string so Payload's `parseSearchParams` re-parses the bracket notation.
+    const searchParams = useMemo(()=>new URLSearchParams(location.searchStr), [
+        location.searchStr
+    ]);
+    const value = useMemo(()=>({
+            Link: TanStackLinkAdapter,
+            params: adaptedParams,
+            pathname: location.pathname,
+            router: adaptedRouter,
+            searchParams
+        }), [
+        adaptedParams,
+        location.pathname,
+        adaptedRouter,
+        searchParams
+    ]);
+    return /*#__PURE__*/ _jsx(RouterAdapterContext, {
+        value: value,
+        children: children
+    });
+};
+
+//# sourceMappingURL=router.js.map

package/dist/adapters/router.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/router.tsx"],"sourcesContent":["'use client'\n\nimport type { RouterAdapterContextValue } from '@payloadcms/ui/providers/RouterAdapter'\nimport type { LinkAdapterProps, RouterAdapterComponent } from 'payload'\n\nimport { RouterAdapterContext, useRouteTransition } from '@payloadcms/ui'\nimport {\n  createLink,\n  useLocation,\n  useParams,\n  useRouter,\n  useRouterState,\n} from '@tanstack/react-router'\nimport * as qs from 'qs-esm'\nimport React, { useCallback, useEffect, useMemo } from 'react'\n\ntype LinkProps = {\n  ariaCurrent?: React.AriaAttributes['aria-current']\n} & React.ComponentPropsWithRef<'a'>\n\nconst TanStackLink = createLink(function Link({ ariaCurrent, children, ...props }: LinkProps) {\n  return (\n    <a {...props} aria-current={ariaCurrent ?? props['aria-current']}>\n      {children}\n    </a>\n  )\n})\n\nconst normalizeNavigationTarget = ({\n  path,\n  pathname,\n  search,\n}: {\n  path: string\n  pathname: string\n  search: string\n}) => {\n  if (path.startsWith('http')) {\n    const url = new URL(path)\n    return `${url.pathname}${url.search}${url.hash}`\n  }\n\n  if (path.startsWith('?')) {\n    return `${pathname}${path}`\n  }\n\n  if (path.startsWith('#')) {\n    return `${pathname}${search}${path}`\n  }\n\n  return path\n}\n\n// Mirror Next.js' router behavior to allow syncing client state to the URL without triggering a second server load.\n// TanStack's browser history monkeypatches `window.history.replaceState` and notifies `router.load` on every call.\n// Use `_ignoreSubscribers` to suppresses that notification — the same flag TanStack uses internally when flushing history.\n// This lives outside the component because React Compiler doesn't allow changing a value returned by a hook.\nconst replaceStateWithoutLoad = ({\n  history,\n  url,\n}: {\n  history: ReturnType<typeof useRouter>['history']\n  url: string\n}) => {\n  history._ignoreSubscribers = true\n\n  try {\n    window.history.replaceState(null, '', url)\n  } finally {\n    history._ignoreSubscribers = false\n  }\n}\n\nconst TanStackLinkAdapter: React.FC<LinkAdapterProps> = ({\n  children,\n  href,\n  prefetch,\n  ref,\n  replace,\n  scroll,\n  ...rest\n}) => {\n  return (\n    <TanStackLink\n      ariaCurrent={rest['aria-current']}\n      preload={prefetch === false ? false : 'intent'}\n      ref={ref}\n      replace={replace}\n      resetScroll={scroll}\n      to={href}\n      {...rest}\n    >\n      {children}\n    </TanStackLink>\n  )\n}\n\nexport const TanStackRouterAdapter: RouterAdapterComponent = ({ children }) => {\n  const router = useRouter()\n  const location = useLocation()\n  const params = useParams({ strict: false })\n  const isRouterLoading = useRouterState({ select: (state) => state.isLoading })\n  const { holdRouteTransition } = useRouteTransition()\n\n  useEffect(() => {\n    if (!isRouterLoading) {\n      return\n    }\n\n    const releaseRouteTransition = holdRouteTransition()\n\n    return () => releaseRouteTransition()\n  }, [holdRouteTransition, isRouterLoading])\n\n  const adaptedParams = useMemo(() => {\n    const adapted: Record<string, string | string[]> = { ...params }\n\n    if ('_splat' in params && typeof params._splat === 'string') {\n      adapted.segments = params._splat.split('/').filter(Boolean)\n    }\n\n    return adapted\n  }, [params])\n\n  // Split a target into `to` (pathname) + a parsed `search` object, so the\n  // router serializes the query via its `stringifySearch` (qs, bracket-encoded)\n  // rather than embedding the raw string in `to`. Navigating with a string `to`\n  // leaves the search *unencoded* in `window.location.search`\n  // (e.g. `where[or][0]…`), which then never matches Payload's `qs.stringify`\n  // output (`where%5Bor%5D…`) — breaking the list-view `syncPropsToURL` guard,\n  // which compares the two and would otherwise clobber optimistic query state\n  // (e.g. an in-progress filter condition) on every navigation.\n  const toNavOptions = useCallback((path: string) => {\n    const relativePath = normalizeNavigationTarget({\n      path,\n      pathname: window.location.pathname,\n      search: window.location.search,\n    })\n\n    const queryIndex = relativePath.indexOf('?')\n\n    if (queryIndex === -1) {\n      return { to: relativePath }\n    }\n\n    const searchObject = qs.parse(relativePath.slice(queryIndex + 1), {\n      depth: 10,\n      ignoreQueryPrefix: true,\n    })\n\n    // Function form replaces the search entirely (no merge with current search).\n    return { search: () => searchObject, to: relativePath.slice(0, queryIndex) }\n  }, [])\n\n  const back = useCallback(() => router.history.back(), [router])\n\n  const push = useCallback(\n    (path: string, options?: { scroll?: boolean }) => {\n      void router.navigate({ ...toNavOptions(path), resetScroll: options?.scroll })\n    },\n    [router, toNavOptions],\n  )\n\n  const refresh = useCallback(() => {\n    void router.invalidate()\n  }, [router])\n\n  const replace = useCallback(\n    (path: string, options?: { scroll?: boolean }) => {\n      return router.navigate({ ...toNavOptions(path), replace: true, resetScroll: options?.scroll })\n    },\n    [router, toNavOptions],\n  )\n\n  const replaceState = useCallback(\n    (url: string) => replaceStateWithoutLoad({ history: router.history, url }),\n    [router],\n  )\n\n  const adaptedRouter = useMemo(\n    () => ({ back, push, refresh, replace, replaceState }),\n    [back, push, refresh, replace, replaceState],\n  )\n\n  // `location.searchStr` is the serialized query string; `location.search` is\n  // the parsed object (a nested structure once the router uses `qs` for search\n  // serialization), which `URLSearchParams` cannot consume. Build from the\n  // string so Payload's `parseSearchParams` re-parses the bracket notation.\n  const searchParams = useMemo(() => new URLSearchParams(location.searchStr), [location.searchStr])\n\n  const value: RouterAdapterContextValue = useMemo(\n    () => ({\n      Link: TanStackLinkAdapter,\n      params: adaptedParams,\n      pathname: location.pathname,\n      router: adaptedRouter,\n      searchParams,\n    }),\n    [adaptedParams, location.pathname, adaptedRouter, searchParams],\n  )\n\n  return <RouterAdapterContext value={value}>{children}</RouterAdapterContext>\n}\n"],"names":["RouterAdapterContext","useRouteTransition","createLink","useLocation","useParams","useRouter","useRouterState","qs","React","useCallback","useEffect","useMemo","TanStackLink","Link","ariaCurrent","children","props","a","aria-current","normalizeNavigationTarget","path","pathname","search","startsWith","url","URL","hash","replaceStateWithoutLoad","history","_ignoreSubscribers","window","replaceState","TanStackLinkAdapter","href","prefetch","ref","replace","scroll","rest","preload","resetScroll","to","TanStackRouterAdapter","router","location","params","strict","isRouterLoading","select","state","isLoading","holdRouteTransition","releaseRouteTransition","adaptedParams","adapted","_splat","segments","split","filter","Boolean","toNavOptions","relativePath","queryIndex","indexOf","searchObject","parse","slice","depth","ignoreQueryPrefix","back","push","options","navigate","refresh","invalidate","adaptedRouter","searchParams","URLSearchParams","searchStr","value"],"mappings":"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"}

package/dist/{utilities/serverAdapter.server.d.ts → adapters/server.d.ts}

@@ -33,4 +33,4 @@ export type PageNavIntent = {
  * nav at the loader boundary.
  */
 export declare const createPageRenderServerAdapter: (nav: PageNavIntent) => ServerAdapter;
-//# sourceMappingURL=serverAdapter.server.d.ts.map
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/adapters/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,SAAS,CAAA;AAoBzD;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,aA4CnC,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,CAAC,EAAE,UAAU,GAAG,UAAU,CAAA;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,6BAA6B,QAAS,aAAa,KAAG,aAgBjE,CAAA"}

package/dist/{utilities/serverAdapter.server.js → adapters/server.js}

@@ -1,5 +1,5 @@
 import { notFound, redirect } from '@tanstack/react-router';
-import { getRequest, setResponseHeader } from '@tanstack/react-start/server';
+import { getRequest, setCookie as setResponseCookie } from '@tanstack/react-start/server';
 import { parseCookies } from 'payload';
 function buildCookieStore(headers) {
     const cookies = parseCookies(headers);
@@ -19,31 +19,6 @@ function buildCookieStore(headers) {
         }
     };
 }
-function serializeCookie(name, value, options) {
-    let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-    if (options?.path) {
-        cookie += `; Path=${options.path}`;
-    }
-    if (options?.domain) {
-        cookie += `; Domain=${options.domain}`;
-    }
-    if (options?.maxAge !== undefined) {
-        cookie += `; Max-Age=${options.maxAge}`;
-    }
-    if (options?.expires) {
-        cookie += `; Expires=${options.expires.toUTCString()}`;
-    }
-    if (options?.httpOnly) {
-        cookie += '; HttpOnly';
-    }
-    if (options?.secure) {
-        cookie += '; Secure';
-    }
-    if (options?.sameSite) {
-        cookie += `; SameSite=${options.sameSite.charAt(0).toUpperCase() + options.sameSite.slice(1)}`;
-    }
-    return cookie;
-}
 /**
  * Server-side adapter for TanStack Start.
  * Uses `@tanstack/react-start/server` utilities for request/response handling.
@@ -87,9 +62,7 @@ function serializeCookie(name, value, options) {
         // a generic error so the request boundary still terminates the request.
         throw new Error('Unauthorized');
     },
-    setCookie: (name, value, options)=>{
-        setResponseHeader('Set-Cookie', serializeCookie(name, value, options));
-    }
+    setCookie: setResponseCookie
 };
 /**
  * Builds the `ServerAdapter` for the admin page render (`renderRoot`). Like
@@ -127,4 +100,4 @@ function serializeCookie(name, value, options) {
         }
     });
 
-//# sourceMappingURL=serverAdapter.server.js.map
+//# sourceMappingURL=server.js.map

package/dist/adapters/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/server.ts"],"sourcesContent":["import type { CookieStore, ServerAdapter } from 'payload'\n\nimport { notFound, redirect } from '@tanstack/react-router'\nimport { getRequest, setCookie as setResponseCookie } from '@tanstack/react-start/server'\nimport { parseCookies } from 'payload'\n\nfunction buildCookieStore(headers: Headers): CookieStore {\n  const cookies = parseCookies(headers)\n\n  return {\n    get: (name: string) => {\n      const value = cookies.get(name)\n      return value !== undefined ? { name, value } : undefined\n    },\n    getAll: () => {\n      return Array.from(cookies.entries()).map(([name, value]) => ({ name, value }))\n    },\n  }\n}\n\n/**\n * Server-side adapter for TanStack Start.\n * Uses `@tanstack/react-start/server` utilities for request/response handling.\n */\nexport const tanstackServerAdapter: ServerAdapter = {\n  getCookies: () => {\n    const request = getRequest()\n    const headers = new Headers(request.headers)\n    return buildCookieStore(headers)\n  },\n\n  getHeaders: () => {\n    const request = getRequest()\n    return new Headers(request.headers)\n  },\n\n  notFound: () => {\n    // TanStack Router requires throwing the notFound() result directly\n    // eslint-disable-next-line @typescript-eslint/only-throw-error\n    throw notFound()\n  },\n\n  redirect: (path: string) => {\n    // TanStack Router requires throwing the redirect() result directly\n    // eslint-disable-next-line @typescript-eslint/only-throw-error\n    throw redirect({ to: path })\n  },\n\n  permanentRedirect: (path: string) => {\n    // TanStack Router does not have a separate permanent redirect primitive;\n    // fall back to a regular redirect so existing behavior is preserved.\n    // eslint-disable-next-line @typescript-eslint/only-throw-error\n    throw redirect({ to: path })\n  },\n\n  forbidden: () => {\n    // TanStack Router does not have a dedicated forbidden() helper; surface\n    // a generic error so the request boundary still terminates the request.\n    throw new Error('Forbidden')\n  },\n\n  unauthorized: () => {\n    // TanStack Router does not have a dedicated unauthorized() helper; surface\n    // a generic error so the request boundary still terminates the request.\n    throw new Error('Unauthorized')\n  },\n\n  setCookie: setResponseCookie,\n}\n\n/**\n * Navigation requested during an admin page render, recorded by\n * `createPageRenderServerAdapter`. The admin-page server function reads this\n * after `renderServerComponent` resolves.\n */\nexport type PageNavIntent = {\n  type?: 'notFound' | 'redirect'\n  url?: string\n}\n\n/**\n * Builds the `ServerAdapter` for the admin page render (`renderRoot`). Like\n * `tanstackServerAdapter` for cookies/headers, but navigation **records the\n * intent on `nav` and throws** the framework-agnostic string error-contract\n * (`Error('not-found')` / `Error('redirect:<url>')`) instead of TanStack's\n * native `notFound`/`redirect`.\n *\n * `renderRoot` navigates via `req.server.*` in two places:\n * - during orchestration (e.g. the unauthenticated login redirect) — the throw\n *   propagates out of `renderRoot` and is caught by the loader's try/catch;\n * - deep inside streamed view components (e.g. `DocumentView` access checks,\n *   `LoginView` already-authenticated) — here the throw happens during\n *   `renderServerComponent` and is swallowed into the RSC stream, so it never\n *   rejects the render promise.\n *\n * Recording the intent on `nav` lets the loader honor the second case by\n * inspecting `nav` after the render resolves, then re-throwing native TanStack\n * nav at the loader boundary.\n */\nexport const createPageRenderServerAdapter = (nav: PageNavIntent): ServerAdapter => ({\n  ...tanstackServerAdapter,\n  notFound: () => {\n    nav.type = 'notFound'\n    throw new Error('not-found')\n  },\n  permanentRedirect: (path: string) => {\n    nav.type = 'redirect'\n    nav.url = path\n    throw new Error(`redirect:${path}`)\n  },\n  redirect: (path: string) => {\n    nav.type = 'redirect'\n    nav.url = path\n    throw new Error(`redirect:${path}`)\n  },\n})\n"],"names":["notFound","redirect","getRequest","setCookie","setResponseCookie","parseCookies","buildCookieStore","headers","cookies","get","name","value","undefined","getAll","Array","from","entries","map","tanstackServerAdapter","getCookies","request","Headers","getHeaders","path","to","permanentRedirect","forbidden","Error","unauthorized","createPageRenderServerAdapter","nav","type","url"],"mappings":"AAEA,SAASA,QAAQ,EAAEC,QAAQ,QAAQ,yBAAwB;AAC3D,SAASC,UAAU,EAAEC,aAAaC,iBAAiB,QAAQ,+BAA8B;AACzF,SAASC,YAAY,QAAQ,UAAS;AAEtC,SAASC,iBAAiBC,OAAgB;IACxC,MAAMC,UAAUH,aAAaE;IAE7B,OAAO;QACLE,KAAK,CAACC;YACJ,MAAMC,QAAQH,QAAQC,GAAG,CAACC;YAC1B,OAAOC,UAAUC,YAAY;gBAAEF;gBAAMC;YAAM,IAAIC;QACjD;QACAC,QAAQ;YACN,OAAOC,MAAMC,IAAI,CAACP,QAAQQ,OAAO,IAAIC,GAAG,CAAC,CAAC,CAACP,MAAMC,MAAM,GAAM,CAAA;oBAAED;oBAAMC;gBAAM,CAAA;QAC7E;IACF;AACF;AAEA;;;CAGC,GACD,OAAO,MAAMO,wBAAuC;IAClDC,YAAY;QACV,MAAMC,UAAUlB;QAChB,MAAMK,UAAU,IAAIc,QAAQD,QAAQb,OAAO;QAC3C,OAAOD,iBAAiBC;IAC1B;IAEAe,YAAY;QACV,MAAMF,UAAUlB;QAChB,OAAO,IAAImB,QAAQD,QAAQb,OAAO;IACpC;IAEAP,UAAU;QACR,mEAAmE;QACnE,+DAA+D;QAC/D,MAAMA;IACR;IAEAC,UAAU,CAACsB;QACT,mEAAmE;QACnE,+DAA+D;QAC/D,MAAMtB,SAAS;YAAEuB,IAAID;QAAK;IAC5B;IAEAE,mBAAmB,CAACF;QAClB,yEAAyE;QACzE,qEAAqE;QACrE,+DAA+D;QAC/D,MAAMtB,SAAS;YAAEuB,IAAID;QAAK;IAC5B;IAEAG,WAAW;QACT,wEAAwE;QACxE,wEAAwE;QACxE,MAAM,IAAIC,MAAM;IAClB;IAEAC,cAAc;QACZ,2EAA2E;QAC3E,wEAAwE;QACxE,MAAM,IAAID,MAAM;IAClB;IAEAxB,WAAWC;AACb,EAAC;AAYD;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,MAAMyB,gCAAgC,CAACC,MAAuC,CAAA;QACnF,GAAGZ,qBAAqB;QACxBlB,UAAU;YACR8B,IAAIC,IAAI,GAAG;YACX,MAAM,IAAIJ,MAAM;QAClB;QACAF,mBAAmB,CAACF;YAClBO,IAAIC,IAAI,GAAG;YACXD,IAAIE,GAAG,GAAGT;YACV,MAAM,IAAII,MAAM,CAAC,SAAS,EAAEJ,MAAM;QACpC;QACAtB,UAAU,CAACsB;YACTO,IAAIC,IAAI,GAAG;YACXD,IAAIE,GAAG,GAAGT;YACV,MAAM,IAAII,MAAM,CAAC,SAAS,EAAEJ,MAAM;QACpC;IACF,CAAA,EAAE"}

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

@@ -0,0 +1,107 @@
+/**
+ * Loader supplied by the app — a TanStack Start `createServerFn` that delegates
+ * to `loadAdminPage`. Typed loosely because the server-fn's call signature is
+ * generated by the Start compiler.
+ */
+export type AdminLoad = (opts: {
+    data: {
+        _splat: string;
+        search: Record<string, string | string[]>;
+    };
+    signal?: AbortSignal;
+}) => Promise<any>;
+/**
+ * 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 declare function payloadAdminSplatRoute({ load }: {
+    load: AdminLoad;
+}): {
+    component: import("@tanstack/react-router").AsyncRouteComponent<unknown>;
+    head: ({ loaderData }: {
+        loaderData?: any;
+    }) => {
+        links: {
+            href: string;
+            media?: string;
+            rel: string;
+            sizes?: string;
+            type?: string;
+        }[];
+        meta: ({
+            charSet: string;
+        } | {
+            content: string;
+            name: string;
+        } | {
+            content: string;
+            property: string;
+        } | {
+            title: string;
+        })[];
+    };
+    notFoundComponent: import("@tanstack/react-router").AsyncRouteComponent<import("@tanstack/react-router").NotFoundRouteProps>;
+    loader: {
+        handler: ({ abortController, location, params, }: {
+            abortController: AbortController;
+            location: any;
+            params: any;
+        }) => Promise<any>;
+        staleReloadMode: 'blocking';
+    };
+    loaderDeps: ({ search }: {
+        search: Record<string, unknown>;
+    }) => {
+        searchKey: string;
+    };
+    validateSearch: (search: Record<string, unknown>) => Record<string, unknown>;
+};
+/**
+ * Route options for the admin index route (`/_payload/admin/`). Not-found
+ * results omit the RSC payload and fall back to `NotFoundClient`.
+ */
+export declare function payloadAdminIndexRoute({ load }: {
+    load: AdminLoad;
+}): {
+    component: import("@tanstack/react-router").AsyncRouteComponent<unknown>;
+    head: ({ loaderData }: {
+        loaderData?: any;
+    }) => {
+        links: {
+            href: string;
+            media?: string;
+            rel: string;
+            sizes?: string;
+            type?: string;
+        }[];
+        meta: ({
+            charSet: string;
+        } | {
+            content: string;
+            name: string;
+        } | {
+            content: string;
+            property: string;
+        } | {
+            title: string;
+        })[];
+    };
+    notFoundComponent: import("@tanstack/react-router").AsyncRouteComponent<import("@tanstack/react-router").NotFoundRouteProps>;
+    loader: {
+        handler: ({ abortController, location, params, }: {
+            abortController: AbortController;
+            location: any;
+            params: any;
+        }) => Promise<any>;
+        staleReloadMode: 'blocking';
+    };
+    loaderDeps: ({ search }: {
+        search: Record<string, unknown>;
+    }) => {
+        searchKey: string;
+    };
+    validateSearch: (search: Record<string, unknown>) => Record<string, unknown>;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/views/index.tsx"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE;IAC7B,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAA;KAAE,CAAA;IACnE,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;AA6GlB;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE;;2BAlD3C;QAAE,UAAU,CAAC,EAAE,GAAG,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;QAUzC,OAAO,2CAIJ;YACD,eAAe,EAAE,eAAe,CAAA;YAChC,QAAQ,EAAE,GAAG,CAAA;YACb,MAAM,EAAE,GAAG,CAAA;SACZ;QAiBD,eAAe,EAAE,UAAU;;6BAGJ;QAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE;QAC1D,SAAS;;6BAEc,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;EAejD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE;;2BA9D3C;QAAE,UAAU,CAAC,EAAE,GAAG,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;QAUzC,OAAO,2CAIJ;YACD,eAAe,EAAE,eAAe,CAAA;YAChC,QAAQ,EAAE,GAAG,CAAA;YACb,MAAM,EAAE,GAAG,CAAA;SACZ;QAiBD,eAAe,EAAE,UAAU;;6BAGJ;QAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE;QAC1D,SAAS;;6BAEc,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;EA2BjD"}

package/dist/adapters/views/index.js

@@ -0,0 +1,101 @@
+'use client';
+import { lazyRouteComponent, notFound, redirect } from '@tanstack/react-router';
+import { getAdminMeta } from '../metadata.js';
+const searchToRecord = (searchStr)=>Object.fromEntries(new URLSearchParams(searchStr));
+const runLoader = async ({ load, searchStr, signal, splat })=>{
+    const loadController = new AbortController();
+    const abortLoad = ()=>loadController.abort(signal.reason);
+    signal.addEventListener('abort', abortLoad, {
+        once: true
+    });
+    if (signal.aborted) {
+        abortLoad();
+    }
+    let data;
+    try {
+        data = await load({
+            data: {
+                _splat: splat,
+                search: searchToRecord(searchStr)
+            },
+            signal: loadController.signal
+        });
+    } finally{
+        // The returned RSC payload can still be streaming after the loader resolves.
+        // Later navigations must not abort a payload that React is already rendering.
+        signal.removeEventListener('abort', abortLoad);
+    }
+    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;
+};
+// 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 AdminPage = lazyRouteComponent(()=>import('./lazy.js'), 'AdminPage');
+const AdminNotFound = lazyRouteComponent(()=>import('./lazy.js'), 'AdminNotFound');
+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 ({ abortController, location, params })=>{
+                const data = await runLoader({
+                    load,
+                    searchStr: location.searchStr,
+                    signal: abortController.signal,
+                    splat: resolveSplat(params)
+                });
+                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=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/views/index.tsx"],"sourcesContent":["'use client'\n\nimport { lazyRouteComponent, notFound, redirect } from '@tanstack/react-router'\n\nimport { getAdminMeta } from '../metadata.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  signal?: AbortSignal\n}) => Promise<any>\n\nconst searchToRecord = (searchStr: string): Record<string, string | string[]> =>\n  Object.fromEntries(new URLSearchParams(searchStr))\n\nconst runLoader = async ({\n  load,\n  searchStr,\n  signal,\n  splat,\n}: {\n  load: AdminLoad\n  searchStr: string\n  signal: AbortSignal\n  splat: string\n}) => {\n  const loadController = new AbortController()\n  const abortLoad = () => loadController.abort(signal.reason)\n\n  signal.addEventListener('abort', abortLoad, { once: true })\n\n  if (signal.aborted) {\n    abortLoad()\n  }\n\n  let data: Awaited<ReturnType<AdminLoad>>\n\n  try {\n    data = await load({\n      data: { _splat: splat, search: searchToRecord(searchStr) },\n      signal: loadController.signal,\n    })\n  } finally {\n    // The returned RSC payload can still be streaming after the loader resolves.\n    // Later navigations must not abort a payload that React is already rendering.\n    signal.removeEventListener('abort', abortLoad)\n  }\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\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 AdminPage = lazyRouteComponent(() => import('./lazy.js'), 'AdminPage')\nconst AdminNotFound = lazyRouteComponent(() => import('./lazy.js'), 'AdminNotFound')\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 ({\n      abortController,\n      location,\n      params,\n    }: {\n      abortController: AbortController\n      location: any\n      params: any\n    }) => {\n      const data = await runLoader({\n        load,\n        searchStr: location.searchStr,\n        signal: abortController.signal,\n        splat: resolveSplat(params),\n      })\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":["lazyRouteComponent","notFound","redirect","getAdminMeta","searchToRecord","searchStr","Object","fromEntries","URLSearchParams","runLoader","load","signal","splat","loadController","AbortController","abortLoad","abort","reason","addEventListener","once","aborted","data","_splat","search","removeEventListener","_redirect","to","AdminPage","AdminNotFound","adminRouteOptions","forwardNotFoundPayload","resolveSplat","component","head","loaderData","metadata","notFoundComponent","loader","handler","abortController","location","params","_notFound","routeKey","rscPayload","undefined","staleReloadMode","loaderDeps","searchKey","JSON","stringify","validateSearch","payloadAdminSplatRoute","payloadAdminIndexRoute"],"mappings":"AAAA;AAEA,SAASA,kBAAkB,EAAEC,QAAQ,EAAEC,QAAQ,QAAQ,yBAAwB;AAE/E,SAASC,YAAY,QAAQ,iBAAgB;AAY7C,MAAMC,iBAAiB,CAACC,YACtBC,OAAOC,WAAW,CAAC,IAAIC,gBAAgBH;AAEzC,MAAMI,YAAY,OAAO,EACvBC,IAAI,EACJL,SAAS,EACTM,MAAM,EACNC,KAAK,EAMN;IACC,MAAMC,iBAAiB,IAAIC;IAC3B,MAAMC,YAAY,IAAMF,eAAeG,KAAK,CAACL,OAAOM,MAAM;IAE1DN,OAAOO,gBAAgB,CAAC,SAASH,WAAW;QAAEI,MAAM;IAAK;IAEzD,IAAIR,OAAOS,OAAO,EAAE;QAClBL;IACF;IAEA,IAAIM;IAEJ,IAAI;QACFA,OAAO,MAAMX,KAAK;YAChBW,MAAM;gBAAEC,QAAQV;gBAAOW,QAAQnB,eAAeC;YAAW;YACzDM,QAAQE,eAAeF,MAAM;QAC/B;IACF,SAAU;QACR,6EAA6E;QAC7E,8EAA8E;QAC9EA,OAAOa,mBAAmB,CAAC,SAAST;IACtC;IACA,IAAIM,MAAMI,WAAW;QACnB,qHAAqH;QACrH,MAAMvB,SAAS;YAAEwB,IAAIL,KAAKI,SAAS;QAAC;IACtC;IACA,OAAOJ;AACT;AAEA,4FAA4F;AAC5F,sFAAsF;AACtF,MAAMM,YAAY3B,mBAAmB,IAAM,MAAM,CAAC,cAAc;AAChE,MAAM4B,gBAAgB5B,mBAAmB,IAAM,MAAM,CAAC,cAAc;AAEpE,MAAM6B,oBAAoB,CAAC,EACzBC,sBAAsB,EACtBpB,IAAI,EACJqB,YAAY,EAWb,GAAM,CAAA;QACLC,WAAWL;QACXM,MAAM,CAAC,EAAEC,UAAU,EAAwB,GAAK/B,aAAa+B,YAAYC;QACzE,qEAAqE;QACrE,mDAAmD;QACnDC,mBAAmBR;QACnB,0EAA0E;QAC1E,8EAA8E;QAC9E,2EAA2E;QAC3E,6EAA6E;QAC7E,4DAA4D;QAC5DS,QAAQ;YACNC,SAAS,OAAO,EACdC,eAAe,EACfC,QAAQ,EACRC,MAAM,EAKP;gBACC,MAAMpB,OAAO,MAAMZ,UAAU;oBAC3BC;oBACAL,WAAWmC,SAASnC,SAAS;oBAC7BM,QAAQ4B,gBAAgB5B,MAAM;oBAC9BC,OAAOmB,aAAaU;gBACtB;gBACA,IAAIpB,MAAMqB,WAAW;oBACnB,qHAAqH;oBACrH,MAAMzC,SACJ6B,yBACI;wBAAET,MAAM;4BAAEsB,UAAUtB,KAAKsB,QAAQ;4BAAEC,YAAYvB,KAAKuB,UAAU;wBAAC;oBAAE,IACjEC;gBAER;gBACA,OAAOxB;YACT;YACAyB,iBAAiB;QACnB;QACA,2EAA2E;QAC3EC,YAAY,CAAC,EAAExB,MAAM,EAAuC,GAAM,CAAA;gBAChEyB,WAAWC,KAAKC,SAAS,CAAC3B;YAC5B,CAAA;QACA4B,gBAAgB,CAAC5B,SAAoCA;IACvD,CAAA;AAEA;;;;;CAKC,GACD,OAAO,SAAS6B,uBAAuB,EAAE1C,IAAI,EAAuB;IAClE,OAAOmB,kBAAkB;QACvBC,wBAAwB;QACxBpB;QACAqB,cAAc,CAACU,SAAWA,OAAOnB,MAAM,IAAI;IAC7C;AACF;AAEA;;;CAGC,GACD,OAAO,SAAS+B,uBAAuB,EAAE3C,IAAI,EAAuB;IAClE,OAAOmB,kBAAkB;QACvBC,wBAAwB;QACxBpB;QACAqB,cAAc,IAAM;IACtB;AACF"}

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

@@ -0,0 +1,4 @@
+import type { NotFoundRouteProps } from '@tanstack/react-router';
+export declare function AdminPage(): import("react").JSX.Element;
+export declare function AdminNotFound({ data }: NotFoundRouteProps): import("react").JSX.Element;
+//# sourceMappingURL=lazy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../../src/adapters/views/lazy.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAMhE,wBAAgB,SAAS,gCAwBxB;AAID,wBAAgB,aAAa,CAAC,EAAE,IAAI,EAAE,EAAE,kBAAkB,+BAOzD"}

package/dist/adapters/views/lazy.js

@@ -0,0 +1,44 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { NotFoundClient, useRouteTransition } from '@payloadcms/ui';
+import { useLoaderData } from '@tanstack/react-router';
+import { Fragment, useDeferredValue, useLayoutEffect } from 'react';
+export 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;
+    // Register before the router acknowledges this commit so navigation can await the deferred view.
+    useLayoutEffect(()=>{
+        if (!isRscPayloadDeferred) {
+            return;
+        }
+        const releaseRouteTransition = holdRouteTransition();
+        return ()=>releaseRouteTransition();
+    }, [
+        holdRouteTransition,
+        isRscPayloadDeferred
+    ]);
+    return /*#__PURE__*/ _jsx(Fragment, {
+        children: rscPayload?.page
+    });
+}
+export 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.page
+    }, routeKey);
+}
+
+//# sourceMappingURL=lazy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/views/lazy.tsx"],"sourcesContent":["'use client'\n\nimport type { NotFoundRouteProps } from '@tanstack/react-router'\n\nimport { NotFoundClient, useRouteTransition } from '@payloadcms/ui'\nimport { useLoaderData } from '@tanstack/react-router'\nimport { Fragment, useDeferredValue, useLayoutEffect } from 'react'\n\nexport function 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  // Register before the router acknowledges this commit so navigation can await the deferred view.\n  useLayoutEffect(() => {\n    if (!isRscPayloadDeferred) {\n      return\n    }\n\n    const releaseRouteTransition = holdRouteTransition()\n\n    return () => releaseRouteTransition()\n  }, [holdRouteTransition, isRscPayloadDeferred])\n\n  return <Fragment>{rscPayload?.page}</Fragment>\n}\n\ntype AdminNotFoundData = { routeKey?: string; rscPayload?: { page: React.ReactNode } }\n\nexport function 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.page}</Fragment>\n}\n"],"names":["NotFoundClient","useRouteTransition","useLoaderData","Fragment","useDeferredValue","useLayoutEffect","AdminPage","data","strict","rscPayload","holdRouteTransition","isRscPayloadDeferred","releaseRouteTransition","page","AdminNotFound","routeKey"],"mappings":"AAAA;;AAIA,SAASA,cAAc,EAAEC,kBAAkB,QAAQ,iBAAgB;AACnE,SAASC,aAAa,QAAQ,yBAAwB;AACtD,SAASC,QAAQ,EAAEC,gBAAgB,EAAEC,eAAe,QAAQ,QAAO;AAEnE,OAAO,SAASC;IACd,+HAA+H;IAC/H,2HAA2H;IAC3H,MAAMC,OAAOL,cAAc;QAAEM,QAAQ;IAAM;IAE3C,+EAA+E;IAC/E,yEAAyE;IACzE,qEAAqE;IACrE,MAAMC,aAAaL,iBAAiBG,MAAME;IAC1C,MAAM,EAAEC,mBAAmB,EAAE,GAAGT;IAChC,MAAMU,uBAAuBF,eAAeF,MAAME;IAElD,iGAAiG;IACjGJ,gBAAgB;QACd,IAAI,CAACM,sBAAsB;YACzB;QACF;QAEA,MAAMC,yBAAyBF;QAE/B,OAAO,IAAME;IACf,GAAG;QAACF;QAAqBC;KAAqB;IAE9C,qBAAO,KAACR;kBAAUM,YAAYI;;AAChC;AAIA,OAAO,SAASC,cAAc,EAAEP,IAAI,EAAsB;IACxD,+FAA+F;IAC/F,MAAM,EAAEQ,QAAQ,EAAEN,UAAU,EAAE,GAAIF,QAAQ,CAAC;IAC3C,IAAI,CAACE,YAAY;QACf,qBAAO,KAACT;IACV;IACA,qBAAO,KAACG;kBAAyBM,WAAWI,IAAI;OAA1BE;AACxB"}

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

@@ -0,0 +1,60 @@
+import type { RenderableServerComponentBuilder } from '@tanstack/react-start/rsc';
+import type { ImportMap, SanitizedConfig } from 'payload';
+import type { AdminPageMetadata } from '../metadata.js';
+export type LoadAdminPageArgs = {
+    config: SanitizedConfig;
+    importMap: ImportMap;
+    search?: Record<string, string | string[]>;
+    splat?: string;
+};
+type RSCPayload = RenderableServerComponentBuilder<{
+    page: React.ReactElement;
+    routeKey: string;
+}>;
+export type LoadAdminPageResult = {
+    _notFound: true;
+    routeKey?: string;
+    rscPayload?: RSCPayload;
+} | {
+    _redirect: string;
+} | {
+    metadata: AdminPageMetadata;
+    /**
+     * Stable identity for this rendered route (the splat, i.e. the path
+     * after `/admin/`). The client keys the rendered subtree by this so the
+     * view remounts exactly when a new payload arrives. Keying by
+     * `location.pathname` instead races: the pathname updates before
+     * `useLoaderData()` during a transition, so the subtree would remount
+     * with the *previous* payload and then reconcile the fresh payload in
+     * place — leaving client providers (DocumentInfo, etc.) holding stale
+     * `useState` values from the prior document. Search params are excluded
+     * so search-only changes (e.g. list-view filtering) reconcile in place.
+     */
+    routeKey: string;
+    rscPayload: RSCPayload;
+};
+/**
+ * Renders an admin page for TanStack Start and returns a serializable loader
+ * result. The framework adapter wraps this in a `createServerFn` that supplies
+ * the app's `config` and generated `importMap`.
+ *
+ *   1. Gets the Payload admin context via the shared `renderRoot` orchestrator
+ *      from `@payloadcms/ui`, passing a TanStack-bound `initAdminContext`. The injected
+ *      page-render `ServerAdapter` records navigation intent and throws the
+ *      framework-agnostic error contract.
+ *   2. Pipes the resulting React server tree through `renderServerComponent`
+ *      to produce a Flight payload the client consumes directly.
+ *   3. Resolves page metadata via the same shared `generatePageMetadata`
+ *      Next.js uses, returning plain serializable strings for `head()`.
+ *
+ * Navigation surfaces two ways and both become a `_notFound` / `_redirect`
+ * sentinel the route loader re-throws as native TanStack nav:
+ * - thrown during `renderRoot` orchestration (e.g. the login redirect) → caught
+ *   by the try/catch below;
+ * - thrown deep inside a streamed view component (e.g. `DocumentView` access
+ *   denied, `LoginView` already-authenticated) → swallowed into the RSC stream,
+ *   so it's read from the `nav` holder after `renderServerComponent` resolves.
+ */
+export declare function loadAdminPage({ config, importMap, search, splat, }: LoadAdminPageArgs): Promise<LoadAdminPageResult>;
+export {};
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/adapters/views/server.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,2BAA2B,CAAA;AACjF,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAMzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAOvD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,eAAe,CAAA;IACvB,SAAS,EAAE,SAAS,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAA;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,KAAK,UAAU,GAAG,gCAAgC,CAAC;IACjD,IAAI,EAAE,KAAK,CAAC,YAAY,CAAA;IACxB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAC3B;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,UAAU,CAAA;CAAE,GAC/D;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GACrB;IACE,QAAQ,EAAE,iBAAiB,CAAA;IAC3B;;;;;;;;;;OAUG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAEL;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,aAAa,CAAC,EAClC,MAAM,EACN,SAAS,EACT,MAAM,EACN,KAAK,GACN,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAyJlD"}