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

package/dist/esm/cli/tanstackTypes.mjs

@@ -0,0 +1,341 @@
+import { findExists, formatImportPath, fs, slash } from "@modern-js/utils";
+import path from "path";
+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 = path.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 = 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, generatedDirName = 'modern-tanstack', routes } = opts;
+    const outDir = path.join(appContext.srcDirectory, generatedDirName, entryName);
+    const rootModern = routes.find((r)=>r && 'nested' === r.type && r.isRoot);
+    const topLevel = rootModern ? rootModern.children || [] : routes;
+    const imports = [];
+    const statements = [];
+    const loaderImportMap = new Map();
+    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 = 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 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
+    };
+}
+export { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled };

package/dist/esm/cli.mjs

@@ -0,0 +1,2 @@
+export * from "./cli/index.mjs";
+export { default } from "./cli/index.mjs";

package/dist/esm/rslib-runtime.mjs

@@ -0,0 +1,18 @@
+var __webpack_modules__ = {};
+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__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+export { __webpack_require__ };

package/dist/esm/runtime/DefaultNotFound.mjs

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+const DefaultNotFound = ()=>/*#__PURE__*/ jsx("div", {
+        style: {
+            margin: '150px auto',
+            textAlign: 'center',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center'
+        },
+        children: "404"
+    });
+export { DefaultNotFound };

package/dist/esm/runtime/basepathRewrite.mjs

@@ -0,0 +1,28 @@
+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 };