@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

package/dist/esm/runtime/plugin.node.mjs

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
 import { InternalRuntimeContext, getGlobalEnableRsc } from "@modern-js/runtime/context";
-import { createRequestContext, storage } from "@modern-js/runtime-utils/node";
+import { createRequestContext } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { RouterProvider, createMemoryHistory, createRouter } from "@tanstack/react-router";
@@ -9,138 +9,43 @@ import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
 import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
 import { applyRouterServerPrepareResult, createRouterServerSnapshot, getRouterRuntimeState } from "./lifecycle.mjs";
-import { getFinalRouteConfig, getMergedRouterConfig } from "./pluginCore.mjs";
+import { createTanstackRouteObjects, getTanstackRouteConfig, joinBasename } from "./pluginShared.mjs";
 import { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./routeTree.mjs";
 import { createTanstackRscServerPayload, handleTanstackRscRedirect } from "./rsc/payloadRouter.mjs";
+import { getTanstackRscRouter, setTanstackRscRouter, setTanstackRscServerPayload } from "./rsc/payloadStorage.mjs";
+import { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml, waitForRouterSerialization } from "./ssrManagedTags.mjs";
+import { preloadMatchedRouteComponents } from "./ssrPreload.mjs";
 import { getModernTanstackRouterFastDefaults } from "./types.mjs";
-import { createRouteObjectsFromConfig, urlJoin } from "./utils.mjs";
-const setTanstackRscServerPayload = (payload)=>{
-    const storageContext = storage.useContext?.();
-    if (storageContext) storageContext.serverPayload = payload;
-};
-function isPromiseLike(value) {
-    return Boolean(value && 'function' == typeof value.then);
-}
-function isPreloadableRouteComponent(component) {
-    if (!component || 'function' != typeof component) return false;
-    const preloadable = component;
-    return 'function' == typeof preloadable.load || 'function' == typeof preloadable.preload;
-}
-function isReactLazyRouteComponent(component) {
-    return null != component && 'object' == typeof component && 'function' == typeof component._init && '_payload' in component;
-}
-async function preloadReactLazyRouteComponent(component) {
-    try {
-        component._init?.(component._payload);
-    } catch (thrown) {
-        if (!isPromiseLike(thrown)) throw thrown;
-        await thrown;
-        component._init?.(component._payload);
-    }
-}
-async function preloadRouteComponent(component) {
-    if (isReactLazyRouteComponent(component)) return void await preloadReactLazyRouteComponent(component);
-    if (!isPreloadableRouteComponent(component)) return;
-    if ('function' == typeof component.load) return void await component.load({});
-    await component.preload?.({});
-}
-async function preloadMatchedRouteComponents(tanstackRouter) {
-    const matches = Array.isArray(tanstackRouter.state.matches) ? tanstackRouter.state.matches : [];
-    const routesById = tanstackRouter.routesById || {};
-    await Promise.all(matches.map(async (match)=>{
-        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : void 0;
-        const route = routeId ? routesById[routeId] : match.route;
-        const options = route?.options;
-        if (!options) return;
-        await Promise.all([
-            preloadRouteComponent(options.component),
-            preloadRouteComponent(options.pendingComponent),
-            preloadRouteComponent(options.errorComponent),
-            preloadRouteComponent(options.notFoundComponent)
-        ]);
-    }));
-}
-async function waitForRouterSerialization(tanstackRouter) {
-    const serverSsr = tanstackRouter.serverSsr;
-    if (!serverSsr || 'function' != typeof serverSsr.onSerializationFinished || serverSsr.isSerializationFinished?.()) return;
-    await new Promise((resolve)=>{
-        serverSsr.onSerializationFinished?.(resolve);
-    });
-}
-function htmlEscapeAttr(value) {
-    return value.replace(/&/g, '&').replace(/"/g, '"');
-}
-function routerManagedTagToHtml(tag) {
-    if (!tag || 'object' != typeof tag) return '';
-    const managedTag = tag;
-    if (!managedTag || "script" !== managedTag.tag) return '';
-    const attrs = managedTag.attrs || {};
-    const attrsStr = Object.entries(attrs).filter(([, v])=>null != v && false !== v).map(([k, v])=>{
-        const name = 'className' === k ? 'class' : k;
-        if (true === v) return name;
-        return `${name}="${htmlEscapeAttr(String(v))}"`;
-    }).join(' ');
-    const open = attrsStr.length ? `<script ${attrsStr}>` : "<script>";
-    const children = 'string' == typeof managedTag.children ? managedTag.children : '';
-    return `${open}${children}</script>`;
-}
-function routerManagedTagsToHtml(tags) {
-    const normalizedTags = Array.isArray(tags) ? tags : [
-        tags
-    ];
-    return normalizedTags.map(routerManagedTagToHtml).filter(Boolean);
-}
-function createGetSsrHref(request) {
-    const url = new URL(request.url);
-    return `${url.pathname}${url.search}${url.hash}`;
-}
-function collectRouterErrors(tanstackRouter) {
-    const state = tanstackRouter.state;
-    const matches = Array.isArray(state.matches) ? state.matches : [];
-    const errors = matches.reduce((acc, match)=>{
-        if (!match.error) return acc;
-        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : `match-${Object.keys(acc).length}`;
-        acc[routeId] = match.error;
-        return acc;
-    }, {});
-    return Object.keys(errors).length > 0 ? errors : void 0;
-}
-async function attachServerSsrUtils(router) {
-    const { attachRouterServerSsrUtils } = await import("@tanstack/router-core/ssr/server");
-    attachRouterServerSsrUtils({
-        router,
-        manifest: void 0
-    });
-}
 const tanstackRouterPlugin = (userConfig = {})=>{
     const plugin = {
         name: '@modern-js/plugin-router-tanstack',
         registryHooks: routerProviderRegistryHooks,
         setup: (api)=>{
             api.onBeforeRender(async (context, interrupt)=>{
-                const mergedConfig = getMergedRouterConfig(api, userConfig);
+                const routeConfig = getTanstackRouteConfig(api, userConfig);
+                const { mergedConfig } = routeConfig;
                 const serializationAdapters = getGlobalEnableRsc() ? (await import("./rsc/server.mjs")).getTanstackRscSerializationAdapters() : void 0;
                 const enableRsc = getGlobalEnableRsc();
-                const { basename = '', createRoutes } = mergedConfig;
-                const finalRouteConfig = getFinalRouteConfig(mergedConfig);
-                if (!finalRouteConfig.routes && !createRoutes) return;
+                const { basename = '' } = mergedConfig;
+                if (!routeConfig.hasConfiguredRoutes) return;
                 const hooks = api.getHooks();
                 await hooks.onBeforeCreateRoutes.call(context);
-                const routeObjects = createRoutes ? createRoutes() : createRouteObjectsFromConfig({
-                    routesConfig: finalRouteConfig,
+                const modifiedRouteObjects = createTanstackRouteObjects({
+                    hooks,
+                    routeConfig,
                     ssrMode: context.ssrContext?.mode
-                }) || [];
-                const modifiedRouteObjects = hooks.modifyRoutes.call(routeObjects);
+                });
                 if (!modifiedRouteObjects.length) return;
                 const { request, nonce, baseUrl, loaderFailureMode = 'errorBoundary' } = context.ssrContext;
-                const _basename = '/' === baseUrl ? urlJoin(baseUrl, basename || '') : baseUrl;
-                const initialHref = createGetSsrHref(request.raw);
-                const isRSCNavigation = enableRsc && 'true' === request.raw.headers.get('x-rsc-tree');
+                const _basename = '/' === baseUrl ? joinBasename(baseUrl, basename || '') : baseUrl;
+                const rawRequest = request.raw;
+                const initialHref = createGetSsrHref(rawRequest);
+                const isRSCNavigation = enableRsc && 'true' === rawRequest.headers.get('x-rsc-tree');
                 const requestContext = createRequestContext(context.ssrContext?.loaderContext);
                 const controller = new AbortController();
-                const ssrRequest = new Request(request.raw.url, {
+                const ssrRequest = new Request(rawRequest.url, {
                     method: 'GET',
-                    headers: request.raw.headers,
+                    headers: rawRequest.headers,
                     signal: controller.signal
                 });
                 const routerContext = {
@@ -168,7 +73,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     history,
                     basepath: '/',
                     rewrite,
-                    origin: new URL(request.raw.url).origin,
+                    origin: new URL(rawRequest.url).origin,
                     ssr: {
                         nonce
                     },
@@ -178,6 +83,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                     } : {}
                 });
                 const serverRouter = tanstackRouter;
+                if (enableRsc) setTanstackRscRouter(serverRouter);
                 await attachServerSsrUtils(serverRouter);
                 const end = time();
                 try {
@@ -197,19 +103,19 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 }
                 const routerErrors = collectRouterErrors(tanstackRouter);
                 if (routerErrors && 'clientRender' === loaderFailureMode) {
-                    context.ssrContext?.response.status(200);
+                    context.ssrContext?.response?.status(200);
                     try {
                         serverRouter.serverSsr?.cleanup?.();
                     } catch  {}
                     throw Object.values(routerErrors)[0];
                 }
                 await preloadMatchedRouteComponents(serverRouter);
-                context.ssrContext?.response.status(tanstackRouter.state.statusCode);
+                context.ssrContext?.response?.status(tanstackRouter.state.statusCode);
                 await serverRouter.serverSsr?.dehydrate?.();
-                if (isRSCNavigation) {
-                    await waitForRouterSerialization(serverRouter);
+                if (enableRsc) {
+                    if (isRSCNavigation) await waitForRouterSerialization(serverRouter);
                     setTanstackRscServerPayload(createTanstackRscServerPayload(serverRouter, {
-                        omitClientLoaderData: true
+                        omitClientLoaderData: isRSCNavigation
                     }));
                 }
                 const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
@@ -243,7 +149,20 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                 });
             });
             api.wrapRoot((App)=>{
-                const getRouteApp = ()=>(props)=>{
+                const getRouteApp = ()=>{
+                    if (getGlobalEnableRsc()) return (props)=>{
+                        const router = getTanstackRscRouter();
+                        if (!router) return App ? /*#__PURE__*/ jsx(App, {
+                            ...props
+                        }) : null;
+                        const routerWrapper = wrapTanstackSsrHydrationBoundary(/*#__PURE__*/ jsx(RouterProvider, {
+                            router: router
+                        }), true);
+                        return App ? /*#__PURE__*/ jsx(App, {
+                            children: routerWrapper
+                        }) : routerWrapper;
+                    };
+                    return (props)=>{
                         const context = useContext(InternalRuntimeContext);
                         const router = getRouterRuntimeState(context)?.instance;
                         if (!router) return App ? /*#__PURE__*/ jsx(App, {
@@ -256,6 +175,7 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                             children: routerWrapper
                         }) : routerWrapper;
                     };
+                };
                 return getRouteApp();
             });
         }

package/dist/esm/runtime/pluginShared.mjs

@@ -0,0 +1,40 @@
+import { getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createTanstackRouteObjectsFromConfig } from "./utils.mjs";
+function getMergedRouterConfig(api, userConfig) {
+    const pluginConfig = api.getRuntimeConfig();
+    return merge(pluginConfig.router || {}, userConfig);
+}
+function getFinalRouteConfig(mergedConfig) {
+    return {
+        routes: getGlobalRoutes(),
+        globalApp: getGlobalLayoutApp(),
+        ...mergedConfig.routesConfig
+    };
+}
+function getTanstackRouteConfig(api, userConfig) {
+    const mergedConfig = getMergedRouterConfig(api, userConfig);
+    const finalRouteConfig = getFinalRouteConfig(mergedConfig);
+    return {
+        mergedConfig,
+        finalRouteConfig,
+        hasConfiguredRoutes: Boolean(finalRouteConfig.routes) || Boolean(mergedConfig.createRoutes)
+    };
+}
+function createTanstackRouteObjects({ hooks, routeConfig, ssrMode }) {
+    const { mergedConfig, finalRouteConfig } = routeConfig;
+    const routeObjects = mergedConfig.createRoutes ? mergedConfig.createRoutes() : createTanstackRouteObjectsFromConfig({
+        routesConfig: finalRouteConfig,
+        ssrMode
+    }) || [];
+    return hooks.modifyRoutes.call(routeObjects);
+}
+function joinBasename(baseUrl, basename) {
+    const base = baseUrl || '/';
+    const normalizedBase = base.startsWith('/') ? base : `/${base}`;
+    const trimmedBase = normalizedBase.length > 1 ? normalizedBase.replace(/\/+$/g, '') : normalizedBase;
+    const trimmedBasename = basename.replace(/^\/+|\/+$/g, '');
+    if (!trimmedBasename) return trimmedBase || '/';
+    return `${trimmedBase}/${trimmedBasename}`.replace(/\/{2,}/g, '/');
+}
+export { createTanstackRouteObjects, getMergedRouterConfig, getTanstackRouteConfig, joinBasename };

package/dist/esm/runtime/prefetchLink.mjs

@@ -1,5 +1,5 @@
 import { jsx } from "react/jsx-runtime";
-import { Link } from "@tanstack/react-router";
+import { useLinkProps } from "@tanstack/react-router";
 function resolvePreloadFromPrefetch(prefetch, preload) {
     if (void 0 !== preload) return preload;
     if ('none' === prefetch) return false;
@@ -7,12 +7,25 @@ function resolvePreloadFromPrefetch(prefetch, preload) {
     return 'viewport';
 }
 const LinkComponentImpl = (props)=>{
-    const { prefetch, preload, ...rest } = props;
-    return /*#__PURE__*/ jsx(Link, {
+    const { prefetch, preload, 'aria-current': ariaCurrentProp, ref, children, ...rest } = props;
+    const hasAriaCurrentOverride = 'aria-current' in props;
+    const linkOptions = {
         ...rest,
         preload: resolvePreloadFromPrefetch(prefetch, preload)
+    };
+    const linkProps = useLinkProps(linkOptions, ref);
+    const { disabled: _disabled, type: _type, ...anchorProps } = linkProps;
+    if (hasAriaCurrentOverride) if (false === ariaCurrentProp || void 0 === ariaCurrentProp) delete anchorProps['aria-current'];
+    else anchorProps['aria-current'] = ariaCurrentProp;
+    const resolvedChildren = 'function' == typeof children ? children({
+        isActive: 'active' === anchorProps['data-status'],
+        isTransitioning: 'transitioning' === anchorProps['data-transitioning']
+    }) : children;
+    return /*#__PURE__*/ jsx("a", {
+        ...anchorProps,
+        children: resolvedChildren
     });
 };
-const prefetchLink_Link = LinkComponentImpl;
+const Link = LinkComponentImpl;
 const NavLink = LinkComponentImpl;
-export { NavLink, prefetchLink_Link as Link };
+export { Link, NavLink };

package/dist/esm/runtime/register.mjs

@@ -1,18 +1,5 @@
 import { registerRouterProvider } from "@modern-js/runtime/context";
-import { Form, RouteActionResponseError, useFetcher } from "./dataMutation.mjs";
-import { Outlet } from "./outlet.mjs";
 import { tanstackRouterPlugin } from "./plugin.mjs";
-import { Link, NavLink } from "./prefetchLink.mjs";
 const tanstackRouterProviderFactory = (userConfig)=>tanstackRouterPlugin(userConfig);
 registerRouterProvider('tanstack', tanstackRouterProviderFactory);
-const COMPAT_BINDINGS_SLOT = Symbol.for('@modern-js/plugin-tanstack:runtime-compat-bindings');
-const tanstackRouterCompatBindings = {
-    Form: Form,
-    Link: Link,
-    NavLink: NavLink,
-    Outlet: Outlet,
-    RouteActionResponseError: RouteActionResponseError,
-    useFetcher: useFetcher
-};
-globalThis[COMPAT_BINDINGS_SLOT] ??= tanstackRouterCompatBindings;
-export { tanstackRouterCompatBindings };
+export { tanstackRouterProviderFactory };

package/dist/esm/runtime/routeTree/components.mjs

@@ -0,0 +1,55 @@
+import { createElement } from "react";
+function pickRouteModuleComponent(routeModule, seen = new Set()) {
+    if ('function' == typeof routeModule || routeModule && 'object' == typeof routeModule && '$$typeof' in routeModule) return routeModule;
+    if (!routeModule || 'object' != typeof routeModule) return;
+    if (seen.has(routeModule)) return;
+    seen.add(routeModule);
+    const module = routeModule;
+    for (const candidate of [
+        module.default,
+        module.Component
+    ]){
+        const component = pickRouteModuleComponent(candidate, seen);
+        if (component) return component;
+    }
+}
+function createServerLazyImportComponent(lazyImport, fallbackComponent) {
+    if ("u" > typeof document) return fallbackComponent;
+    let resolvedComponent;
+    let pendingLoad;
+    const load = async ()=>{
+        if (resolvedComponent) return resolvedComponent;
+        const routeModule = await lazyImport();
+        const component = pickRouteModuleComponent(routeModule);
+        if (component) resolvedComponent = component;
+        return resolvedComponent;
+    };
+    const Component = (props)=>{
+        if (resolvedComponent) return createElement(resolvedComponent, props);
+        pendingLoad ||= load();
+        throw pendingLoad;
+    };
+    Component.load = load;
+    Component.preload = load;
+    return Component;
+}
+function toRouteComponent(routeObject, options = {}) {
+    const route = routeObject;
+    const lazyImport = 'function' == typeof route.lazyImport ? route.lazyImport : void 0;
+    const routeComponent = route.Component || route.component;
+    const fallbackComponent = routeComponent ? routeComponent : route.element ? ()=>route.element : void 0;
+    if (lazyImport && fallbackComponent) return createServerLazyImportComponent(lazyImport, fallbackComponent);
+    if (routeComponent) return routeComponent;
+    const element = route.element;
+    if (element) return ()=>element;
+}
+function toErrorComponent(routeObject) {
+    const route = routeObject;
+    if (route.ErrorBoundary) return route.ErrorBoundary;
+    if (route.errorElement) return ()=>route.errorElement;
+}
+function toPendingComponent(routeObject) {
+    const route = routeObject;
+    return route.HydrateFallback || route.pendingComponent || void 0;
+}
+export { pickRouteModuleComponent, toErrorComponent, toPendingComponent, toRouteComponent };

package/dist/esm/runtime/routeTree/construction.mjs

@@ -0,0 +1,111 @@
+import { DefaultNotFound } from "@modern-js/runtime/context";
+import { rootRouteId } from "@tanstack/react-router";
+import { withModernRouteMatchContext } from "../outlet.mjs";
+import { toErrorComponent, toPendingComponent, toRouteComponent } from "./components.mjs";
+import { createModernShouldReload, wrapRouteObjectLoader } from "./loaders.mjs";
+import { isRouteObjectPathlessLayout, toTanstackPath } from "./paths.mjs";
+import { createRouteStaticData, mergeModernRouteHandle } from "./staticData.mjs";
+import { createTanstackRootRoute, createTanstackRoute, wrapRouteComponentWithModernContext } from "./tanstackRoutes.mjs";
+function createRouteFromRouteObject(opts) {
+    const { options = {}, parent, pathlessFallbackId = 'pathless', routeObject } = opts;
+    const modernRouteObject = routeObject;
+    const revalidationState = {};
+    const shouldRevalidate = modernRouteObject.shouldRevalidate;
+    const shouldReload = createModernShouldReload(shouldRevalidate, revalidationState);
+    const stableFallbackId = routeObject.id || modernRouteObject.file || pathlessFallbackId;
+    const component = toRouteComponent(routeObject, options);
+    const base = {
+        getParentRoute: ()=>parent,
+        component,
+        pendingComponent: toPendingComponent(routeObject),
+        errorComponent: toErrorComponent(routeObject),
+        validateSearch: modernRouteObject.validateSearch,
+        loaderDeps: modernRouteObject.loaderDeps,
+        staticData: createRouteStaticData({
+            modernRouteId: routeObject.id,
+            modernRouteAction: modernRouteObject.action,
+            modernRouteHandle: mergeModernRouteHandle(modernRouteObject),
+            modernRouteHasAction: modernRouteObject.hasAction || Boolean(modernRouteObject.action),
+            modernRouteHasClientLoader: modernRouteObject.hasClientLoader || void 0 !== modernRouteObject.clientData,
+            modernRouteHasLoader: modernRouteObject.hasLoader || 'function' == typeof modernRouteObject.loader,
+            modernRouteIsClientComponent: modernRouteObject.isClientComponent,
+            modernRouteLoader: modernRouteObject.loader,
+            modernRouteShouldRevalidate: shouldRevalidate
+        }),
+        loader: wrapRouteObjectLoader(routeObject, revalidationState, options)
+    };
+    if (modernRouteObject.inValidSSRRoute) base.ssr = false;
+    if (shouldReload) base.shouldReload = shouldReload;
+    if (isRouteObjectPathlessLayout(routeObject)) base.id = stableFallbackId;
+    else base.path = routeObject.index ? '/' : toTanstackPath(routeObject.path || '');
+    const route = createTanstackRoute(base);
+    wrapRouteComponentWithModernContext(route, component, routeObject.id);
+    const children = routeObject.children;
+    if (children && children.length > 0) {
+        const childRoutes = children.map((child, index)=>createRouteFromRouteObject({
+                options,
+                parent: route,
+                pathlessFallbackId: `pathless-${index}`,
+                routeObject: child
+            }));
+        route.addChildren(childRoutes);
+    }
+    return route;
+}
+function getRootLikeRouteObject(routes) {
+    return routes.find((route)=>'/' === route.path && !route.index);
+}
+function createRouteTreeFromRouteObjects(routes, options = {}) {
+    const rootLikeRoute = getRootLikeRouteObject(routes);
+    const rootRevalidationState = {};
+    const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
+    const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
+    const rootComponent = rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0;
+    const rootRouteOptions = {
+        component: rootComponent,
+        pendingComponent: rootLikeRoute ? toPendingComponent(rootLikeRoute) : void 0,
+        errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : void 0,
+        validateSearch: rootLikeRoute?.validateSearch,
+        loaderDeps: rootLikeRoute?.loaderDeps,
+        notFoundComponent: DefaultNotFound,
+        staticData: createRouteStaticData({
+            modernRouteId: rootLikeRoute?.id,
+            modernRouteAction: rootLikeRoute?.action,
+            modernRouteHandle: rootLikeRoute ? mergeModernRouteHandle(rootLikeRoute) : void 0,
+            modernRouteHasAction: rootLikeRoute?.hasAction || Boolean(rootLikeRoute?.action),
+            modernRouteHasClientLoader: rootLikeRoute?.hasClientLoader || void 0 !== rootLikeRoute?.clientData,
+            modernRouteHasLoader: rootLikeRoute?.hasLoader || 'function' == typeof rootLikeRoute?.loader,
+            modernRouteIsClientComponent: rootLikeRoute?.isClientComponent,
+            modernRouteLoader: rootLikeRoute?.loader,
+            modernRouteShouldRevalidate: rootShouldRevalidate
+        }),
+        loader: rootLikeRoute ? wrapRouteObjectLoader(rootLikeRoute, rootRevalidationState, options) : void 0
+    };
+    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
+    if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
+    const rootRoute = createTanstackRootRoute(rootRouteOptions);
+    if (rootComponent) rootRoute.options.component = withModernRouteMatchContext(rootComponent, rootRouteId);
+    const topLevel = rootLikeRoute ? [
+        ...rootLikeRoute.children || [],
+        ...routes.filter((route)=>route !== rootLikeRoute)
+    ] : routes;
+    const childRoutes = topLevel.map((routeObject, index)=>createRouteFromRouteObject({
+            options,
+            parent: rootRoute,
+            pathlessFallbackId: `pathless-${index}`,
+            routeObject
+        }));
+    rootRoute.addChildren(childRoutes);
+    return rootRoute;
+}
+function getModernRouteIdsFromMatches(router) {
+    const matches = router.state.matches || [];
+    const routesById = router.routesById;
+    const ids = matches.map((match)=>{
+        const normalizedMatch = match;
+        const routeId = 'string' == typeof normalizedMatch.routeId ? normalizedMatch.routeId : void 0;
+        return normalizedMatch.route?.options?.staticData?.modernRouteId ?? (routeId ? routesById?.[routeId]?.options?.staticData?.modernRouteId : void 0);
+    }).filter((id)=>'string' == typeof id);
+    return Array.from(new Set(ids));
+}
+export { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches };

package/dist/esm/runtime/routeTree/index.mjs

@@ -0,0 +1,2 @@
+export { pickRouteModuleComponent } from "./components.mjs";
+export { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./construction.mjs";

package/dist/esm/runtime/routeTree/loaders.mjs

@@ -0,0 +1,117 @@
+import { notFound } from "@tanstack/react-router";
+import { isRedirectResponse, isResponse, isTanstackRedirect, throwTanstackRedirect } from "../loaderBridge.mjs";
+import { isTanstackRscPayloadNavigationEnabled, loadTanstackRscRouteData } from "../rsc/payloadRouter.mjs";
+function isModernDeferredData(value) {
+    if (!value || 'object' != typeof value) return false;
+    const deferred = value;
+    return true === deferred.__modern_deferred && Boolean(deferred.data) && 'object' == typeof deferred.data && !Array.isArray(deferred.data);
+}
+function normalizeModernLoaderResult(result) {
+    return isModernDeferredData(result) ? result.data : result;
+}
+function normalizeModernLoaderResponse(result) {
+    if (isResponse(result)) {
+        if (isRedirectResponse(result)) {
+            const location = result.headers.get('Location') || '/';
+            throwTanstackRedirect(location);
+        }
+        if (404 === result.status) throw notFound();
+    }
+    return normalizeModernLoaderResult(result);
+}
+function createModernRequest(input, signal) {
+    return new Request(input, {
+        signal
+    });
+}
+function getModernUrlFromLoaderContext(ctx) {
+    const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '/';
+    const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
+    const baseUrl = baseRequest?.url || ("u" > typeof window ? window.origin : 'http://localhost');
+    return new URL(href || '/', baseUrl);
+}
+function rememberRouteLocation(state, ctx) {
+    state.currentUrl = getModernUrlFromLoaderContext(ctx);
+    state.currentParams = ctx?.params || {};
+}
+function createModernShouldReload(shouldRevalidate, state) {
+    if ('function' != typeof shouldRevalidate) return;
+    const revalidate = shouldRevalidate;
+    return (ctx)=>{
+        const nextUrl = getModernUrlFromLoaderContext(ctx);
+        const nextParams = ctx?.params || {};
+        const result = revalidate({
+            currentUrl: state.currentUrl || nextUrl,
+            currentParams: state.currentParams || nextParams,
+            nextUrl,
+            nextParams,
+            defaultShouldRevalidate: void 0
+        });
+        state.currentUrl = nextUrl;
+        state.currentParams = nextParams;
+        return 'boolean' == typeof result ? result : void 0;
+    };
+}
+function isRouteObjectSplatRoute(route) {
+    return 'string' == typeof route.path && route.path.includes('*');
+}
+function mapParamsForRouteObjectLoader({ route, params }) {
+    if (isRouteObjectSplatRoute(route)) {
+        const { _splat, ...rest } = params;
+        if (void 0 !== _splat) return {
+            ...rest,
+            '*': _splat
+        };
+        return rest;
+    }
+    return params;
+}
+function wrapRouteObjectLoader(route, revalidationState, options = {}) {
+    const modernRoute = route;
+    const routeLoader = modernRoute.loader;
+    if ('function' != typeof routeLoader) return;
+    return async (ctx)=>{
+        try {
+            if (revalidationState) rememberRouteLocation(revalidationState, ctx);
+            if ('function' == typeof modernRoute.lazyImport) try {
+                await modernRoute.lazyImport();
+            } catch  {}
+            const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
+            const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
+            const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '';
+            const request = void 0 !== baseRequest ? new Request(baseRequest, {
+                signal
+            }) : createModernRequest(href, signal);
+            const params = mapParamsForRouteObjectLoader({
+                route,
+                params: ctx.params || {}
+            });
+            const loadModernData = async ()=>{
+                const result = await routeLoader({
+                    request,
+                    params,
+                    context: ctx?.context?.requestContext
+                });
+                return normalizeModernLoaderResponse(result);
+            };
+            if (options.rscPayloadRouter && isTanstackRscPayloadNavigationEnabled()) return loadTanstackRscRouteData({
+                hasClientLoader: modernRoute.hasClientLoader || void 0 !== modernRoute.clientData,
+                loadClientData: loadModernData,
+                request,
+                routeId: ctx.route?.id
+            });
+            return loadModernData();
+        } catch (err) {
+            if (isResponse(err)) {
+                if (isTanstackRedirect(err)) throw err;
+                if (isRedirectResponse(err)) {
+                    const location = err.headers.get('Location') || '/';
+                    throwTanstackRedirect(location);
+                }
+                if (404 === err.status) throw notFound();
+            }
+            throw err;
+        }
+    };
+}
+export { createModernShouldReload, wrapRouteObjectLoader };

package/dist/esm/runtime/routeTree/paths.mjs

@@ -0,0 +1,16 @@
+function toTanstackPath(pathname) {
+    return pathname.split('/').map((segment)=>{
+        if (!segment) return segment;
+        if ('*' === segment) return '$';
+        if (segment.startsWith(':')) {
+            const name = segment.slice(1);
+            if (name.endsWith('?')) return `{-$${name.slice(0, -1)}}`;
+            return `$${name}`;
+        }
+        return segment;
+    }).join('/');
+}
+function isRouteObjectPathlessLayout(route) {
+    return !route.path && !route.index;
+}
+export { isRouteObjectPathlessLayout, toTanstackPath };

package/dist/esm/runtime/routeTree/staticData.mjs

@@ -0,0 +1,22 @@
+function mergeModernRouteHandle(route) {
+    const config = route.config;
+    const handle = {
+        ...route.handle,
+        ...config && 'object' == typeof config ? config.handle : {}
+    };
+    return Object.keys(handle).length > 0 ? handle : void 0;
+}
+function createRouteStaticData(opts) {
+    const staticData = {};
+    if (opts.modernRouteId) staticData.modernRouteId = opts.modernRouteId;
+    if (opts.modernRouteAction) staticData.modernRouteAction = opts.modernRouteAction;
+    if (opts.modernRouteHandle) staticData.modernRouteHandle = opts.modernRouteHandle;
+    if (opts.modernRouteHasAction) staticData.modernRouteHasAction = true;
+    if (opts.modernRouteHasClientLoader) staticData.modernRouteHasClientLoader = true;
+    if (opts.modernRouteHasLoader) staticData.modernRouteHasLoader = true;
+    if (opts.modernRouteIsClientComponent) staticData.modernRouteIsClientComponent = true;
+    if (opts.modernRouteLoader) staticData.modernRouteLoader = opts.modernRouteLoader;
+    if (opts.modernRouteShouldRevalidate) staticData.modernRouteShouldRevalidate = opts.modernRouteShouldRevalidate;
+    return Object.keys(staticData).length > 0 ? staticData : void 0;
+}
+export { createRouteStaticData, mergeModernRouteHandle };