@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/cli/index.js

@@ -0,0 +1,268 @@
+"use strict";
+var __webpack_modules__ = {
+    "@modern-js/runtime/cli" (module) {
+        module.exports = require("@modern-js/runtime/cli");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+        default: ()=>src_cli,
+        generateTanstackRouterTypesSourceForEntry: ()=>external_tanstackTypes_js_namespaceObject.generateTanstackRouterTypesSourceForEntry,
+        isTanstackRouterFrameworkEnabled: ()=>external_tanstackTypes_js_namespaceObject.isTanstackRouterFrameworkEnabled,
+        tanstackRouterPlugin: ()=>tanstackRouterPlugin,
+        writeTanstackRegisterFile: ()=>writeTanstackRegisterFile,
+        writeTanstackRouterTypesForEntries: ()=>writeTanstackRouterTypesForEntries
+    });
+    const external_node_path_namespaceObject = require("node:path");
+    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+    const utils_namespaceObject = require("@modern-js/utils");
+    const external_tanstackTypes_js_namespaceObject = require("./tanstackTypes.js");
+    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__("@modern-js/runtime/cli");
+        if (cli.handleGeneratorEntryCode && cli.getEntrypointRoutesDir) {
+            runtimeRouterCli = cli;
+            return runtimeRouterCli;
+        }
+        throw new Error('@modern-js/plugin-tanstack requires @modern-js/runtime/cli router helper exports.');
+    }
+    async function writeFileIfChanged(filePath, content) {
+        try {
+            const previous = await utils_namespaceObject.fs.pathExists(filePath) ? await utils_namespaceObject.fs.readFile(filePath, 'utf-8') : null;
+            if (previous === content) return;
+        } catch  {}
+        await utils_namespaceObject.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(' | ');
+        return `// This file is auto-generated by Modern.js. Do not edit manually.
+
+${importStatements}
+
+declare module '${opts.runtimeModule}' {
+  interface Register {
+    router: ${routerUnionType};
+  }
+}
+`;
+    }
+    async function writeTanstackRegisterFile(opts) {
+        const { entries, generatedDirName = DEFAULT_GENERATED_DIR_NAME, runtimeModule = '@modern-js/plugin-tanstack/runtime', srcDirectory } = opts;
+        if (0 === entries.length) return;
+        const registerDtsPath = external_node_path_default().join(srcDirectory, generatedDirName, 'register.gen.d.ts');
+        await writeFileIfChanged(registerDtsPath, createRegisterDtsContent({
+            entries,
+            runtimeModule
+        }));
+    }
+    async function writeTanstackRouterTypesForEntries(opts) {
+        const { appContext, generatedDirName = DEFAULT_GENERATED_DIR_NAME, routesByEntry } = opts;
+        const entryNames = Object.keys(routesByEntry);
+        await Promise.all(entryNames.map(async (entryName)=>{
+            const { routerGenTs } = await (0, external_tanstackTypes_js_namespaceObject.generateTanstackRouterTypesSourceForEntry)({
+                appContext,
+                entryName,
+                generatedDirName,
+                routes: routesByEntry[entryName]
+            });
+            await writeFileIfChanged(external_node_path_default().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);
+        });
+        await writeTanstackRegisterFile({
+            entries: registerEntries,
+            generatedDirName,
+            srcDirectory: appContext.srcDirectory
+        });
+    }
+    function tanstackRouterPlugin(options = {}) {
+        const routesDir = options.routesDir || DEFAULT_ROUTES_DIR;
+        const generatedDirName = options.generatedDirName || DEFAULT_GENERATED_DIR_NAME;
+        return {
+            name: '@modern-js/plugin-tanstack',
+            required: [
+                '@modern-js/runtime'
+            ],
+            setup: (api)=>{
+                const nestedRoutesForServer = {};
+                const isTanstackEntrypoint = (entrypoint)=>{
+                    const { getEntrypointRoutesDir } = getRuntimeRouterCli();
+                    return getEntrypointRoutesDir(entrypoint) === routesDir;
+                };
+                api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                    if (!isTanstackEntrypoint(entrypoint)) return {
+                        entrypoint,
+                        plugins
+                    };
+                    const { metaName, serverRoutes } = api.getAppContext();
+                    const serverBase = serverRoutes.filter((route)=>route.entryName === entrypoint.entryName).map((route)=>route.urlPath).sort((a, b)=>a.length - b.length > 0 ? -1 : 1);
+                    plugins.push({
+                        name: 'tanstackRouter',
+                        path: `@${metaName}/plugin-tanstack/runtime`,
+                        config: {
+                            serverBase
+                        }
+                    });
+                    return {
+                        entrypoint,
+                        plugins
+                    };
+                });
+                api.checkEntryPoint(({ path: entryPath, entry })=>{
+                    const { isRouteEntry } = getRuntimeRouterCli();
+                    return {
+                        path: entryPath,
+                        entry: entry || isRouteEntry(entryPath, routesDir)
+                    };
+                });
+                api.config(()=>({
+                        source: {
+                            include: [
+                                /[\\/]node_modules[\\/]@tanstack[\\/]react-router[\\/]/,
+                                external_node_path_default().resolve(__dirname, '../runtime').replace('cjs', 'esm')
+                            ]
+                        }
+                    }));
+                api.modifyEntrypoints(async ({ entrypoints })=>{
+                    const { handleModifyEntrypoints } = getRuntimeRouterCli();
+                    return {
+                        entrypoints: await handleModifyEntrypoints(entrypoints, routesDir, {
+                            routesOwner: ENTRYPOINTS_KEY
+                        })
+                    };
+                });
+                api.generateEntryCode(async ({ entrypoints })=>{
+                    const tanstackEntrypoints = entrypoints.filter(isTanstackEntrypoint);
+                    if (0 === tanstackEntrypoints.length) return;
+                    const { handleGeneratorEntryCode } = getRuntimeRouterCli();
+                    const routesByEntry = await handleGeneratorEntryCode(api, tanstackEntrypoints, {
+                        entrypointsKey: ENTRYPOINTS_KEY,
+                        generateCodeOptions: {
+                            enableTanstackTypes: false
+                        }
+                    });
+                    await writeTanstackRouterTypesForEntries({
+                        appContext: api.getAppContext(),
+                        generatedDirName,
+                        routesByEntry
+                    });
+                });
+                api.onFileChanged(async (event)=>{
+                    const { handleFileChange } = getRuntimeRouterCli();
+                    await handleFileChange(api, event, {
+                        entrypointsKey: ENTRYPOINTS_KEY,
+                        includeEntry: (entrypoint)=>{
+                            const { getEntrypointRoutesDir } = getRuntimeRouterCli();
+                            return getEntrypointRoutesDir(entrypoint) === routesDir;
+                        },
+                        regenerate: async ({ api, entrypoints })=>{
+                            const { handleGeneratorEntryCode } = getRuntimeRouterCli();
+                            const routesByEntry = await handleGeneratorEntryCode(api, entrypoints, {
+                                entrypointsKey: ENTRYPOINTS_KEY,
+                                generateCodeOptions: {
+                                    enableTanstackTypes: false
+                                }
+                            });
+                            await writeTanstackRouterTypesForEntries({
+                                appContext: api.getAppContext(),
+                                generatedDirName,
+                                routesByEntry
+                            });
+                        }
+                    });
+                });
+                api.modifyFileSystemRoutes(async ({ entrypoint, routes })=>{
+                    if (isTanstackEntrypoint(entrypoint)) nestedRoutesForServer[entrypoint.entryName] = (0, utils_namespaceObject.filterRoutesForServer)(routes);
+                    return {
+                        entrypoint,
+                        routes
+                    };
+                });
+                api.onBeforeGenerateRoutes(async ({ entrypoint, code })=>{
+                    if (isTanstackEntrypoint(entrypoint)) {
+                        const { distDirectory } = api.getAppContext();
+                        const nestedRoutesSpecPath = external_node_path_default().resolve(distDirectory, utils_namespaceObject.NESTED_ROUTE_SPEC_FILE);
+                        const existingNestedRoutes = await utils_namespaceObject.fs.pathExists(nestedRoutesSpecPath) ? await utils_namespaceObject.fs.readJSON(nestedRoutesSpecPath) : {};
+                        await utils_namespaceObject.fs.outputJSON(nestedRoutesSpecPath, {
+                            ...existingNestedRoutes,
+                            ...nestedRoutesForServer
+                        });
+                    }
+                    return {
+                        entrypoint,
+                        code
+                    };
+                });
+            }
+        };
+    }
+    const src_cli = tanstackRouterPlugin;
+})();
+exports["default"] = __webpack_exports__["default"];
+exports.generateTanstackRouterTypesSourceForEntry = __webpack_exports__.generateTanstackRouterTypesSourceForEntry;
+exports.isTanstackRouterFrameworkEnabled = __webpack_exports__.isTanstackRouterFrameworkEnabled;
+exports.tanstackRouterPlugin = __webpack_exports__.tanstackRouterPlugin;
+exports.writeTanstackRegisterFile = __webpack_exports__.writeTanstackRegisterFile;
+exports.writeTanstackRouterTypesForEntries = __webpack_exports__.writeTanstackRouterTypesForEntries;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "generateTanstackRouterTypesSourceForEntry",
+    "isTanstackRouterFrameworkEnabled",
+    "tanstackRouterPlugin",
+    "writeTanstackRegisterFile",
+    "writeTanstackRouterTypesForEntries"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/tanstackTypes.js

