@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.11 → 3.9.0-ultramodern.13

package/dist/cjs/runtime/routeTree/construction.js

@@ -31,26 +31,22 @@ __webpack_require__.d(__webpack_exports__, {
     createRouteTreeFromRouteObjects: ()=>createRouteTreeFromRouteObjects,
     getModernRouteIdsFromMatches: ()=>getModernRouteIdsFromMatches
 });
-const i18n_runtime_extensions_namespaceObject = require("@modern-js/i18n-runtime-extensions");
 const context_namespaceObject = require("@modern-js/runtime/context");
 const react_router_namespaceObject = require("@tanstack/react-router");
+const routeDescriptor_js_namespaceObject = require("../../shared/routeDescriptor.js");
 const routeStaticData_js_namespaceObject = require("../../shared/routeStaticData.js");
 const external_outlet_js_namespaceObject = require("../outlet.js");
 const external_components_js_namespaceObject = require("./components.js");
 const external_loaders_js_namespaceObject = require("./loaders.js");
-const external_paths_js_namespaceObject = require("./paths.js");
 const external_staticData_js_namespaceObject = require("./staticData.js");
 const external_tanstackRoutes_js_namespaceObject = require("./tanstackRoutes.js");
-function createRouteFromRouteObject(opts) {
-    const { options = {}, parent, pathlessFallbackId = 'pathless', routeObject } = opts;
+function createRouteOptions(routeObject, options) {
     const modernRouteObject = routeObject;
     const revalidationState = {};
     const shouldRevalidate = modernRouteObject.shouldRevalidate;
     const shouldReload = (0, external_loaders_js_namespaceObject.createModernShouldReload)(shouldRevalidate, revalidationState);
-    const stableFallbackId = routeObject.id || modernRouteObject.file || pathlessFallbackId;
     const component = (0, external_components_js_namespaceObject.toRouteComponent)(routeObject);
     const base = {
-        getParentRoute: ()=>parent,
         component,
         pendingComponent: (0, external_components_js_namespaceObject.toPendingComponent)(routeObject),
         errorComponent: (0, external_components_js_namespaceObject.toErrorComponent)(routeObject),
@@ -71,67 +67,29 @@ function createRouteFromRouteObject(opts) {
     };
     if (modernRouteObject.inValidSSRRoute) base.ssr = false;
     if (shouldReload) base.shouldReload = shouldReload;
-    if ((0, external_paths_js_namespaceObject.isRouteObjectPathlessLayout)(routeObject)) base.id = stableFallbackId;
-    else base.path = routeObject.index ? '/' : (0, external_paths_js_namespaceObject.toTanstackPath)(routeObject.path || '');
-    const route = (0, external_tanstackRoutes_js_namespaceObject.createTanstackRoute)(base);
-    (0, external_tanstackRoutes_js_namespaceObject.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;
+    return base;
 }
-function getRootLikeRouteObject(routes) {
-    return routes.find((route)=>'/' === route.path && !route.index);
+function createRouteFromDescriptor(descriptor, parent, options) {
+    const { source, location, children } = descriptor;
+    const routeOptions = createRouteOptions(source, options);
+    const route = (0, external_tanstackRoutes_js_namespaceObject.createTanstackRoute)({
+        ...routeOptions,
+        ...location,
+        getParentRoute: ()=>parent
+    });
+    (0, external_tanstackRoutes_js_namespaceObject.wrapRouteComponentWithModernContext)(route, routeOptions.component, source.id);
+    if (children.length) route.addChildren(children.map((child)=>createRouteFromDescriptor(child, route, options)));
+    return route;
 }
 function createRouteTreeFromRouteObjects(routes, options = {}) {
-    routes = (0, i18n_runtime_extensions_namespaceObject.canonicaliseLocalisedRoutes)(routes);
-    const rootLikeRoute = getRootLikeRouteObject(routes);
-    const rootRevalidationState = {};
-    const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
-    const rootShouldReload = (0, external_loaders_js_namespaceObject.createModernShouldReload)(rootShouldRevalidate, rootRevalidationState);
-    const rootComponent = rootLikeRoute ? (0, external_components_js_namespaceObject.toRouteComponent)(rootLikeRoute) : void 0;
+    const { root, children } = (0, routeDescriptor_js_namespaceObject.describeRouteTree)(routes);
     const rootRouteOptions = {
-        component: rootComponent,
-        pendingComponent: rootLikeRoute ? (0, external_components_js_namespaceObject.toPendingComponent)(rootLikeRoute) : void 0,
-        errorComponent: rootLikeRoute ? (0, external_components_js_namespaceObject.toErrorComponent)(rootLikeRoute) : void 0,
-        validateSearch: rootLikeRoute?.validateSearch,
-        loaderDeps: rootLikeRoute?.loaderDeps,
-        notFoundComponent: context_namespaceObject.DefaultNotFound,
-        staticData: (0, routeStaticData_js_namespaceObject.createRouteStaticData)({
-            modernRouteId: rootLikeRoute?.id,
-            modernRouteAction: rootLikeRoute?.action,
-            modernRouteHandle: rootLikeRoute ? (0, external_staticData_js_namespaceObject.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 ? (0, external_loaders_js_namespaceObject.wrapRouteObjectLoader)(rootLikeRoute, rootRevalidationState, options) : void 0
+        ...root ? createRouteOptions(root, options) : {},
+        notFoundComponent: context_namespaceObject.DefaultNotFound
     };
-    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
-    if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
     const rootRoute = (0, external_tanstackRoutes_js_namespaceObject.createTanstackRootRoute)(rootRouteOptions);
-    if (rootComponent) rootRoute.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(rootComponent, react_router_namespaceObject.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);
+    if (rootRouteOptions.component) rootRoute.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(rootRouteOptions.component, react_router_namespaceObject.rootRouteId);
+    rootRoute.addChildren(children.map((child)=>createRouteFromDescriptor(child, rootRoute, options)));
     return rootRoute;
 }
 function getModernRouteIdsFromMatches(router) {

package/dist/cjs/runtime/routeTree/loaders.js

@@ -82,7 +82,7 @@ function wrapRouteObjectLoader(route, revalidationState, options = {}) {
             if ('function' == typeof modernRoute.lazyImport) try {
                 await modernRoute.lazyImport();
             } catch  {}
-            const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
+            const signal = (0, external_loaderBridge_js_namespaceObject.getLoaderSignal)(ctx);
             const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
             const href = (0, external_loaderBridge_js_namespaceObject.getLoaderHref)(ctx);
             const request = void 0 !== baseRequest ? new Request(baseRequest, {

package/dist/cjs/runtime/routeTree/paths.js

@@ -39,17 +39,11 @@ function toTanstackPath(pathname) {
         return segment;
     }).join('/');
 }
-function isRouteObjectPathlessLayout(route) {
-    return !route.path && !route.index;
-}
 __webpack_require__.d(__webpack_exports__, {
-    isRouteObjectPathlessLayout: ()=>isRouteObjectPathlessLayout,
     toTanstackPath: ()=>toTanstackPath
 });
-exports.isRouteObjectPathlessLayout = __webpack_exports__.isRouteObjectPathlessLayout;
 exports.toTanstackPath = __webpack_exports__.toTanstackPath;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "isRouteObjectPathlessLayout",
     "toTanstackPath"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/runtime/ssrManagedTags.js

@@ -27,13 +27,6 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-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, '"');
 }
@@ -83,20 +76,17 @@ __webpack_require__.d(__webpack_exports__, {
     attachServerSsrUtils: ()=>attachServerSsrUtils,
     collectRouterErrors: ()=>collectRouterErrors,
     createGetSsrHref: ()=>createGetSsrHref,
-    routerManagedTagsToHtml: ()=>routerManagedTagsToHtml,
-    waitForRouterSerialization: ()=>waitForRouterSerialization
+    routerManagedTagsToHtml: ()=>routerManagedTagsToHtml
 });
 exports.attachServerSsrUtils = __webpack_exports__.attachServerSsrUtils;
 exports.collectRouterErrors = __webpack_exports__.collectRouterErrors;
 exports.createGetSsrHref = __webpack_exports__.createGetSsrHref;
 exports.routerManagedTagsToHtml = __webpack_exports__.routerManagedTagsToHtml;
-exports.waitForRouterSerialization = __webpack_exports__.waitForRouterSerialization;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "attachServerSsrUtils",
     "collectRouterErrors",
     "createGetSsrHref",
-    "routerManagedTagsToHtml",
-    "waitForRouterSerialization"
+    "routerManagedTagsToHtml"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/runtime/utils.js

@@ -56,6 +56,7 @@ function withGlobalLayout(Component, globalApp) {
 function toTanstackRouteObject(route, globalApp) {
     if ('nested' === route.type) return {
         modernLocalisedRoute: Reflect.get(route, 'modernLocalisedRoute'),
+        isRoot: Reflect.get(route, 'isRoot'),
         path: route.path,
         id: route.id,
         loader: route.loader,

package/dist/cjs/shared/routeDescriptor.js

@@ -0,0 +1,60 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    describeRouteTree: ()=>describeRouteTree
+});
+const paths_js_namespaceObject = require("../runtime/routeTree/paths.js");
+function describeRouteTree(routes) {
+    const root = routes.find((route)=>true === route.isRoot || '/' === route.path && true !== route.index);
+    const describe = (route, index)=>({
+            source: route,
+            location: 0 === (route.path ?? '').length && true !== route.index ? {
+                id: route.id || route.file || `pathless-${index}`
+            } : {
+                path: true === route.index ? '/' : (0, paths_js_namespaceObject.toTanstackPath)(route.path || '')
+            },
+            hasSplat: Boolean(route.path?.includes('*')),
+            children: (route.children ?? []).map(describe)
+        });
+    return {
+        root,
+        children: (void 0 !== root ? [
+            ...root.children ?? [],
+            ...routes.filter((route)=>route !== root)
+        ] : routes).map(describe)
+    };
+}
+exports.describeRouteTree = __webpack_exports__.describeRouteTree;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "describeRouteTree"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/cli/artifacts.mjs

@@ -95,9 +95,10 @@ async function generateTanstackRouteArtifacts(opts) {
         version: opts.version || process.env.MODERN_JS_VERSION || '0.0.0-routes-generate',
         internalPlugins: utils.INTERNAL_RUNTIME_PLUGINS
     });
-    await cli.init({
+    const { appContext } = await cli.init({
         ...runOptions,
         command: 'build'
     });
+    await appContext.hooks.onBeforeExit.call();
 }
 export { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

package/dist/esm/cli/index.mjs

@@ -2,19 +2,13 @@ import node_path from "node:path";
 import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer } from "@modern-js/utils";
 import { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries } from "./artifacts.mjs";
 import { createTanstackRsbuildRouteSplittingProfile, resolveTanstackRouteCodeSplittingEnabled } from "./routeSplitting.mjs";
-import { __webpack_require__ } from "../rslib-runtime~1.mjs";
-__webpack_require__.add({
-    267 (module) {
-        module.exports = require("@modern-js/runtime/cli");
-    }
-});
 const DEFAULT_ROUTES_DIR = 'routes';
 const DEFAULT_GENERATED_DIR_NAME = 'modern-tanstack';
 const ENTRYPOINTS_KEY = '@modern-js/plugin-tanstack';
 let runtimeRouterCli;
 function getRuntimeRouterCli() {
     if (runtimeRouterCli) return runtimeRouterCli;
-    const cli = __webpack_require__(267);
+    const cli = require("@modern-js/runtime/cli");
     if (cli.handleGeneratorEntryCode && cli.getEntrypointRoutesDir && cli.getEntrypointRoutesOwner && cli.updateNestedRoutesSpec) {
         runtimeRouterCli = cli;
         return runtimeRouterCli;

package/dist/esm/cli/tanstackTypes/canonicalRoutes.mjs

@@ -1,3 +1,4 @@
+import { describeRouteTree } from "../../shared/routeDescriptor.mjs";
 import { toTanstackPath } from "./shared.mjs";
 const LOCALE_PARAM_SEGMENTS = new Set([
     ':lang',
@@ -44,11 +45,13 @@ function collectCanonicalRoutesForEntry(routes, options = {}) {
         const key = toTanstackPath(normalized);
         if (!canonicalParams.has(key)) canonicalParams.set(key, paramsTypeForCanonicalPath(normalized));
     };
-    const visit = (route, parentPath)=>{
+    const visit = (descriptor, parentPath)=>{
+        const { source: route, children } = descriptor;
         let currentPath = parentPath;
-        if ('string' == typeof route.modernCanonicalPath) {
+        const canonicalPath = route.modernLocalisedRoute?.canonicalPath ?? route.modernCanonicalPath;
+        if ('string' == typeof canonicalPath) {
             hasI18nSurface = true;
-            currentPath = normalizeJoined(route.modernCanonicalPath);
+            currentPath = canonicalPath ? normalizeJoined(canonicalPath) : '';
         } else if ('string' == typeof route.path && route.path.length > 0) {
             const segments = route.path.replace(/\[(.+?)\]/g, ':$1').split('/').filter(Boolean);
             if (localeParamHeuristic && '' === parentPath && LOCALE_PARAM_SEGMENTS.has(segments[0])) {
@@ -57,16 +60,13 @@ function collectCanonicalRoutesForEntry(routes, options = {}) {
             }
             currentPath = segments.length ? normalizeJoined(`${parentPath}/${segments.join('/')}`) : parentPath;
         }
-        const children = route.children;
         if (children && children.length > 0) {
             for (const child of children)visit(child, currentPath);
             return;
         }
         record(currentPath || '/');
     };
-    const rootModern = routes.find((route)=>route.isRoot);
-    const topLevel = rootModern ? rootModern.children ?? [] : routes;
-    for (const route of topLevel)visit(route, '');
+    for (const route of describeRouteTree(routes).children)visit(route, '');
     if (!hasI18nSurface || 0 === canonicalParams.size) return null;
     return Object.fromEntries([
         ...canonicalParams.entries()

package/dist/esm/cli/tanstackTypes/shared.mjs

@@ -42,14 +42,6 @@ function pickRouteSearchContractModules(route) {
         loaderDepsPath: 'string' == typeof loaderDepsPath ? loaderDepsPath : null
     };
 }
-function isPathlessLayout(route) {
-    const extras = route;
-    return 'nested' === extras.type && 'boolean' != typeof extras.index && void 0 === extras.path;
-}
-function isIndexRoute(route) {
-    const extras = route;
-    return 'nested' === extras.type && Boolean(extras.index);
-}
 function createRouteStaticDataSnippet(opts) {
     const staticData = createRouteStaticData({
         modernRouteId: opts.modernRouteId && quote(opts.modernRouteId),
@@ -60,4 +52,4 @@ function createRouteStaticDataSnippet(opts) {
     return entries.length > 0 ? `staticData: createRouteStaticData({\n    ${entries.map(([key, value])=>`${key}: ${value},`).join('\n    ')}\n  }),` : null;
 }
 export { toTanstackPath } from "../../runtime/routeTree/paths.mjs";
-export { createRouteStaticDataSnippet, isIndexRoute, isPathlessLayout, normalizeRelativeImport, pickModernLoaderModule, pickRouteSearchContractModules, quote, resolveFileNoExt };
+export { createRouteStaticDataSnippet, normalizeRelativeImport, pickModernLoaderModule, pickRouteSearchContractModules, quote, resolveFileNoExt };

package/dist/esm/cli/tanstackTypes/source.mjs

@@ -1,17 +1,11 @@
-import { canonicaliseLocalisedRoutes } from "@modern-js/i18n-runtime-extensions";
 import { makeLegalIdentifier } from "@modern-js/runtime/cli";
 import { upath } from "@modern-js/utils";
-import { createRouteStaticDataSnippet, isIndexRoute, isPathlessLayout, normalizeRelativeImport, pickModernLoaderModule, pickRouteSearchContractModules, quote, resolveFileNoExt, toTanstackPath } from "./shared.mjs";
+import { describeRouteTree } from "../../shared/routeDescriptor.mjs";
+import { createRouteStaticDataSnippet, normalizeRelativeImport, pickModernLoaderModule, pickRouteSearchContractModules, quote, resolveFileNoExt } from "./shared.mjs";
 async function generateTanstackRouterTypesSourceForEntry(opts) {
-    const { appContext, entryName, generatedDirName = 'modern-tanstack', routes: rawRoutes } = opts;
-    const routes = canonicaliseLocalisedRoutes(rawRoutes);
+    const { appContext, entryName, generatedDirName = 'modern-tanstack', routes } = opts;
     const outDir = upath.join(appContext.srcDirectory, generatedDirName, entryName);
-    const rootModern = routes.find((r)=>{
-        const extras = r;
-        return r && 'nested' === extras.type && extras.isRoot;
-    });
-    const rootExtras = rootModern;
-    const topLevel = rootModern ? rootExtras?.children || [] : routes;
+    const { root: rootModern, children: topLevel } = describeRouteTree(routes);
     const imports = [];
     const statements = [];
     const loaderImportMap = new Map();
@@ -28,9 +22,8 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         let pendingImportName = componentImportMap.get(componentPath);
         if (!pendingImportName) {
             pendingImportName = (async ()=>{
-                const resolvedNoExt = await resolveRouteModuleNoExt(componentPath);
-                if (!resolvedNoExt) return null;
-                const relImport = normalizeRelativeImport(upath.relative(outDir, resolvedNoExt));
+                const relImport = await resolveRouteImport(componentPath);
+                if (!relImport) return null;
                 const componentName = `component_${componentIndex++}`;
                 imports.push(`import ${componentName} from ${quote(relImport)};`);
                 return componentName;
@@ -39,14 +32,15 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         }
         return pendingImportName;
     };
-    const resolveRouteModuleNoExt = async (aliasedNoExtPath)=>{
+    const resolveRouteImport = async (aliasedNoExtPath)=>{
         const prefix = `${appContext.internalSrcAlias}/`;
         let absNoExt;
         if (aliasedNoExtPath.startsWith(prefix)) {
             const rel = aliasedNoExtPath.slice(prefix.length);
             absNoExt = upath.join(appContext.srcDirectory, rel);
         } else absNoExt = upath.isAbsolute(aliasedNoExtPath) ? aliasedNoExtPath : upath.join(appContext.srcDirectory, aliasedNoExtPath);
-        return resolveFileNoExt(absNoExt);
+        const resolvedNoExt = await resolveFileNoExt(absNoExt);
+        return resolvedNoExt ? normalizeRelativeImport(upath.relative(outDir, resolvedNoExt)) : null;
     };
     const getImportNamesForLoader = async (aliasedNoExtPath, inline, hasAction)=>{
         const key = `${inline ? 'inline' : 'default'}:${hasAction ? 'action' : 'loader'}:${aliasedNoExtPath}`;
@@ -55,9 +49,8 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             loaderName: existing,
             actionName: hasAction ? existing.replace(/^loader_/, 'action_') : null
         };
-        const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
-        if (!resolvedNoExt) return null;
-        const relImport = normalizeRelativeImport(upath.relative(outDir, resolvedNoExt));
+        const relImport = await resolveRouteImport(aliasedNoExtPath);
+        if (!relImport) return null;
         const importName = `loader_${loaderIndex++}`;
         const actionName = hasAction ? importName.replace(/^loader_/, 'action_') : null;
         if (inline) {
@@ -77,9 +70,8 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         const key = `${exportName}:${aliasedNoExtPath}`;
         const existing = searchContractImportMap.get(key);
         if (existing) return existing;
-        const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
-        if (!resolvedNoExt) return null;
-        const relImport = normalizeRelativeImport(upath.relative(outDir, resolvedNoExt));
+        const relImport = await resolveRouteImport(aliasedNoExtPath);
+        if (!relImport) return null;
         const importName = 'validateSearch' === exportName ? `validateSearch_${validateSearchIndex++}` : `loaderDeps_${loaderDepsIndex++}`;
         imports.push(`import { ${exportName} as ${importName} } from ${quote(relImport)};`);
         searchContractImportMap.set(key, importName);
@@ -97,9 +89,7 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         const base = id ? makeLegalIdentifier(id) : `r_${routeIndex++}`;
         return reserveRouteVarName(`route_${base}`);
     };
-    const buildRoute = async (opts)=>{
-        const { parentVar, route } = opts;
-        const varName = createRouteVarName(route);
+    const createRouteOptions = async (route, hasSplat)=>{
         const routeExtras = route;
         const loaderInfo = pickModernLoaderModule(route);
         const routeAction = routeExtras.action;
@@ -109,20 +99,9 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         const searchContractInfo = pickRouteSearchContractModules(route);
         const validateSearchName = searchContractInfo.validateSearchPath ? await getImportNameForSearchContract(searchContractInfo.validateSearchPath, 'validateSearch') : null;
         const loaderDepsName = searchContractInfo.loaderDepsPath ? await getImportNameForSearchContract(searchContractInfo.loaderDepsPath, 'loaderDeps') : null;
-        const rawPath = routeExtras.path;
-        const hasSplat = 'string' == typeof rawPath && rawPath.includes('*');
-        const routeOpts = [
-            `getParentRoute: () => ${parentVar},`
-        ];
+        const routeOpts = [];
         const componentName = await getImportNameForComponent(routeExtras._component);
         if (componentName) routeOpts.push(`component: ${componentName},`);
-        if (isPathlessLayout(route)) {
-            const id = routeExtras.id;
-            routeOpts.push(`id: ${quote(id || 'pathless')},`);
-        } else {
-            const p = isIndexRoute(route) ? '/' : toTanstackPath(rawPath || '');
-            routeOpts.push(`path: ${quote(p)},`);
-        }
         if (loaderName) routeOpts.push(`loader: modernLoaderToTanstack({ hasSplat: ${hasSplat} }, ${loaderName}),`);
         if (validateSearchName) routeOpts.push(`validateSearch: ${validateSearchName},`);
         if (loaderDepsName) routeOpts.push(`loaderDeps: ${loaderDepsName},`);
@@ -132,39 +111,29 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             actionName
         });
         if (staticDataSnippet) routeOpts.push(staticDataSnippet);
-        const children = routeExtras.children;
+        return routeOpts;
+    };
+    const buildRoute = async (descriptor, parentVar)=>{
+        const { source: route, location, hasSplat, children } = descriptor;
+        const varName = createRouteVarName(route);
+        const routeOpts = [
+            `getParentRoute: () => ${parentVar},`,
+            ...Object.entries(location).map(([key, value])=>`${key}: ${quote(value)},`),
+            ...await createRouteOptions(route, hasSplat)
+        ];
         const hasChildren = Boolean(children && children.length > 0);
         const routeCtorVarName = hasChildren ? reserveRouteVarName(`${varName}__base`) : varName;
         statements.push(`const ${routeCtorVarName} = createRoute({\n  ${routeOpts.join('\n  ')}\n});`);
         if (children && children.length > 0) {
             const childVars = [];
-            for (const child of children)childVars.push(await buildRoute({
-                parentVar: routeCtorVarName,
-                route: child
-            }));
+            for (const child of children)childVars.push(await buildRoute(child, routeCtorVarName));
             statements.push(`const ${varName} = ${routeCtorVarName}.addChildren([${childVars.join(', ')}]);`);
         }
         return varName;
     };
-    const rootLoaderInfo = rootModern ? pickModernLoaderModule(rootModern) : null;
-    const rootAction = rootExtras?.action;
-    const rootLoaderImports = rootLoaderInfo?.loaderPath ? await getImportNamesForLoader(rootLoaderInfo.loaderPath, rootLoaderInfo.inline, Boolean(rootLoaderInfo.inline && rootAction === rootLoaderInfo.loaderPath)) : null;
-    const rootLoaderName = rootLoaderImports?.loaderName || null;
-    const rootActionName = rootLoaderImports?.actionName || null;
-    const rootSearchContractInfo = rootModern ? pickRouteSearchContractModules(rootModern) : null;
-    const rootValidateSearchName = rootSearchContractInfo?.validateSearchPath ? await getImportNameForSearchContract(rootSearchContractInfo.validateSearchPath, 'validateSearch') : null;
-    const rootLoaderDepsName = rootSearchContractInfo?.loaderDepsPath ? await getImportNameForSearchContract(rootSearchContractInfo.loaderDepsPath, 'loaderDeps') : null;
     const topLevelVars = [];
-    for (const route of topLevel)topLevelVars.push(await buildRoute({
-        parentVar: 'rootRoute',
-        route
-    }));
-    const rootOpts = [];
-    const rootComponentName = await getImportNameForComponent(rootExtras?._component);
-    if (rootComponentName) rootOpts.push(`component: ${rootComponentName},`);
-    if (rootLoaderName) rootOpts.push(`loader: modernLoaderToTanstack({ hasSplat: false }, ${rootLoaderName}),`);
-    if (rootValidateSearchName) rootOpts.push(`validateSearch: ${rootValidateSearchName},`);
-    if (rootLoaderDepsName) rootOpts.push(`loaderDeps: ${rootLoaderDepsName},`);
+    for (const route of topLevel)topLevelVars.push(await buildRoute(route, 'rootRoute'));
+    const rootOpts = rootModern ? await createRouteOptions(rootModern, false) : [];
     const routerGenTs = `// This file is auto-generated by Modern.js. Do not edit manually.
 
 import {
@@ -181,11 +150,7 @@ ${imports.join('\n')}
 
 export const rootRoute = createRootRouteWithContext<ModernRouterContext>()({
   ${rootOpts.join('\n  ')}
-  ${createRouteStaticDataSnippet({
-        modernRouteId: rootExtras?.id,
-        loaderName: rootLoaderName,
-        actionName: rootActionName
-    }) || ''}
+
 });
 
 ${statements.join('\n\n')}

package/dist/esm/runtime/lifecycle.mjs

@@ -1 +1 @@
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterRuntimeState, createRouterServerSnapshot, getRouterRuntimeState, getRouterServerSnapshot } from "@modern-js/runtime-extensions/router-state";
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterServerSnapshot, getRouterRuntimeState, getRouterServerSnapshot } from "@modern-js/runtime-extensions/router-state";

package/dist/esm/runtime/loaderBridge.mjs

@@ -36,10 +36,13 @@ function mapSplatParamsForModernLoader(params, hasSplat) {
     return rest;
 }
 function getLoaderSignal(ctx) {
-    const abortSignal = ctx?.abortController?.signal;
-    if (abortSignal instanceof AbortSignal) return abortSignal;
-    if (ctx?.signal instanceof AbortSignal) return ctx.signal;
-    return new AbortController().signal;
+    const matchSignal = ctx?.abortController?.signal ?? ctx?.signal;
+    const requestSignal = ctx?.context?.request?.signal;
+    const signals = [
+        matchSignal,
+        requestSignal
+    ].filter((signal)=>signal instanceof AbortSignal);
+    return AbortSignal.any(signals);
 }
 function getLoaderHref(ctx) {
     if ('string' == typeof ctx?.location) return ctx.location;
@@ -101,4 +104,4 @@ function modernLoaderToTanstack(opts, modernLoader) {
     };
 }
 export { createRouteStaticData } from "../shared/routeStaticData.mjs";
-export { getLoaderHref, handleModernLoaderError, handleModernLoaderResult, isAbsoluteUrl, isRedirectResponse, isResponse, isTanstackRedirect, mapSplatParamsForModernLoader, modernLoaderToTanstack, throwTanstackRedirect };
+export { getLoaderHref, getLoaderSignal, handleModernLoaderError, handleModernLoaderResult, isAbsoluteUrl, isRedirectResponse, isResponse, isTanstackRedirect, mapSplatParamsForModernLoader, modernLoaderToTanstack, throwTanstackRedirect };

package/dist/esm/runtime/navigation.mjs

@@ -0,0 +1,64 @@
+import { Link } from "./prefetchLink.mjs";
+function createTanstackNavigation(router) {
+    let location;
+    let matches;
+    let snapshot;
+    return {
+        Link: Link,
+        getSnapshot () {
+            const state = router.state;
+            if (location !== state.location || void 0 === matches || matches.length !== state.matches.length || matches.some((match, index)=>match.params !== state.matches[index]?.params)) {
+                location = state.location;
+                matches = state.matches;
+                snapshot = {
+                    location: {
+                        pathname: location.pathname,
+                        search: location.searchStr,
+                        hash: '' !== location.hash ? `#${location.hash.replace(/^#/, '')}` : ''
+                    },
+                    params: Object.assign({}, ...matches.map((match)=>match.params))
+                };
+            }
+            return snapshot;
+        },
+        subscribe (listener) {
+            const stops = [
+                'onBeforeNavigate',
+                'onBeforeLoad',
+                'onLoad',
+                'onResolved'
+            ].map((event)=>router.subscribe(event, listener));
+            return ()=>{
+                for (const stop of stops)stop();
+            };
+        },
+        navigate (href, options) {
+            return router.navigate({
+                to: href,
+                replace: options?.replace,
+                ...options?.state === void 0 ? {} : {
+                    state: options.state
+                }
+            });
+        },
+        createLinkProps (target) {
+            const preload = void 0 !== target.preload ? target.preload : 'none' === target.prefetch ? false : target.prefetch;
+            return {
+                to: target.pathname,
+                ...void 0 !== target.search ? {
+                    search: target.search
+                } : {},
+                ...void 0 !== target.hash && '' !== target.hash ? {
+                    hash: target.hash
+                } : {},
+                ...void 0 === target.hashScrollIntoView ? {} : {
+                    hashScrollIntoView: target.hashScrollIntoView
+                },
+                ...void 0 === preload ? {} : {
+                    preload
+                }
+            };
+        }
+    };
+}
+export { createTanstackNavigation };

package/dist/esm/runtime/plugin.mjs

@@ -10,6 +10,7 @@ import { ModernRouterClient, getTanstackSsrHydrationPromise, hasTanstackSsrHydra
 import { routerProviderRegistryHooks } from "./hooks.mjs";
 import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
 import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { createTanstackNavigation } from "./navigation.mjs";
 import { createTanstackRouteObjects, getMergedRouterConfig, getTanstackRouteConfig, joinBasename } from "./pluginShared.mjs";
 import { Link } from "./prefetchLink.mjs";
 import { useMatches } from "./routeHooks.mjs";
@@ -142,10 +143,14 @@ const tanstackRouterPlugin = (userConfig = {})=>{
                         runtimeContext
                     ]);
                     if (!router) return App ? /*#__PURE__*/ jsx(App, {}) : null;
+                    const navigation = useMemo(()=>createTanstackNavigation(router), [
+                        router
+                    ]);
                     const runtimeState = applyRouterRuntimeState(runtimeContext, {
                         framework: 'tanstack',
                         basename: _basename,
-                        instance: router
+                        instance: router,
+                        navigation
                     });
                     const lifecycleContext = {
                         framework: 'tanstack',