@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

package/dist/esm/runtime/ssrPreload.mjs

@@ -0,0 +1,51 @@
+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, preloadedComponents) {
+    if (isReactLazyRouteComponent(component)) {
+        if (preloadedComponents.has(component)) return;
+        preloadedComponents.add(component);
+        await preloadReactLazyRouteComponent(component);
+        return;
+    }
+    if (!isPreloadableRouteComponent(component)) return;
+    if (preloadedComponents.has(component)) return;
+    preloadedComponents.add(component);
+    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 || {};
+    const preloadedComponents = new Set();
+    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, preloadedComponents),
+            preloadRouteComponent(options.pendingComponent, preloadedComponents),
+            preloadRouteComponent(options.errorComponent, preloadedComponents),
+            preloadRouteComponent(options.notFoundComponent, preloadedComponents)
+        ]);
+    }));
+}
+export { preloadMatchedRouteComponents };

package/dist/esm/runtime/submitAction.mjs

@@ -0,0 +1,120 @@
+import { formDataToTextPlain, formDataToUrlSearchParams, toFormData } from "./formData.mjs";
+class RouteActionResponseError extends Error {
+    constructor(response, data){
+        super(`Route action failed with status ${response.status}`);
+        this.name = 'RouteActionResponseError';
+        this.response = response;
+        this.data = data;
+    }
+}
+function resolveRouteHandlers(router, actionTo) {
+    const builtLocation = router.buildLocation({
+        to: actionTo
+    });
+    const href = router.getParsedLocationHref(builtLocation);
+    const matchedRoutes = router.getMatchedRoutes(builtLocation.pathname);
+    const routeStaticData = matchedRoutes.foundRoute?.options?.staticData;
+    const action = routeStaticData?.modernRouteAction;
+    const loader = routeStaticData?.modernRouteLoader;
+    return {
+        action,
+        loader,
+        href,
+        params: matchedRoutes.routeParams || {}
+    };
+}
+function isRedirectResponse(value) {
+    if (!(value instanceof Response)) return false;
+    return [
+        301,
+        302,
+        303,
+        307,
+        308
+    ].includes(value.status);
+}
+async function parseResponseData(response) {
+    if (204 === response.status) return null;
+    const contentType = response.headers.get('Content-Type') || '';
+    if (contentType.includes('application/json')) return response.json();
+    return response.text();
+}
+async function parseResponseResultOrThrow(response) {
+    const parsed = await parseResponseData(response);
+    if (!response.ok) throw new RouteActionResponseError(response, parsed);
+    return parsed;
+}
+async function submitRouteAction({ router, target, options = {}, isFetcher = false, onInvalidateStart }) {
+    const method = (options.method || 'post').toLowerCase();
+    const encType = options.encType || 'application/x-www-form-urlencoded';
+    const actionTo = options.action || '.';
+    const formData = toFormData(target);
+    const resolved = resolveRouteHandlers(router, actionTo);
+    if ('get' === method) {
+        const search = formDataToUrlSearchParams(formData).toString();
+        const requestUrl = new URL(resolved.href, window.location.origin);
+        requestUrl.search = search;
+        if (isFetcher && resolved.loader) {
+            const result = await resolved.loader({
+                request: new Request(requestUrl, {
+                    method: 'GET'
+                }),
+                params: resolved.params
+            });
+            if (result instanceof Response) {
+                const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+                if (redirectTo || isRedirectResponse(result)) {
+                    await router.navigate({
+                        to: redirectTo || '/'
+                    });
+                    return parseResponseData(result);
+                }
+                return parseResponseResultOrThrow(result);
+            }
+            return result;
+        }
+        await router.navigate({
+            href: `${requestUrl.pathname}${requestUrl.search}${requestUrl.hash}`
+        });
+        return;
+    }
+    if (!resolved.action) throw new Error(`No route action found for "${actionTo}"`);
+    const headers = new Headers();
+    let body = null;
+    if (encType.includes('application/json')) {
+        headers.set('Content-Type', 'application/json');
+        body = JSON.stringify(Object.fromEntries(formDataToUrlSearchParams(formData).entries()));
+    } else if (encType.includes('text/plain')) {
+        headers.set('Content-Type', 'text/plain;charset=UTF-8');
+        body = formDataToTextPlain(formData);
+    } else if (encType.includes('application/x-www-form-urlencoded')) {
+        headers.set('Content-Type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        body = formDataToUrlSearchParams(formData);
+    } else body = formData;
+    const request = new Request(new URL(resolved.href, window.location.origin), {
+        method: method.toUpperCase(),
+        headers,
+        body
+    });
+    const result = await resolved.action({
+        request,
+        params: resolved.params
+    });
+    if (result instanceof Response) {
+        const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+        if (redirectTo || isRedirectResponse(result)) {
+            await router.navigate({
+                to: redirectTo || '/'
+            });
+            return parseResponseData(result);
+        }
+        const parsed = isFetcher ? await parseResponseResultOrThrow(result) : await parseResponseData(result);
+        onInvalidateStart?.();
+        await router.invalidate();
+        return parsed;
+    }
+    onInvalidateStart?.();
+    await router.invalidate();
+    return result;
+}
+export { RouteActionResponseError, submitRouteAction };

package/dist/esm/runtime/utils.mjs

@@ -1,83 +1,55 @@
 import { jsx } from "react/jsx-runtime";
 import react from "react";
-function getRouteObjects(routes, { globalApp, ssrMode, props }) {
-    const createLayoutElement = (Component)=>{
-        const GlobalLayout = globalApp;
-        if (!GlobalLayout) return Component;
-        const LayoutWrapper = (props)=>{
-            const LayoutComponent = GlobalLayout;
-            return /*#__PURE__*/ jsx(LayoutComponent, {
-                Component: Component,
-                ...props
-            });
-        };
-        return LayoutWrapper;
+function withGlobalLayout(Component, globalApp) {
+    if (!globalApp) return Component;
+    const GlobalLayout = globalApp;
+    return function(props) {
+        return /*#__PURE__*/ jsx(GlobalLayout, {
+            Component: Component,
+            ...props
+        });
     };
-    const routeObjects = [];
-    for (const route of routes)if ('nested' === route.type) {
-        const nestedRouteObject = {
-            path: route.path,
-            id: route.id,
-            loader: route.loader,
-            action: route.action,
-            shouldRevalidate: route.shouldRevalidate,
-            handle: {
-                ...route.handle,
-                ...'object' == typeof route.config ? route.config?.handle : {}
-            },
-            index: route.index,
-            hasLoader: Boolean(route.loader),
-            hasClientLoader: Boolean(route.clientData),
-            hasAction: Boolean(route.action),
-            ...route.isClientComponent ? {
-                isClientComponent: true
-            } : {},
-            ...route.inValidSSRRoute ? {
-                inValidSSRRoute: true
-            } : {},
-            lazyImport: route.lazyImport,
-            Component: route.component ? route.component : void 0,
-            errorElement: route.error ? /*#__PURE__*/ jsx(route.error, {}) : void 0,
-            children: route.children ? route.children.map((child)=>getRouteObjects([
-                    child
-                ], {
-                    globalApp,
-                    ssrMode,
-                    props
-                })[0]) : void 0
-        };
-        routeObjects.push(nestedRouteObject);
-    } else if ('function' == typeof route.component || 'object' == typeof route.component) {
-        const LayoutComponent = createLayoutElement(route.component);
-        const routeObject = {
-            path: route.path,
-            element: /*#__PURE__*/ react.createElement(LayoutComponent)
-        };
-        routeObjects.push(routeObject);
-    }
-    return routeObjects;
 }
-function createRouteObjectsFromConfig({ routesConfig, props, ssrMode }) {
+function getRouteHandle(route) {
+    return {
+        ...route.handle,
+        ...'object' == typeof route.config ? route.config?.handle : {}
+    };
+}
+function toTanstackRouteObject(route, globalApp) {
+    if ('nested' === route.type) return {
+        path: route.path,
+        id: route.id,
+        loader: route.loader,
+        action: route.action,
+        shouldRevalidate: route.shouldRevalidate,
+        handle: getRouteHandle(route),
+        index: route.index,
+        hasLoader: Boolean(route.loader),
+        hasClientLoader: Boolean(route.clientData),
+        hasAction: Boolean(route.action),
+        ...route.isClientComponent ? {
+            isClientComponent: true
+        } : {},
+        ...route.inValidSSRRoute ? {
+            inValidSSRRoute: true
+        } : {},
+        lazyImport: route.lazyImport,
+        Component: route.component ? route.component : void 0,
+        errorElement: route.error ? /*#__PURE__*/ react.createElement(route.error) : void 0,
+        children: route.children ? route.children.map((child)=>toTanstackRouteObject(child, globalApp)).filter((child)=>null !== child) : void 0
+    };
+    if ('function' != typeof route.component && 'object' != typeof route.component) return null;
+    const LayoutComponent = withGlobalLayout(route.component, globalApp);
+    return {
+        path: route.path,
+        element: /*#__PURE__*/ react.createElement(LayoutComponent)
+    };
+}
+function createTanstackRouteObjectsFromConfig({ routesConfig }) {
     if (!routesConfig) return null;
     const { routes, globalApp } = routesConfig;
     if (!routes) return null;
-    return getRouteObjects(routes, {
-        globalApp,
-        ssrMode,
-        props
-    });
-}
-const urlJoin = (...parts)=>{
-    const separator = '/';
-    const replace = new RegExp(`${separator}{1,}`, 'g');
-    return standardSlash(parts.join(separator).replace(replace, separator));
-};
-function standardSlash(str) {
-    let addr = str;
-    if (!addr || 'string' != typeof addr) return addr;
-    if (addr.startsWith('.')) addr = addr.slice(1);
-    if (!addr.startsWith('/')) addr = `/${addr}`;
-    if (addr.endsWith('/') && '/' !== addr) addr = addr.slice(0, addr.length - 1);
-    return addr;
+    return routes.map((route)=>toTanstackRouteObject(route, globalApp)).filter((route)=>null !== route);
 }
-export { createRouteObjectsFromConfig, getRouteObjects, standardSlash, urlJoin };
+export { createTanstackRouteObjectsFromConfig };

package/dist/esm-node/cli/artifacts.mjs

@@ -0,0 +1,104 @@
+import "node:module";
+import node_path from "node:path";
+import { fs } from "@modern-js/utils";
+import { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry } from "./tanstackTypes.mjs";
+const DEFAULT_GENERATED_DIR_NAME = 'modern-tanstack';
+async function writeFileIfChanged(filePath, content) {
+    try {
+        const previous = await fs.pathExists(filePath) ? await fs.readFile(filePath, 'utf-8') : null;
+        if (previous === content) return;
+    } catch  {}
+    await fs.outputFile(filePath, content, 'utf-8');
+}
+function createRegisterDtsContent(opts) {
+    const importStatements = opts.entries.map((entryName, index)=>`import type { router as router${index} } from './${entryName}/router.gen';`).join('\n');
+    const routerUnionType = opts.entries.map((_, index)=>`typeof router${index}`).join(' | ');
+    const canonicalEntries = Object.entries(opts.canonicalRoutes ?? {});
+    const canonicalRoutesAugmentation = canonicalEntries.length > 0 ? `
+declare module '${opts.i18nRuntimeModule || '@modern-js/plugin-i18n/runtime'}' {
+  interface UltramodernCanonicalRoutes {
+${canonicalEntries.map(([routePath, paramsType])=>`    '${routePath}': ${paramsType};`).join('\n')}
+  }
+}
+` : '';
+    return `// This file is auto-generated by Modern.js. Do not edit manually.
+
+${importStatements}
+
+declare module '${opts.runtimeModule}' {
+  interface Register {
+    router: ${routerUnionType};
+  }
+}
+${canonicalRoutesAugmentation}`;
+}
+async function writeTanstackRegisterFile(opts) {
+    const { entries, generatedDirName = DEFAULT_GENERATED_DIR_NAME, runtimeModule = '@modern-js/plugin-tanstack/runtime', srcDirectory, canonicalRoutes, i18nRuntimeModule } = opts;
+    if (0 === entries.length) return;
+    const registerDtsPath = node_path.join(srcDirectory, generatedDirName, 'register.gen.d.ts');
+    await writeFileIfChanged(registerDtsPath, createRegisterDtsContent({
+        entries,
+        runtimeModule,
+        canonicalRoutes,
+        i18nRuntimeModule
+    }));
+}
+async function writeTanstackRouterTypesForEntries(opts) {
+    const { appContext, generatedDirName = DEFAULT_GENERATED_DIR_NAME, routesByEntry, i18nPluginInstalled = false } = opts;
+    const entryNames = Object.keys(routesByEntry);
+    await Promise.all(entryNames.map(async (entryName)=>{
+        const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
+            appContext,
+            entryName,
+            generatedDirName,
+            routes: routesByEntry[entryName]
+        });
+        await writeFileIfChanged(node_path.join(appContext.srcDirectory, generatedDirName, entryName, 'router.gen.ts'), routerGenTs);
+    }));
+    const mainEntryName = appContext.entrypoints?.find((entrypoint)=>entrypoint.isMainEntry)?.entryName;
+    const registerEntries = entryNames.sort((a, b)=>{
+        if (mainEntryName && a === mainEntryName) return -1;
+        if (mainEntryName && b === mainEntryName) return 1;
+        return a.localeCompare(b);
+    });
+    let canonicalRoutes = null;
+    if (i18nPluginInstalled) for (const entryName of registerEntries){
+        const entryCanonicalRoutes = collectCanonicalRoutesForEntry(routesByEntry[entryName], {
+            localeParamHeuristic: true
+        });
+        if (entryCanonicalRoutes) canonicalRoutes = {
+            ...entryCanonicalRoutes,
+            ...canonicalRoutes ?? {}
+        };
+    }
+    await writeTanstackRegisterFile({
+        entries: registerEntries,
+        generatedDirName,
+        srcDirectory: appContext.srcDirectory,
+        canonicalRoutes
+    });
+}
+async function generateTanstackRouteArtifacts(opts) {
+    const [{ createRunOptions }, { cli }, utils] = await Promise.all([
+        import("@modern-js/app-tools/cli/run"),
+        import("@modern-js/plugin/cli"),
+        import("@modern-js/utils")
+    ]);
+    process.env.MODERN_ARGV = 'node modern build';
+    process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+    const { findExists, CONFIG_FILE_EXTENSIONS } = utils;
+    const configFileBase = node_path.resolve(opts.appDirectory, 'modern.config');
+    const resolvedConfigFile = findExists(CONFIG_FILE_EXTENSIONS.map((extension)=>`${configFileBase}${extension}`));
+    if (!resolvedConfigFile) throw new Error(`[plugin-tanstack] Unable to locate a Modern.js config file (modern.config.{${CONFIG_FILE_EXTENSIONS.map((extension)=>extension.slice(1)).join(',')}}) in ${opts.appDirectory}. TanStack route generation requires the app config to resolve its plugins.`);
+    const runOptions = await createRunOptions({
+        cwd: opts.appDirectory,
+        configFile: configFileBase,
+        version: opts.version || process.env.MODERN_JS_VERSION || '0.0.0-routes-generate',
+        internalPlugins: utils.INTERNAL_RUNTIME_PLUGINS
+    });
+    await cli.init({
+        ...runOptions,
+        command: 'build'
+    });
+}
+export { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

package/dist/esm-node/cli/index.mjs

@@ -1,8 +1,8 @@
 import "node:module";
 import node_path from "node:path";
-import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, fs } from "@modern-js/utils";
+import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer } from "@modern-js/utils";
+import { generateTanstackRouteArtifacts, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries } from "./artifacts.mjs";
 import { createTanstackRsbuildRouteSplittingProfile, resolveTanstackRouteCodeSplittingEnabled } from "./routeSplitting.mjs";
-import { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry } from "./tanstackTypes.mjs";
 import { __webpack_require__ } from "../rslib-runtime.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
@@ -26,81 +26,6 @@ function getRuntimeRouterCli() {
     }
     throw new Error('@modern-js/plugin-tanstack requires @modern-js/runtime/cli router helper exports.');
 }
