@bleedingdev/modern-js-runtime 3.2.0-ultramodern.99 → 3.4.0-ultramodern.0

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

@@ -1,397 +0,0 @@
-import "node:module";
-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-node/router/runtime/tanstack/basepathRewrite.mjs

@@ -1,29 +0,0 @@
-import "node:module";
-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 };