@@ -0,0 +1,388 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    generateTanstackRouterTypesSourceForEntry: ()=>generateTanstackRouterTypesSourceForEntry,
+    isTanstackRouterFrameworkEnabled: ()=>isTanstackRouterFrameworkEnabled
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbidList = new Set(`${reservedWords} ${builtins}`.split(' '));
+function makeLegalIdentifier(str) {
+    const identifier = str.replace(/-(\w)/g, (_, letter)=>letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');
+    if (/\d/.test(identifier[0]) || forbidList.has(identifier)) return `_${identifier}`;
+    return identifier || '_';
+}
+function getPathWithoutExt(filename) {
+    const extname = external_path_default().extname(filename);
+    return extname ? filename.slice(0, -extname.length) : filename;
+}
+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 = (0, utils_namespaceObject.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 = (0, utils_namespaceObject.formatImportPath)((0, utils_namespaceObject.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 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  }),`;
+}
+async function isTanstackRouterFrameworkEnabled(appContext) {
+    const runtimeConfigBase = external_path_default().join(appContext.srcDirectory, appContext.runtimeConfigFile);
+    const runtimeConfigFile = (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${runtimeConfigBase}${ext}`));
+    if (!runtimeConfigFile) return false;
+    try {
+        const content = await utils_namespaceObject.fs.readFile(runtimeConfigFile, 'utf-8');
+        return /framework\s*:\s*['"]tanstack['"]/.test(content);
+    } catch  {
+        return false;
+    }
+}
+async function generateTanstackRouterTypesSourceForEntry(opts) {
+    const { appContext, entryName, generatedDirName = 'modern-tanstack', routes } = opts;
+    const outDir = external_path_default().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();
+    let loaderIndex = 0;
+    let routeIndex = 0;
+    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 prefix = `${appContext.internalSrcAlias}/`;
+        let absNoExt;
+        if (aliasedNoExtPath.startsWith(prefix)) {
+            const rel = aliasedNoExtPath.slice(prefix.length);
+            absNoExt = external_path_default().join(appContext.srcDirectory, rel);
+        } else absNoExt = external_path_default().isAbsolute(aliasedNoExtPath) ? aliasedNoExtPath : external_path_default().join(appContext.srcDirectory, aliasedNoExtPath);
+        const resolvedNoExt = await resolveFileNoExt(absNoExt);
+        if (!resolvedNoExt) return null;
+        const relImport = normalizeRelativeImport(external_path_default().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 createRouteVarName = (route)=>{
+        const id = route.id;
+        const base = id ? makeLegalIdentifier(id) : `r_${routeIndex++}`;
+        return `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 rawPath = route.path;
+        const hasSplat = 'string' == typeof rawPath && rawPath.includes('*');
+        const routeOpts = [
+            `getParentRoute: () => ${parentVar},`
+        ];
+        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}),`);
+        const staticDataSnippet = createRouteStaticDataSnippet({
+            modernRouteId: route.id,
+            loaderName,
+            actionName
+        });
+        if (staticDataSnippet) routeOpts.push(staticDataSnippet);
+        statements.push(`const ${varName} = createRoute({\n  ${routeOpts.join('\n  ')}\n});`);
+        const children = route.children;
+        if (children && children.length > 0) {
+            const childVars = await Promise.all(children.map((child)=>buildRoute({
+                    parentVar: varName,
+                    route: child
+                })));
+            statements.push(`${varName}.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 topLevelVars = await Promise.all(topLevel.map((route)=>buildRoute({
+            parentVar: 'rootRoute',
+            route
+        })));
+    const rootOpts = [];
+    if (rootLoaderName) rootOpts.push(`loader: modernLoaderToTanstack({ hasSplat: false }, ${rootLoaderName}),`);
+    const routerGenTs = `/* eslint-disable */
+// This file is auto-generated by Modern.js. Do not edit manually.
+
+import {
+  createMemoryHistory,
+  createRootRouteWithContext,
+  createRoute,
+  createRouter,
+  notFound,
+  redirect,
+} from '@modern-js/plugin-tanstack/runtime';
+
+type ModernRouterContext = {
+  request?: Request;
+  requestContext?: unknown;
+};
+
+function isResponse(value: unknown): value is Response {
+  return (
+    value != null &&
+    typeof value === 'object' &&
+    typeof (value as any).status === 'number' &&
+    typeof (value as any).headers === 'object'
+  );
+}
+
+const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+function isRedirectResponse(res: Response) {
+  return redirectStatusCodes.has(res.status);
+}
+
+function throwTanstackRedirect(location: string) {
+  const target = location || '/';
+  try {
+    void new URL(target);
+    throw redirect({ href: target });
+  } catch {
+    throw redirect({ to: target });
+  }
+}
+
+function mapParamsForModernLoader(params: Record<string, string>, hasSplat: boolean) {
+  if (!hasSplat) {
+    return params;
+  }
+
+  const { _splat, ...rest } = params as any;
+  if (typeof _splat !== 'undefined') {
+    return { ...rest, '*': _splat };
+  }
+  return rest;
+}
+
+function createRouteStaticData(opts: {
+  modernRouteId?: string;
+  modernRouteAction?: unknown;
+  modernRouteLoader?: unknown;
+}) {
+  const staticData: Record<string, unknown> = {};
+
+  if (opts.modernRouteId) {
+    staticData.modernRouteId = opts.modernRouteId;
+  }
+
+  if (opts.modernRouteLoader) {
+    staticData.modernRouteLoader = opts.modernRouteLoader;
+  }
+
+  if (opts.modernRouteAction) {
+    staticData.modernRouteAction = opts.modernRouteAction;
+  }
+
+  return Object.keys(staticData).length > 0 ? staticData : undefined;
+}
+
+function modernLoaderToTanstack<TLoader extends (args: any) => any>(
+  opts: { hasSplat: boolean },
+  modernLoader: TLoader,
+) {
+  type LoaderResult = Awaited<ReturnType<TLoader>>;
+
+  return async (ctx: any): Promise<LoaderResult> => {
+    try {
+      const signal: AbortSignal =
+        ctx?.abortController?.signal ||
+        ctx?.signal ||
+        new AbortController().signal;
+      const baseRequest: Request | undefined =
+        ctx?.context?.request instanceof Request ? ctx.context.request : undefined;
+
+      const href =
+        typeof ctx?.location === 'string'
+          ? ctx.location
+          : ctx?.location?.publicHref ||
+            ctx?.location?.href ||
+            ctx?.location?.url?.href ||
+            '';
+
+      const request = baseRequest
+        ? new Request(baseRequest, { signal })
+        : new Request(href, { signal });
+
+      const params = mapParamsForModernLoader(ctx?.params || {}, opts.hasSplat);
+
+      const result = await (modernLoader as any)({
+        request,
+        params,
+        context: ctx?.context?.requestContext,
+      });
+
+      if (isResponse(result)) {
+        if (isRedirectResponse(result)) {
+          const location = result.headers.get('Location') || '/';
+          throwTanstackRedirect(location);
+        }
+        if (result.status === 404) {
+          throw notFound();
+        }
+      }
+
+      return result as LoaderResult;
+    } catch (err) {
+      if (isResponse(err)) {
+        if (isRedirectResponse(err)) {
+          const location = err.headers.get('Location') || '/';
+          throwTanstackRedirect(location);
+        }
+        if (err.status === 404) {
+          throw notFound();
+        }
+      }
+      throw err;
+    }
+  };
+}
+
+${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({
+  routeTree,
+  history: createMemoryHistory({
+    initialEntries: ['/'],
+  }),
+  context: {} as ModernRouterContext,
+});
+`;
+    return {
+        routerGenTs
+    };
+}
+exports.generateTanstackRouterTypesSourceForEntry = __webpack_exports__.generateTanstackRouterTypesSourceForEntry;
+exports.isTanstackRouterFrameworkEnabled = __webpack_exports__.isTanstackRouterFrameworkEnabled;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateTanstackRouterTypesSourceForEntry",
+    "isTanstackRouterFrameworkEnabled"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});