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

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

@@ -0,0 +1,207 @@
+import node_path from "node:path";
+import { makeLegalIdentifier } from "@modern-js/runtime/cli";
+import { createRouteStaticDataSnippet, isIndexRoute, isPathlessLayout, normalizeRelativeImport, pickModernLoaderModule, pickRouteSearchContractModules, quote, resolveFileNoExt, toTanstackPath } from "./shared.mjs";
+async function generateTanstackRouterTypesSourceForEntry(opts) {
+    const { appContext, entryName, generatedDirName = 'modern-tanstack', routes } = opts;
+    const outDir = node_path.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 imports = [];
+    const statements = [];
+    const loaderImportMap = new Map();
+    const componentImportMap = new Map();
+    const searchContractImportMap = new Map();
+    const usedRouteVarNames = new Set();
+    let loaderIndex = 0;
+    let componentIndex = 0;
+    let validateSearchIndex = 0;
+    let loaderDepsIndex = 0;
+    let routeIndex = 0;
+    const getImportNameForComponent = (componentPath)=>{
+        if ('string' != typeof componentPath || 0 === componentPath.length) return Promise.resolve(null);
+        let pendingImportName = componentImportMap.get(componentPath);
+        if (!pendingImportName) {
+            pendingImportName = (async ()=>{
+                const resolvedNoExt = await resolveRouteModuleNoExt(componentPath);
+                if (!resolvedNoExt) return null;
+                const relImport = normalizeRelativeImport(node_path.relative(outDir, resolvedNoExt));
+                const componentName = `component_${componentIndex++}`;
+                imports.push(`import ${componentName} from ${quote(relImport)};`);
+                return componentName;
+            })();
+            componentImportMap.set(componentPath, pendingImportName);
+        }
+        return pendingImportName;
+    };
+    const resolveRouteModuleNoExt = async (aliasedNoExtPath)=>{
+        const prefix = `${appContext.internalSrcAlias}/`;
+        let absNoExt;
+        if (aliasedNoExtPath.startsWith(prefix)) {
+            const rel = aliasedNoExtPath.slice(prefix.length);
+            absNoExt = node_path.join(appContext.srcDirectory, rel);
+        } else absNoExt = node_path.isAbsolute(aliasedNoExtPath) ? aliasedNoExtPath : node_path.join(appContext.srcDirectory, aliasedNoExtPath);
+        return resolveFileNoExt(absNoExt);
+    };
+    const getImportNamesForLoader = async (aliasedNoExtPath, inline, hasAction)=>{
+        const key = `${inline ? 'inline' : 'default'}:${hasAction ? 'action' : 'loader'}:${aliasedNoExtPath}`;
+        const existing = loaderImportMap.get(key);
+        if (existing) return {
+            loaderName: existing,
+            actionName: hasAction ? existing.replace(/^loader_/, 'action_') : null
+        };
+        const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
+        if (!resolvedNoExt) return null;
+        const relImport = normalizeRelativeImport(node_path.relative(outDir, resolvedNoExt));
+        const importName = `loader_${loaderIndex++}`;
+        const actionName = hasAction ? importName.replace(/^loader_/, 'action_') : null;
+        if (inline) {
+            const specifiers = [
+                `loader as ${importName}`
+            ];
+            if (actionName) specifiers.push(`action as ${actionName}`);
+            imports.push(`import { ${specifiers.join(', ')} } from ${quote(relImport)};`);
+        } else imports.push(`import ${importName} from ${quote(relImport)};`);
+        loaderImportMap.set(key, importName);
+        return {
+            loaderName: importName,
+            actionName
+        };
+    };
+    const getImportNameForSearchContract = async (aliasedNoExtPath, exportName)=>{
+        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(node_path.relative(outDir, resolvedNoExt));
+        const importName = 'validateSearch' === exportName ? `validateSearch_${validateSearchIndex++}` : `loaderDeps_${loaderDepsIndex++}`;
+        imports.push(`import { ${exportName} as ${importName} } from ${quote(relImport)};`);
+        searchContractImportMap.set(key, importName);
+        return importName;
+    };
+    const reserveRouteVarName = (preferred)=>{
+        let candidate = preferred;
+        let suffix = 1;
+        while(usedRouteVarNames.has(candidate))candidate = `${preferred}_${suffix++}`;
+        usedRouteVarNames.add(candidate);
+        return candidate;
+    };
+    const createRouteVarName = (route)=>{
+        const id = route.id;
+        const base = id ? makeLegalIdentifier(id) : `r_${routeIndex++}`;
+        return reserveRouteVarName(`route_${base}`);
+    };
+    const buildRoute = async (opts)=>{
+        const { parentVar, route } = opts;
+        const varName = createRouteVarName(route);
+        const routeExtras = route;
+        const loaderInfo = pickModernLoaderModule(route);
+        const routeAction = routeExtras.action;
+        const loaderImports = loaderInfo ? await getImportNamesForLoader(loaderInfo.loaderPath, loaderInfo.inline, Boolean(loaderInfo.inline && routeAction === loaderInfo.loaderPath)) : null;
+        const loaderName = loaderImports?.loaderName || null;
+        const actionName = loaderImports?.actionName || null;
+        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 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},`);
+        const staticDataSnippet = createRouteStaticDataSnippet({
+            modernRouteId: routeExtras.id,
+            loaderName,
+            actionName
+        });
+        if (staticDataSnippet) routeOpts.push(staticDataSnippet);
+        const children = routeExtras.children;
+        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
+            }));
+            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},`);
+    const routerGenTs = `// This file is auto-generated by Modern.js. Do not edit manually.
+
+import {
+  createMemoryHistory,
+  createRootRouteWithContext,
+  createRoute,
+  createRouter,
+  createRouteStaticData,
+  type ModernRouterContext,
+  modernLoaderToTanstack,
+  modernTanstackRouterFastDefaults,
+} from '@modern-js/plugin-tanstack/runtime';
+
+${imports.join('\n')}
+
+export const rootRoute = createRootRouteWithContext<ModernRouterContext>()({
+  ${rootOpts.join('\n  ')}
+  ${createRouteStaticDataSnippet({
+        modernRouteId: rootExtras?.id,
+        loaderName: rootLoaderName,
+        actionName: rootActionName
+    }) || ''}
+});
+
+${statements.join('\n\n')}
+
+export const routeTree = rootRoute.addChildren([${topLevelVars.join(', ')}]);
+
+export const router = createRouter({
+  ...modernTanstackRouterFastDefaults,
+  routeTree,
+  history: createMemoryHistory({
+    initialEntries: ['/'],
+  }),
+  context: {} as ModernRouterContext,
+});
+`;
+    return {
+        routerGenTs
+    };
+}
+export { generateTanstackRouterTypesSourceForEntry };