-async function writeFileIfChanged(filePath, content) {
-    try {
-        const previous = await fs.pathExists(filePath) ? await fs.readFile(filePath, 'utf-8') : null;
-        if (previous === content) return;
-    } catch  {}
-    await fs.outputFile(filePath, content, 'utf-8');
-}
-function createRegisterDtsContent(opts) {
-    const importStatements = opts.entries.map((entryName, index)=>`import type { router as router${index} } from './${entryName}/router.gen';`).join('\n');
-    const routerUnionType = opts.entries.map((_, index)=>`typeof router${index}`).join(' | ');
-    const canonicalEntries = Object.entries(opts.canonicalRoutes ?? {});
-    const canonicalRoutesAugmentation = canonicalEntries.length > 0 ? `
-declare module '${opts.i18nRuntimeModule || '@modern-js/plugin-i18n/runtime'}' {
-  interface UltramodernCanonicalRoutes {
-${canonicalEntries.map(([routePath, paramsType])=>`    '${routePath}': ${paramsType};`).join('\n')}
-  }
-}
-` : '';
-    return `// This file is auto-generated by Modern.js. Do not edit manually.
-
-${importStatements}
-
-declare module '${opts.runtimeModule}' {
-  interface Register {
-    router: ${routerUnionType};
-  }
-}
-${canonicalRoutesAugmentation}`;
-}
-async function writeTanstackRegisterFile(opts) {
-    const { entries, generatedDirName = DEFAULT_GENERATED_DIR_NAME, runtimeModule = '@modern-js/plugin-tanstack/runtime', srcDirectory, canonicalRoutes, i18nRuntimeModule } = opts;
-    if (0 === entries.length) return;
-    const registerDtsPath = node_path.join(srcDirectory, generatedDirName, 'register.gen.d.ts');
-    await writeFileIfChanged(registerDtsPath, createRegisterDtsContent({
-        entries,
-        runtimeModule,
-        canonicalRoutes,
-        i18nRuntimeModule
-    }));
-}
-async function writeTanstackRouterTypesForEntries(opts) {
-    const { appContext, generatedDirName = DEFAULT_GENERATED_DIR_NAME, routesByEntry, i18nPluginInstalled = false } = opts;
-    const entryNames = Object.keys(routesByEntry);
-    await Promise.all(entryNames.map(async (entryName)=>{
-        const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
-            appContext,
-            entryName,
-            generatedDirName,
-            routes: routesByEntry[entryName]
-        });
-        await writeFileIfChanged(node_path.join(appContext.srcDirectory, generatedDirName, entryName, 'router.gen.ts'), routerGenTs);
-    }));
-    const mainEntryName = appContext.entrypoints?.find((entrypoint)=>entrypoint.isMainEntry)?.entryName;
-    const registerEntries = entryNames.sort((a, b)=>{
-        if (mainEntryName && a === mainEntryName) return -1;
-        if (mainEntryName && b === mainEntryName) return 1;
-        return a.localeCompare(b);
-    });
-    let canonicalRoutes = null;
-    if (i18nPluginInstalled) for (const entryName of registerEntries){
-        const entryCanonicalRoutes = collectCanonicalRoutesForEntry(routesByEntry[entryName], {
-            localeParamHeuristic: true
-        });
-        if (entryCanonicalRoutes) canonicalRoutes = {
-            ...entryCanonicalRoutes,
-            ...canonicalRoutes ?? {}
-        };
-    }
-    await writeTanstackRegisterFile({
-        entries: registerEntries,
-        generatedDirName,
-        srcDirectory: appContext.srcDirectory,
-        canonicalRoutes
-    });
-}
 function tanstackRouterPlugin(options = {}) {
     const routesDir = options.routesDir || DEFAULT_ROUTES_DIR;
     const generatedDirName = options.generatedDirName || DEFAULT_GENERATED_DIR_NAME;
@@ -242,29 +167,7 @@ function tanstackRouterPlugin(options = {}) {
         }
     };
 }
