@bleedingdev/modern-js-runtime 3.2.0-ultramodern.120 → 3.2.0-ultramodern.122

package/dist/cjs/ssr/serverRender/renderToString/entry.js

@@ -1,200 +0,0 @@
-"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, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    default: ()=>Entry
-});
-const node_namespaceObject = require("@modern-js/runtime-utils/node");
-const time_namespaceObject = require("@modern-js/runtime-utils/time");
-const external_react_namespaceObject = require("react");
-var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
-const external_react_helmet_async_namespaceObject = require("react-helmet-async");
-const helmet_js_namespaceObject = require("../../../core/server/helmet.js");
-const utils_js_namespaceObject = require("../../../router/runtime/utils.js");
-const external_prefetch_namespaceObject = require("../../prefetch");
-var external_prefetch_default = /*#__PURE__*/ __webpack_require__.n(external_prefetch_namespaceObject);
-const external_tracker_namespaceObject = require("../tracker");
-const external_types_js_namespaceObject = require("../types.js");
-const external_utils_namespaceObject = require("../utils");
-const external_buildHtml_namespaceObject = require("./buildHtml");
-const external_loadable_namespaceObject = require("./loadable");
-const external_render_namespaceObject = require("./render");
-const external_styledComponent_namespaceObject = require("./styledComponent");
-const buildTemplateData = (context, data, renderLevel, tracker)=>{
-    const { request, enableUnsafeCtx } = context;
-    const unsafeContext = {
-        headers: request.headers
-    };
-    return {
-        data,
-        context: {
-            request: {
-                params: request.params,
-                query: request.query,
-                pathname: request.pathname,
-                host: request.host,
-                url: request.url,
-                ...enableUnsafeCtx ? unsafeContext : {}
-            },
-            reporter: {
-                sessionId: tracker.sessionId
-            }
-        },
-        renderLevel
-    };
-};
-class Entry {
-    async renderToHtml(context) {
-        const ssrContext = context.ssrContext;
-        if (ssrContext.redirection?.url) return '';
-        const prefetchData = await this.prefetch(context);
-        if (ssrContext.redirection?.url) return '';
-        if (this.result.renderLevel >= external_types_js_namespaceObject.RenderLevel.SERVER_PREFETCH) this.result.html = await this.renderToString(context);
-        if (ssrContext.redirection?.url) return '';
-        const { routerContext, routerServerSnapshot } = context;
-        const routerData = routerServerSnapshot?.routerData ? {
-            loaderData: routerServerSnapshot.routerData.loaderData,
-            errors: (0, utils_js_namespaceObject.serializeErrors)(routerServerSnapshot.routerData.errors)
-        } : routerContext ? {
-            loaderData: routerContext.loaderData,
-            errors: (0, utils_js_namespaceObject.serializeErrors)(routerContext.errors)
-        } : void 0;
-        const templateData = buildTemplateData(ssrContext, prefetchData, this.result.renderLevel, this.tracker);
-        const ssrDataScripts = this.getSSRDataScript(templateData, routerData);
-        const html = (0, external_buildHtml_namespaceObject.buildHtml)(this.template, [
-            (0, external_buildHtml_namespaceObject.createReplaceChunkCss)(this.result.chunksMap.css),
-            (0, external_buildHtml_namespaceObject.createReplaceChunkJs)(this.result.chunksMap.js),
-            (0, external_buildHtml_namespaceObject.createReplaceHtml)(this.result.html || ''),
-            (0, external_buildHtml_namespaceObject.createReplaceSSRDataScript)(ssrDataScripts),
-            ...this.htmlModifiers
-        ]);
-        const helmetData = (0, helmet_js_namespaceObject.getHelmetData)(context);
-        return helmetData ? (0, helmet_js_namespaceObject.helmetReplace)(html, helmetData) : html;
-    }
-    async prefetch(context) {
-        let prefetchData;
-        const end = (0, time_namespaceObject.time)();
-        try {
-            prefetchData = await external_prefetch_default()(this.App, context, this.pluginConfig);
-            this.result.renderLevel = external_types_js_namespaceObject.RenderLevel.SERVER_PREFETCH;
-            const prefetchCost = end();
-            this.tracker.trackTiming(external_tracker_namespaceObject.SSRTimings.SSR_PREFETCH, prefetchCost);
-        } catch (e) {
-            this.result.renderLevel = external_types_js_namespaceObject.RenderLevel.CLIENT_RENDER;
-            this.tracker.trackError(external_tracker_namespaceObject.SSRErrors.PREFETCH, e);
-        }
-        return prefetchData || {};
-    }
-    async renderToString(context) {
-        let html = '';
-        const end = (0, time_namespaceObject.time)();
-        const { ssrContext } = context;
-        try {
-            const helmetContext = context._helmetContext ??= {};
-            const App = external_react_default().createElement(external_react_helmet_async_namespaceObject.HelmetProvider, {
-                context: helmetContext
-            }, external_react_default().createElement(this.App, {
-                context: Object.assign(context, {
-                    ssr: true
-                })
-            }));
-            html = await (0, external_render_namespaceObject.createRender)(App).addCollector((0, external_styledComponent_namespaceObject.createStyledCollector)(this.result)).addCollector((0, external_loadable_namespaceObject.createLoadableCollector)({
-                stats: ssrContext.loadableStats,
-                result: this.result,
-                entryName: this.entryName,
-                config: this.pluginConfig,
-                nonce: this.nonce,
-                template: this.template,
-                routeManifest: this.routeManifest
-            })).finish();
-            const cost = end();
-            this.tracker.trackTiming(external_tracker_namespaceObject.SSRTimings.SSR_RENDER_HTML, cost);
-            this.result.renderLevel = external_types_js_namespaceObject.RenderLevel.SERVER_RENDER;
-        } catch (e) {
-            this.tracker.trackError(external_tracker_namespaceObject.SSRErrors.RENDER_HTML, e);
-        }
-        return html;
-    }
-    getSSRDataScript(templateData, routerData) {
-        const useInlineScript = false !== this.pluginConfig.inlineScript;
-        const sanitizedTemplateData = (0, node_namespaceObject.sanitizeSSRPayload)(templateData, {
-            unsafeHeaders: this.pluginConfig.unsafeHeaders
-        }).payload;
-        const ssrData = (0, node_namespaceObject.serializeJson)(sanitizedTemplateData);
-        const attrsStr = (0, external_utils_namespaceObject.attributesToString)({
-            nonce: this.nonce
-        });
-        let ssrDataScripts = useInlineScript ? `<script${attrsStr}>window._SSR_DATA = ${ssrData}</script>` : `<script type="application/json" id="${external_utils_namespaceObject.SSR_DATA_JSON_ID}">${ssrData}</script>`;
-        if (routerData) {
-            const sanitizedRouterData = (0, node_namespaceObject.sanitizeSSRPayload)(routerData, {
-                unsafeHeaders: this.pluginConfig.unsafeHeaders
-            }).payload;
-            const serializedRouterData = (0, node_namespaceObject.serializeJson)(sanitizedRouterData);
-            ssrDataScripts += useInlineScript ? `\n<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>` : `\n<script type="application/json" id="${external_utils_namespaceObject.ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>`;
-        }
-        return ssrDataScripts;
-    }
-    constructor(options){
-        const { ctx, config } = options;
-        const { entryName, template, nonce } = ctx;
-        this.template = template;
-        this.entryName = entryName;
-        this.App = options.App;
-        this.pluginConfig = config;
-        this.routeManifest = ctx.routeManifest;
-        this.tracker = ctx.tracker;
-        this.metrics = ctx.metrics;
-        this.htmlModifiers = ctx.htmlModifiers;
-        this.nonce = nonce;
-        this.result = {
-            renderLevel: external_types_js_namespaceObject.RenderLevel.CLIENT_RENDER,
-            html: '',
-            chunksMap: {
-                js: '',
-                css: ''
-            }
-        };
-    }
-}
-exports["default"] = __webpack_exports__["default"];
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "default"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/ssr/serverRender/types.js