package/dist/esm/cli/tanstackTypes.mjs

@@ -1,339 +1,2 @@
-import { getPathWithoutExt, makeLegalIdentifier } from "@modern-js/runtime/cli";
-import { findExists, formatImportPath, slash } from "@modern-js/utils";
-import path from "path";
-const JS_OR_TS_EXTS = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-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('/');
-}
-async function resolveFileNoExt(inputNoExtPath) {
-    const file = findExists(JS_OR_TS_EXTS.map((ext)=>`${inputNoExtPath}${ext}`));
-    return file ? getPathWithoutExt(file) : null;
-}
-function quote(str) {
-    return JSON.stringify(str);
-}
-function normalizeRelativeImport(p) {
-    const normalized = formatImportPath(slash(p));
-    if (normalized.startsWith('.')) return normalized;
-    return `./${normalized}`;
-}
-function pickModernLoaderModule(route) {
-    const loaderPath = route.data || route.loader;
-    if (!loaderPath || 'string' != typeof loaderPath) return null;
-    const inline = Boolean(route.data);
-    return {
-        loaderPath,
-        inline
-    };
-}
-function pickRouteSearchContractModules(route) {
-    const validateSearchPath = route.validateSearch;
-    const loaderDepsPath = route.loaderDeps;
-    return {
-        validateSearchPath: 'string' == typeof validateSearchPath ? validateSearchPath : null,
-        loaderDepsPath: 'string' == typeof loaderDepsPath ? loaderDepsPath : null
-    };
-}
-function isPathlessLayout(route) {
-    return 'nested' === route.type && 'boolean' != typeof route.index && void 0 === route.path;
-}
-function isIndexRoute(route) {
-    return 'nested' === route.type && Boolean(route.index);
-}
-function createRouteStaticDataSnippet(opts) {
-    const staticDataLines = [];
-    if (opts.modernRouteId) staticDataLines.push(`modernRouteId: ${quote(opts.modernRouteId)},`);
-    if (opts.loaderName) staticDataLines.push(`modernRouteLoader: ${opts.loaderName},`);
-    if (opts.actionName) staticDataLines.push(`modernRouteAction: ${opts.actionName},`);
-    if (!staticDataLines.length) return null;
-    return `staticData: createRouteStaticData({\n    ${staticDataLines.join('\n    ')}\n  }),`;
-}
-const LOCALE_PARAM_SEGMENTS = new Set([
-    ':lang',
-    ':locale',
-    ':language',
-    '$lang',
-    '$locale',
-    '$language'
-]);
-function paramsTypeForCanonicalPath(canonicalPath) {
-    const fields = [];
-    for (const segment of canonicalPath.split('/'))if (segment) {
-        if ('*' === segment || '$' === segment) {
-            fields.push("'_splat'?: string");
-            continue;
-        }
-        if (segment.startsWith('{-$') && segment.endsWith('}')) {
-            fields.push(`${JSON.stringify(segment.slice(3, -1))}?: string`);
-            continue;
-        }
-        if (segment.startsWith('$')) {
-            fields.push(`${JSON.stringify(segment.slice(1))}: string`);
-            continue;
-        }
-        if (segment.startsWith(':')) {
-            const optional = segment.endsWith('?');
-            const name = segment.slice(1, optional ? void 0 : segment.length);
-            fields.push(`${JSON.stringify(optional ? name.slice(0, -1) : name)}${optional ? '?' : ''}: string`);
-        }
-    }
-    return fields.length > 0 ? `{ ${fields.join('; ')} }` : 'Record<string, never>';
-}
-function collectCanonicalRoutesForEntry(routes, options = {}) {
-    const { localeParamHeuristic = true } = options;
-    const canonicalParams = new Map();
-    let hasI18nSurface = false;
-    const normalizeJoined = (joined)=>{
-        const collapsed = joined.replace(/\/+/g, '/');
-        const withLeading = collapsed.startsWith('/') ? collapsed : `/${collapsed}`;
-        return withLeading.length > 1 ? withLeading.replace(/\/+$/, '') : withLeading;
-    };
-    const record = (canonicalPath)=>{
-        const normalized = normalizeJoined(canonicalPath || '/');
-        const key = toTanstackPath(normalized);
-        if (!canonicalParams.has(key)) canonicalParams.set(key, paramsTypeForCanonicalPath(normalized));
-    };
-    const visit = (route, parentPath)=>{
-        let currentPath = parentPath;
-        if ('string' == typeof route.modernCanonicalPath) {
-            hasI18nSurface = true;
-            currentPath = normalizeJoined(route.modernCanonicalPath);
-        } 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])) {
-                hasI18nSurface = true;
-                segments.shift();
-            }
-            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, '');
-    if (!hasI18nSurface || 0 === canonicalParams.size) return null;
-    return Object.fromEntries([
-        ...canonicalParams.entries()
-    ].sort(([a], [b])=>a.localeCompare(b)));
-}
-async function generateTanstackRouterTypesSourceForEntry(opts) {
-    const { appContext, entryName, generatedDirName = 'modern-tanstack', routes } = opts;
-    const outDir = path.join(appContext.srcDirectory, generatedDirName, entryName);
-    const rootModern = routes.find((r)=>r && 'nested' === r.type && r.isRoot);
-    const topLevel = rootModern ? rootModern.children || [] : routes;
-    const imports = [];
-    const statements = [];
-    const loaderImportMap = new Map();
-    const componentImportMap = new Map();
-    const searchContractImportMap = new Map();
-    const usedRouteVarNames = new Set();
-    let loaderIndex = 0;
-    let componentIndex = 0;
-    let validateSearchIndex = 0;
-    let loaderDepsIndex = 0;
-    let routeIndex = 0;
-    const getImportNameForComponent = (componentPath)=>{
-        if ('string' != typeof componentPath || 0 === componentPath.length) return Promise.resolve(null);
-        let pendingImportName = componentImportMap.get(componentPath);
-        if (!pendingImportName) {
-            pendingImportName = (async ()=>{
-                const resolvedNoExt = await resolveRouteModuleNoExt(componentPath);
-                if (!resolvedNoExt) return null;
-                const relImport = normalizeRelativeImport(path.relative(outDir, resolvedNoExt));
-                const componentName = `component_${componentIndex++}`;
-                imports.push(`import ${componentName} from ${quote(relImport)};`);
-                return componentName;
-            })();
-            componentImportMap.set(componentPath, pendingImportName);
-        }
-        return pendingImportName;
-    };
-    const resolveRouteModuleNoExt = async (aliasedNoExtPath)=>{
-        const prefix = `${appContext.internalSrcAlias}/`;
-        let absNoExt;
-        if (aliasedNoExtPath.startsWith(prefix)) {
-            const rel = aliasedNoExtPath.slice(prefix.length);
-            absNoExt = path.join(appContext.srcDirectory, rel);
-        } else absNoExt = path.isAbsolute(aliasedNoExtPath) ? aliasedNoExtPath : path.join(appContext.srcDirectory, aliasedNoExtPath);
-        return resolveFileNoExt(absNoExt);
-    };
-    const getImportNamesForLoader = async (aliasedNoExtPath, inline, hasAction)=>{
-        const key = `${inline ? 'inline' : 'default'}:${hasAction ? 'action' : 'loader'}:${aliasedNoExtPath}`;
-        const existing = loaderImportMap.get(key);
-        if (existing) return {
-            loaderName: existing,
-            actionName: hasAction ? existing.replace(/^loader_/, 'action_') : null
-        };
-        const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
-        if (!resolvedNoExt) return null;
-        const relImport = normalizeRelativeImport(path.relative(outDir, resolvedNoExt));
-        const importName = `loader_${loaderIndex++}`;
-        const actionName = hasAction ? importName.replace(/^loader_/, 'action_') : null;
-        if (inline) {
-            const specifiers = [
-                `loader as ${importName}`
-            ];
-            if (actionName) specifiers.push(`action as ${actionName}`);
-            imports.push(`import { ${specifiers.join(', ')} } from ${quote(relImport)};`);
-        } else imports.push(`import ${importName} from ${quote(relImport)};`);
-        loaderImportMap.set(key, importName);
-        return {
-            loaderName: importName,
-            actionName
-        };
-    };
-    const getImportNameForSearchContract = async (aliasedNoExtPath, exportName)=>{
-        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(path.relative(outDir, resolvedNoExt));
-        const importName = 'validateSearch' === exportName ? `validateSearch_${validateSearchIndex++}` : `loaderDeps_${loaderDepsIndex++}`;
-        imports.push(`import { ${exportName} as ${importName} } from ${quote(relImport)};`);
-        searchContractImportMap.set(key, importName);
-        return importName;
-    };
-    const reserveRouteVarName = (preferred)=>{
-        let candidate = preferred;
-        let suffix = 1;
-        while(usedRouteVarNames.has(candidate))candidate = `${preferred}_${suffix++}`;
-        usedRouteVarNames.add(candidate);
-        return candidate;
-    };
-    const createRouteVarName = (route)=>{
-        const id = route.id;
-        const base = id ? makeLegalIdentifier(id) : `r_${routeIndex++}`;
-        return reserveRouteVarName(`route_${base}`);
-    };
-    const buildRoute = async (opts)=>{
-        const { parentVar, route } = opts;
-        const varName = createRouteVarName(route);
-        const loaderInfo = pickModernLoaderModule(route);
-        const routeAction = route.action;
-        const loaderImports = loaderInfo ? await getImportNamesForLoader(loaderInfo.loaderPath, loaderInfo.inline, Boolean(loaderInfo.inline && routeAction === loaderInfo.loaderPath)) : null;
-        const loaderName = loaderImports?.loaderName || null;
-        const actionName = loaderImports?.actionName || null;
-        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 = route.path;
-        const hasSplat = 'string' == typeof rawPath && rawPath.includes('*');
-        const routeOpts = [
-            `getParentRoute: () => ${parentVar},`
-        ];
-        const componentName = await getImportNameForComponent(route._component);
-        if (componentName) routeOpts.push(`component: ${componentName},`);
-        if (isPathlessLayout(route)) {
-            const id = route.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},`);
-        const staticDataSnippet = createRouteStaticDataSnippet({
-            modernRouteId: route.id,
-            loaderName,
-            actionName
-        });
-        if (staticDataSnippet) routeOpts.push(staticDataSnippet);
-        const children = route.children;
-        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 = await Promise.all(children.map((child)=>buildRoute({
-                    parentVar: routeCtorVarName,
-                    route: child
-                })));
-            statements.push(`const ${varName} = ${routeCtorVarName}.addChildren([${childVars.join(', ')}]);`);
-        }
-        return varName;
-    };
-    const rootLoaderInfo = rootModern ? pickModernLoaderModule(rootModern) : null;
-    const rootAction = rootModern?.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 = await Promise.all(topLevel.map((route)=>buildRoute({
-            parentVar: 'rootRoute',
-            route
-        })));
-    const rootOpts = [];
-    const rootComponentName = await getImportNameForComponent(rootModern?._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},`);
-    const routerGenTs = `/* eslint-disable */
-// This file is auto-generated by Modern.js. Do not edit manually.
-
-import {
-  createMemoryHistory,
-  createRootRouteWithContext,
-  createRoute,
-  createRouter,
-  createRouteStaticData,
-  type ModernRouterContext,
-  modernLoaderToTanstack,
-  modernTanstackRouterFastDefaults,
-} from '@modern-js/plugin-tanstack/runtime';
-
-${imports.join('\n')}
-
-export const rootRoute = createRootRouteWithContext<ModernRouterContext>()({
-  ${rootOpts.join('\n  ')}
-  ${createRouteStaticDataSnippet({
-        modernRouteId: rootModern?.id,
-        loaderName: rootLoaderName,
-        actionName: rootActionName
-    }) || ''}
-});
-
-${statements.join('\n\n')}
-
-export const routeTree = rootRoute.addChildren([${topLevelVars.join(', ')}]);
-
-export const router = createRouter({
-  ...modernTanstackRouterFastDefaults,
-  routeTree,
-  history: createMemoryHistory({
-    initialEntries: ['/'],
-  }),
-  context: {} as ModernRouterContext,
-});
-`;
-    return {
-        routerGenTs
-    };
-}
-export { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry };
+export { collectCanonicalRoutesForEntry } from "./tanstackTypes/canonicalRoutes.mjs";
+export { generateTanstackRouterTypesSourceForEntry } from "./tanstackTypes/source.mjs";