-async function generateTanstackRouteArtifacts(opts) {
-    const [{ createRunOptions }, { cli }, utils] = await Promise.all([
-        import("@modern-js/app-tools/cli/run"),
-        import("@modern-js/plugin/cli"),
-        import("@modern-js/utils")
-    ]);
-    process.env.MODERN_ARGV = 'node modern build';
-    process.env.NODE_ENV = process.env.NODE_ENV || 'production';
-    const { findExists, CONFIG_FILE_EXTENSIONS } = utils;
-    const configFileBase = node_path.resolve(opts.appDirectory, 'modern.config');
-    const resolvedConfigFile = findExists(CONFIG_FILE_EXTENSIONS.map((extension)=>`${configFileBase}${extension}`));
-    if (!resolvedConfigFile) throw new Error(`[plugin-tanstack] Unable to locate a Modern.js config file (modern.config.{${CONFIG_FILE_EXTENSIONS.map((extension)=>extension.slice(1)).join(',')}}) in ${opts.appDirectory}. TanStack route generation requires the app config to resolve its plugins.`);
-    const runOptions = await createRunOptions({
-        cwd: opts.appDirectory,
-        configFile: configFileBase,
-        version: opts.version || process.env.MODERN_JS_VERSION || '0.0.0-routes-generate',
-        internalPlugins: utils.INTERNAL_RUNTIME_PLUGINS
-    });
-    await cli.init({
-        ...runOptions,
-        command: 'build'
-    });
-}
 const src_cli = tanstackRouterPlugin;
+export { collectCanonicalRoutesForEntry, generateTanstackRouterTypesSourceForEntry } from "./tanstackTypes.mjs";
 export default src_cli;
-export { collectCanonicalRoutesForEntry, createTanstackRsbuildRouteSplittingProfile, generateTanstackRouteArtifacts, generateTanstackRouterTypesSourceForEntry, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { createTanstackRsbuildRouteSplittingProfile, generateTanstackRouteArtifacts, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

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

@@ -0,0 +1,76 @@
+import "node:module";
+import { toTanstackPath } from "./shared.mjs";
+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)));
+}
+export { collectCanonicalRoutesForEntry };

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

@@ -0,0 +1,69 @@
+import "node:module";
+import { getPathWithoutExt } from "@modern-js/runtime/cli";
+import { findExists, formatImportPath, slash } from "@modern-js/utils";
+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  }),`;
+}
+export { createRouteStaticDataSnippet, isIndexRoute, isPathlessLayout, normalizeRelativeImport, pickModernLoaderModule, pickRouteSearchContractModules, quote, resolveFileNoExt, toTanstackPath };