one/dist/cjs/typed-routes/getTypedRoutesDeclarationFile.cjs

One is a new React Framework that makes Vite serve both native and web.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all) __defProp(target, name, {
    get: all[name],
    enumerable: true
  });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
      get: () => from[key],
      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
    });
  }
  return to;
};
var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
  value: true
}), mod);
var getTypedRoutesDeclarationFile_exports = {};
__export(getTypedRoutesDeclarationFile_exports, {
  getTypedRoutesDeclarationFile: () => getTypedRoutesDeclarationFile
});
module.exports = __toCommonJS(getTypedRoutesDeclarationFile_exports);
var import_getRoutes = require("../router/getRoutes.cjs");
var import_matchers = require("../router/matchers.cjs");
const CATCH_ALL = /\[\.\.\..+?\]/g;
const SLUG = /\[.+?\]/g;
function getTypedRoutesDeclarationFile(ctx) {
  const staticRoutes = /* @__PURE__ */new Set();
  const dynamicRoutes = /* @__PURE__ */new Set();
  const dynamicRouteContextKeys = /* @__PURE__ */new Set();
  walkRouteNode((0, import_getRoutes.getRoutes)(ctx, {
    platformRoutes: false,
    // We don't need to generate platform specific routes
    ignoreEntryPoints: true,
    ignoreRequireErrors: true
    // importMode: 'async',
  }), "", staticRoutes, dynamicRoutes, dynamicRouteContextKeys);
  const hasRoutes = dynamicRouteContextKeys.size > 0;
  return `// deno-lint-ignore-file
/* eslint-disable */
// biome-ignore: needed import
import type { OneRouter } from 'one'

declare module 'one' {
  export namespace OneRouter {
    export interface __routes<T extends string = string> extends Record<string, unknown> {
      StaticRoutes: ${setToUnionType(staticRoutes)}
      DynamicRoutes: ${setToUnionType(dynamicRoutes)}
      DynamicRouteTemplate: ${setToUnionType(dynamicRouteContextKeys)}
      IsTyped: true
      ${hasRoutes ? `RouteTypes: ${generateRouteTypesMap(dynamicRouteContextKeys)}` : ""}
    }
  }
}
${hasRoutes ? `
/**
 * Helper type for route information
 */
type RouteInfo<Params = Record<string, never>> = {
  Params: Params
  LoaderProps: { path: string; search?: string; subdomain?: string; params: Params; request?: Request }
}` : ""}
`.trim();
}
function generateRouteTypesMap(dynamicRouteContextKeys) {
  if (dynamicRouteContextKeys.size === 0) {
    return "{}";
  }
  const routes = [...dynamicRouteContextKeys].sort();
  const entries = routes.map(routePath => {
    const params = extractParams(routePath);
    const paramsType = params.length === 0 ? "{}" : generateInlineParamsType(params);
    return `        '${routePath}': RouteInfo<${paramsType}>`;
  }).join("\n");
  return `{
${entries}
      }`;
}
function extractParams(routePath) {
  const params = [];
  const paramRegex = /\[(\.\.\.)?([\w]+)\]/g;
  let match;
  while ((match = paramRegex.exec(routePath)) !== null) {
    params.push({
      name: match[2],
      isCatchAll: match[1] === "..."
    });
  }
  return params;
}
function generateInlineParamsType(params) {
  const entries = params.map(p => {
    const type = p.isCatchAll ? "string[]" : "string";
    return `${p.name}: ${type}`;
  });
  return `{ ${entries.join("; ")} }`;
}
function walkRouteNode(routeNode, parentRoutePath, staticRoutes, dynamicRoutes, dynamicRouteContextKeys) {
  if (!routeNode) return;
  addRouteNode(routeNode, parentRoutePath, staticRoutes, dynamicRoutes, dynamicRouteContextKeys);
  parentRoutePath = `${(0, import_matchers.removeSupportedExtensions)(`${parentRoutePath}/${routeNode.route}`).replace(/\/?index$/, "")}`;
  for (const child of routeNode.children) {
    walkRouteNode(child, parentRoutePath, staticRoutes, dynamicRoutes, dynamicRouteContextKeys);
  }
}
function addRouteNode(routeNode, parentRoutePath, staticRoutes, dynamicRoutes, dynamicRouteContextKeys) {
  if (!routeNode?.route) return;
  if (!(0, import_matchers.isTypedRoute)(routeNode.route)) return;
  let routePath = `${parentRoutePath}/${(0, import_matchers.removeSupportedExtensions)(routeNode.route).replace(/\/?index$/, "")}`;
  if (!routePath.startsWith("/")) {
    routePath = `/${routePath}`;
  }
  if (routeNode.dynamic) {
    for (const path of generateCombinations(routePath)) {
      dynamicRouteContextKeys.add(path);
      dynamicRoutes.add(
      // biome-ignore lint/suspicious/noTemplateCurlyInString: intentionally generating type string
      `${path.replaceAll(CATCH_ALL, "${string}").replaceAll(SLUG, "${OneRouter.SingleRoutePart<T>}")}`);
    }
  } else {
    for (const combination of generateCombinations(routePath)) {
      staticRoutes.add(combination);
    }
  }
}
const setToUnionType = set => {
  if (set.size === 0) return "never";
  const sorted = [...set].sort();
  if (sorted.length === 1) return `\`${sorted[0]}\``;
  return "\n        | " + sorted.map(s => `\`${s}\``).join("\n        | ");
};
function generateCombinations(pathname) {
  const groups = pathname.split("/").filter(part => part.startsWith("(") && part.endsWith(")"));
  const combinations = [];
  function generate(currentIndex, currentPath) {
    if (currentIndex === groups.length) {
      combinations.push(currentPath.replace(/\/{2,}/g, "/"));
      return;
    }
    const group = groups[currentIndex];
    const withoutGroup = currentPath.replace(`/${group}`, "");
    generate(currentIndex + 1, withoutGroup);
    generate(currentIndex + 1, currentPath);
  }
  generate(0, pathname);
  return combinations;
}