package/dist/esm/runtime/blockingSubscribe.mjs

@@ -0,0 +1,19 @@
+const BLOCKING_SUBSCRIBE_SYMBOL = Symbol.for('@modern-js/plugin-tanstack:blocking-subscribe');
+const BLOCKING_STATE_SYMBOL = Symbol.for('@modern-js/plugin-tanstack:blocking-state');
+function wrapRouterSubscribeWithBlockState(router, getBlockNavState) {
+    if (!router || 'object' != typeof router) return;
+    const target = router;
+    target[BLOCKING_STATE_SYMBOL] = getBlockNavState;
+    if (target[BLOCKING_SUBSCRIBE_SYMBOL] || 'function' != typeof target.subscribe) return;
+    const originSubscribe = target.subscribe.bind(target);
+    target.subscribe = (eventType, listener)=>{
+        const wrappedListener = (...args)=>{
+            const blockRoute = target[BLOCKING_STATE_SYMBOL]?.() || false;
+            if (blockRoute) return;
+            return listener(...args);
+        };
+        return originSubscribe(eventType, wrappedListener);
+    };
+    target[BLOCKING_SUBSCRIBE_SYMBOL] = true;
+}
+export { wrapRouterSubscribeWithBlockState };

package/dist/esm/runtime/clientBasepath.mjs