@@ -1,40 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    RenderLevel: ()=>type_namespaceObject.RenderLevel
-});
-const type_namespaceObject = require("./renderToString/type");
-exports.RenderLevel = __webpack_exports__.RenderLevel;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "RenderLevel"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/esm/router/cli/code/tanstackTypes.mjs

@@ -1,396 +0,0 @@
-import { findExists, formatImportPath, fs, slash } from "@modern-js/utils";
-import path from "path";
-import { makeLegalIdentifier } from "./makeLegalIdentifier.mjs";
-import { getPathWithoutExt } from "./utils.mjs";
-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 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 = path.join(appContext.srcDirectory, appContext.runtimeConfigFile);
-    const runtimeConfigFile = findExists(JS_OR_TS_EXTS.map((ext)=>`${runtimeConfigBase}${ext}`));
-    if (!runtimeConfigFile) return false;
-    try {
-        const content = await fs.readFile(runtimeConfigFile, 'utf-8');
-        return /framework\s*:\s*['"]tanstack['"]/.test(content);
-    } catch  {
-        return false;
-    }
-}
-async function generateTanstackRouterTypesSourceForEntry(opts) {
-    const { appContext, entryName, routes } = opts;
-    const outDir = path.join(appContext.srcDirectory, 'modern-tanstack', entryName);
-    const rootModern = routes.find((r)=>r && 'nested' === r.type && r.isRoot);
-    const topLevel = rootModern ? rootModern.children || [] : routes;
-    const imports = [];
-    const statements = [];
-    const componentImportMap = new Map();
-    const loaderImportMap = new Map();
-    const usedRouteVarNames = new Set();
-    let componentIndex = 0;
-    let loaderIndex = 0;
-    let routeIndex = 0;
-    const getImportNameForComponent = (componentPath)=>{
-        if ('string' != typeof componentPath || 0 === componentPath.length) return null;
-        const existing = componentImportMap.get(componentPath);
-        if (existing) return existing;
-        const componentName = `component_${componentIndex++}`;
-        imports.push(`import ${componentName} from ${quote(componentPath)};`);
-        componentImportMap.set(componentPath, componentName);
-        return componentName;
-    };
-    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 = null;
-        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);
-        const resolvedNoExt = await resolveFileNoExt(absNoExt);
-        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 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 rawPath = route.path;
-        const hasSplat = 'string' == typeof rawPath && rawPath.includes('*');
-        const routeOpts = [
-            `getParentRoute: () => ${parentVar},`
-        ];
-        const componentName = 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}),`);
-        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 topLevelVars = await Promise.all(topLevel.map((route)=>buildRoute({
-            parentVar: 'rootRoute',
-            route
-        })));
-    const rootOpts = [];
-    const rootComponentName = getImportNameForComponent(rootModern?._component);
-    if (rootComponentName) rootOpts.push(`component: ${rootComponentName},`);
-    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/runtime/tanstack-router';
-
-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.length > 0 ? 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: {
-    modernRouteId?: string;
-    modernRouteAction?: unknown;
-    modernRouteLoader?: unknown;
-  } = {};
-
-  if (typeof opts.modernRouteId === 'string' && opts.modernRouteId.length > 0) {
-    staticData.modernRouteId = opts.modernRouteId;
-  }
-
-  if (typeof opts.modernRouteLoader !== 'undefined') {
-    staticData.modernRouteLoader = opts.modernRouteLoader;
-  }
-
-  if (typeof opts.modernRouteAction !== 'undefined') {
-    staticData.modernRouteAction = opts.modernRouteAction;
-  }
-
-  return staticData;
-}
-
-function getLoaderSignal(ctx: any): AbortSignal {
-  const abortSignal = ctx?.abortController?.signal;
-  if (abortSignal instanceof AbortSignal) {
-    return abortSignal;
-  }
-  if (ctx?.signal instanceof AbortSignal) {
-    return ctx.signal;
-  }
-  return new AbortController().signal;
-}
-
-function getLoaderHref(ctx: any): string {
-  if (typeof ctx?.location === 'string') {
-    return ctx.location;
-  }
-
-  const publicHref = ctx?.location?.publicHref;
-  if (typeof publicHref === 'string') {
-    return publicHref;
-  }
-
-  const href = ctx?.location?.href;
-  if (typeof href === 'string') {
-    return href;
-  }
-
-  const urlHref = ctx?.location?.url?.href;
-  return typeof urlHref === 'string' ? urlHref : '';
-}
-
-function getLoaderParams(ctx: any): Record<string, string> {
-  return typeof ctx?.params === 'object' && ctx.params !== null ? ctx.params : {};
-}
-
-function handleModernLoaderResult<LoaderResult>(result: LoaderResult): LoaderResult {
-  if (isResponse(result)) {
-    if (isRedirectResponse(result)) {
-      const location = result.headers.get('Location') ?? '/';
-      throwTanstackRedirect(location);
-    }
-    if (result.status === 404) {
-      throw notFound();
-    }
-  }
-
-  return result;
-}
-
-function handleModernLoaderError(err: unknown): never {
-  if (isResponse(err)) {
-    if (isRedirectResponse(err)) {
-      const location = err.headers.get('Location') ?? '/';
-      throwTanstackRedirect(location);
-    }
-    if (err.status === 404) {
-      throw notFound();
-    }
-  }
-
-  throw err;
-}
-
-function modernLoaderToTanstack<TLoader extends (args: any) => any>(
-  opts: { hasSplat: boolean },
-  modernLoader: TLoader,
-) {
-  type LoaderResult = Awaited<ReturnType<TLoader>>;
-
-  return (ctx: any): Promise<LoaderResult> => {
-    try {
-      const signal = getLoaderSignal(ctx);
-      const baseRequest: Request | undefined =
-        ctx?.context?.request instanceof Request ? ctx.context.request : undefined;
-
-      const href = getLoaderHref(ctx);
-
-      const request = baseRequest !== undefined
-        ? new Request(baseRequest, { signal })
-        : new Request(href, { signal });
-
-      const params = mapParamsForModernLoader(getLoaderParams(ctx), opts.hasSplat);
-
-      return Promise.resolve(
-        (modernLoader as any)({
-          request,
-          params,
-          context: ctx?.context?.requestContext,
-        }),
-      )
-        .then((result: LoaderResult) => handleModernLoaderResult(result))
-        .catch(handleModernLoaderError);
-    } catch (err) {
-      handleModernLoaderError(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
-    };
-}
-export { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled };

package/dist/esm/router/runtime/tanstack/basepathRewrite.mjs

@@ -1,28 +0,0 @@
-function normalizeBasepath(basepath) {
-    if (!basepath) return '/';
-    let normalized = basepath.startsWith('/') ? basepath : `/${basepath}`;
-    if (normalized.length > 1 && normalized.endsWith('/')) normalized = normalized.slice(0, -1);
-    return normalized || '/';
-}
-function createModernBasepathRewrite(basepath, caseSensitive = false) {
-    const normalizedBasepath = normalizeBasepath(basepath);
-    if ('/' === normalizedBasepath) return;
-    const normalizedBasepathWithSlash = `${normalizedBasepath}/`;
-    const checkBasepath = caseSensitive ? normalizedBasepath : normalizedBasepath.toLowerCase();
-    const checkBasepathWithSlash = caseSensitive ? normalizedBasepathWithSlash : normalizedBasepathWithSlash.toLowerCase();
-    return {
-        input: ({ url })=>{
-            const pathname = caseSensitive ? url.pathname : url.pathname.toLowerCase();
-            if (pathname === checkBasepath) url.pathname = '/';
-            else if (pathname.startsWith(checkBasepathWithSlash)) url.pathname = url.pathname.slice(normalizedBasepath.length) || '/';
-            return url;
-        },
-        output: ({ url })=>{
-            const pathname = url.pathname || '/';
-            if ('/' === pathname) url.pathname = normalizedBasepath;
-            else url.pathname = `${normalizedBasepath}${pathname.startsWith('/') ? '' : '/'}${pathname}`;
-            return url;
-        }
-    };
-}
-export { createModernBasepathRewrite };