@@ -0,0 +1,10 @@
+function normalizeBase(b) {
+    if (b.length > 1 && b.endsWith('/')) return b.slice(0, -1);
+    return b || '/';
+}
+function isSegmentPrefix(pathname, base) {
+    const b = normalizeBase(base);
+    const p = pathname || '/';
+    return p === b || p.startsWith(`${b}/`);
+}
+export { isSegmentPrefix };

package/dist/esm/runtime/clientHydration.mjs

@@ -0,0 +1,71 @@
+import { RouterProvider } from "@tanstack/react-router";
+import { createElement } from "react";
+import { withModernRouteMatchContext } from "./outlet.mjs";
+import { pickRouteModuleComponent } from "./routeTree.mjs";
+const routerHydrationRecords = new WeakMap();
+const routeModulesKey = '_routeModules';
+function getCachedRouteModule(routeId) {
+    if ("u" < typeof window) return;
+    return window[routeModulesKey]?.[routeId];
+}
+function preloadHydratedRouteComponents(router) {
+    const preloadableRouter = router;
+    const routesById = preloadableRouter.routesById || {};
+    const matches = preloadableRouter.stores.matches.get();
+    return Promise.all(matches.map((match)=>{
+        if (void 0 === match.routeId || '' === match.routeId) return;
+        const route = routesById[match.routeId];
+        const component = route?.options?.component;
+        const preload = component?.load || component?.preload;
+        if ('function' != typeof preload) return;
+        return Promise.resolve(preload.call(component)).then((routeModule)=>{
+            const modernRouteId = route?.options?.staticData?.modernRouteId;
+            const cachedRouteModule = 'string' == typeof modernRouteId && '' !== modernRouteId ? getCachedRouteModule(modernRouteId) : void 0;
+            const resolvedComponent = pickRouteModuleComponent(cachedRouteModule ?? routeModule);
+            if (void 0 !== resolvedComponent && 'string' == typeof modernRouteId && '' !== modernRouteId) route.options.component = withModernRouteMatchContext(resolvedComponent, modernRouteId);
+        });
+    })).then(()=>void 0);
+}
+function hydrateTanstackRouter(router) {
+    return import("@tanstack/react-router/ssr/client").then(({ hydrate })=>hydrate(router));
+}
+function getTanstackSsrHydrationRecord(router) {
+    const existingHydrationRecord = routerHydrationRecords.get(router);
+    if (void 0 !== existingHydrationRecord) return existingHydrationRecord;
+    const hydrationRecord = {
+        promise: Promise.resolve(),
+        status: 'pending'
+    };
+    routerHydrationRecords.set(router, hydrationRecord);
+    try {
+        hydrationRecord.promise = hydrateTanstackRouter(router).then((value)=>preloadHydratedRouteComponents(router).then(()=>value)).then((value)=>{
+            hydrationRecord.status = 'fulfilled';
+            return value;
+        }, (error)=>{
+            hydrationRecord.status = 'rejected';
+            hydrationRecord.error = error;
+            throw error;
+        });
+    } catch (error) {
+        hydrationRecord.status = 'rejected';
+        hydrationRecord.error = error;
+        hydrationRecord.promise = Promise.reject(error);
+        hydrationRecord.promise.catch(()=>{});
+    }
+    return hydrationRecord;
+}
+function getTanstackSsrHydrationPromise(router) {
+    return getTanstackSsrHydrationRecord(router).promise;
+}
+function hasTanstackSsrHydrationRecord(router) {
+    return routerHydrationRecords.has(router);
+}
+function ModernRouterClient({ router }) {
+    const hydrationRecord = getTanstackSsrHydrationRecord(router);
+    if ('pending' === hydrationRecord.status) throw hydrationRecord.promise;
+    if ('rejected' === hydrationRecord.status) throw hydrationRecord.error;
+    return createElement(RouterProvider, {
+        router
+    });
+}
+export { ModernRouterClient, getTanstackSsrHydrationPromise, hasTanstackSsrHydrationRecord, hydrateTanstackRouter };