@vaadin/hilla-file-router 24.4.0-alpha10

package/vite-plugin/collectRoutesFromFS.js

@@ -0,0 +1,71 @@
+import { opendir, readFile } from "node:fs/promises";
+import { basename, extname, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { cleanUp } from "./utils.js";
+async function checkFile(url, logger) {
+  if (url) {
+    const contents = await readFile(url, "utf-8");
+    if (contents === "") {
+      return void 0;
+    } else if (!contents.includes("export default")) {
+      logger.error(`The file "${String(url)}" should contain a default export of a component`);
+    }
+  }
+  return url;
+}
+const collator = new Intl.Collator("en-US");
+async function collectRoutesFromFS(dir, { extensions, logger, parent = dir }) {
+  const path = relative(fileURLToPath(parent), fileURLToPath(dir));
+  let children = [];
+  let layout;
+  for await (const d of await opendir(dir)) {
+    if (d.isDirectory()) {
+      children.push(await collectRoutesFromFS(new URL(`${d.name}/`, dir), { extensions, logger, parent: dir }));
+    } else if (d.isFile() && extensions.includes(extname(d.name))) {
+      const file = new URL(d.name, dir);
+      const name = basename(d.name, extname(d.name));
+      if (name.startsWith("$")) {
+        if (name === "$layout") {
+          layout = file;
+        } else if (name === "$index") {
+          children.push({
+            path: "",
+            file,
+            children: []
+          });
+        } else {
+          throw new Error('Symbol "$" is reserved for special files; only "$layout" and "$index" are allowed');
+        }
+      } else if (!name.startsWith("_")) {
+        children.push({
+          path: name,
+          file,
+          children: []
+        });
+      }
+    }
+  }
+  [children, layout] = await Promise.all([
+    Promise.all(
+      children.map(async (child) => {
+        let { file: f, layout: l } = child;
+        [f, l] = await Promise.all([checkFile(f, logger), checkFile(l, logger)]);
+        return {
+          ...child,
+          file: f,
+          layout: l
+        };
+      })
+    ),
+    checkFile(layout, logger)
+  ]);
+  return {
+    path,
+    layout,
+    children: children.sort(({ path: a }, { path: b }) => collator.compare(cleanUp(a), cleanUp(b)))
+  };
+}
+export {
+  collectRoutesFromFS as default
+};
+//# sourceMappingURL=collectRoutesFromFS.js.map

package/vite-plugin/collectRoutesFromFS.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/vite-plugin/collectRoutesFromFS.ts"],
+  "sourcesContent": ["import { opendir, readFile } from 'node:fs/promises';\nimport { basename, extname, relative } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { Logger } from 'vite';\nimport { cleanUp } from './utils.js';\n\nexport type RouteMeta = Readonly<{\n  path: string;\n  file?: URL;\n  layout?: URL;\n  children: RouteMeta[];\n}>;\n\n/**\n * Routes collector options.\n */\nexport type CollectRoutesOptions = Readonly<{\n  /**\n   * The list of extensions for files that will be collected as routes.\n   */\n  extensions: readonly string[];\n  /**\n   * The parent directory of the current directory. This is a\n   * nested parameter used inside the function only.\n   */\n  parent?: URL;\n  /**\n   * The Vite logger instance.\n   */\n  logger: Logger;\n}>;\n\nasync function checkFile(url: URL | undefined, logger: Logger): Promise<URL | undefined> {\n  if (url) {\n    const contents = await readFile(url, 'utf-8');\n    if (contents === '') {\n      return undefined;\n    } else if (!contents.includes('export default')) {\n      logger.error(`The file \"${String(url)}\" should contain a default export of a component`);\n    }\n  }\n\n  return url;\n}\n\nconst collator = new Intl.Collator('en-US');\n\n/**\n * Collect route metadata from the file system and build a route tree.\n *\n * It accepts files that start with `$` as special files.\n * - `$layout` contains a component that wraps the child components.\n * - `$index` contains a component that will be used as the index page of the directory.\n *\n * It accepts files that start with `_` as private files. They will be ignored.\n *\n * @param dir - The directory to collect routes from.\n * @param options - The options object.\n *\n * @returns The route metadata tree.\n */\nexport default async function collectRoutesFromFS(\n  dir: URL,\n  { extensions, logger, parent = dir }: CollectRoutesOptions,\n): Promise<RouteMeta> {\n  const path = relative(fileURLToPath(parent), fileURLToPath(dir));\n  let children: RouteMeta[] = [];\n  let layout: URL | undefined;\n\n  for await (const d of await opendir(dir)) {\n    if (d.isDirectory()) {\n      children.push(await collectRoutesFromFS(new URL(`${d.name}/`, dir), { extensions, logger, parent: dir }));\n    } else if (d.isFile() && extensions.includes(extname(d.name))) {\n      const file = new URL(d.name, dir);\n      const name = basename(d.name, extname(d.name));\n\n      if (name.startsWith('$')) {\n        if (name === '$layout') {\n          layout = file;\n        } else if (name === '$index') {\n          children.push({\n            path: '',\n            file,\n            children: [],\n          });\n        } else {\n          throw new Error('Symbol \"$\" is reserved for special files; only \"$layout\" and \"$index\" are allowed');\n        }\n      } else if (!name.startsWith('_')) {\n        children.push({\n          path: name,\n          file,\n          children: [],\n        });\n      }\n    }\n  }\n\n  [children, layout] = await Promise.all([\n    Promise.all(\n      children.map(async (child) => {\n        let { file: f, layout: l } = child;\n        [f, l] = await Promise.all([checkFile(f, logger), checkFile(l, logger)]);\n\n        return {\n          ...child,\n          file: f,\n          layout: l,\n        };\n      }),\n    ),\n    checkFile(layout, logger),\n  ]);\n\n  return {\n    path,\n    layout,\n    children: children.sort(({ path: a }, { path: b }) => collator.compare(cleanUp(a), cleanUp(b))),\n  };\n}\n"],
+  "mappings": "AAAA,SAAS,SAAS,gBAAgB;AAClC,SAAS,UAAU,SAAS,gBAAgB;AAC5C,SAAS,qBAAqB;AAE9B,SAAS,eAAe;AA4BxB,eAAe,UAAU,KAAsB,QAA0C;AACvF,MAAI,KAAK;AACP,UAAM,WAAW,MAAM,SAAS,KAAK,OAAO;AAC5C,QAAI,aAAa,IAAI;AACnB,aAAO;AAAA,IACT,WAAW,CAAC,SAAS,SAAS,gBAAgB,GAAG;AAC/C,aAAO,MAAM,aAAa,OAAO,GAAG,CAAC,kDAAkD;AAAA,IACzF;AAAA,EACF;AAEA,SAAO;AACT;AAEA,MAAM,WAAW,IAAI,KAAK,SAAS,OAAO;AAgB1C,eAAO,oBACL,KACA,EAAE,YAAY,QAAQ,SAAS,IAAI,GACf;AACpB,QAAM,OAAO,SAAS,cAAc,MAAM,GAAG,cAAc,GAAG,CAAC;AAC/D,MAAI,WAAwB,CAAC;AAC7B,MAAI;AAEJ,mBAAiB,KAAK,MAAM,QAAQ,GAAG,GAAG;AACxC,QAAI,EAAE,YAAY,GAAG;AACnB,eAAS,KAAK,MAAM,oBAAoB,IAAI,IAAI,GAAG,EAAE,IAAI,KAAK,GAAG,GAAG,EAAE,YAAY,QAAQ,QAAQ,IAAI,CAAC,CAAC;AAAA,IAC1G,WAAW,EAAE,OAAO,KAAK,WAAW,SAAS,QAAQ,EAAE,IAAI,CAAC,GAAG;AAC7D,YAAM,OAAO,IAAI,IAAI,EAAE,MAAM,GAAG;AAChC,YAAM,OAAO,SAAS,EAAE,MAAM,QAAQ,EAAE,IAAI,CAAC;AAE7C,UAAI,KAAK,WAAW,GAAG,GAAG;AACxB,YAAI,SAAS,WAAW;AACtB,mBAAS;AAAA,QACX,WAAW,SAAS,UAAU;AAC5B,mBAAS,KAAK;AAAA,YACZ,MAAM;AAAA,YACN;AAAA,YACA,UAAU,CAAC;AAAA,UACb,CAAC;AAAA,QACH,OAAO;AACL,gBAAM,IAAI,MAAM,mFAAmF;AAAA,QACrG;AAAA,MACF,WAAW,CAAC,KAAK,WAAW,GAAG,GAAG;AAChC,iBAAS,KAAK;AAAA,UACZ,MAAM;AAAA,UACN;AAAA,UACA,UAAU,CAAC;AAAA,QACb,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAEA,GAAC,UAAU,MAAM,IAAI,MAAM,QAAQ,IAAI;AAAA,IACrC,QAAQ;AAAA,MACN,SAAS,IAAI,OAAO,UAAU;AAC5B,YAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,IAAI;AAC7B,SAAC,GAAG,CAAC,IAAI,MAAM,QAAQ,IAAI,CAAC,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC,CAAC;AAEvE,eAAO;AAAA,UACL,GAAG;AAAA,UACH,MAAM;AAAA,UACN,QAAQ;AAAA,QACV;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IACA,UAAU,QAAQ,MAAM;AAAA,EAC1B,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,UAAU,SAAS,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,SAAS,QAAQ,QAAQ,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;AAAA,EAChG;AACF;",
+  "names": []
+}

package/vite-plugin/createRoutesFromMeta.d.ts

@@ -0,0 +1,10 @@
+import type { RouteMeta } from './collectRoutesFromFS.js';
+import type { RuntimeFileUrls } from './generateRuntimeFiles.js';
+/**
+ * Loads all the files from the received metadata and creates a framework-agnostic route tree.
+ *
+ * @param views - The abstract route tree.
+ * @param generatedDir - The directory where the generated view file will be stored.
+ */
+export default function createRoutesFromMeta(views: RouteMeta, { code: codeFile }: RuntimeFileUrls): string;
+//# sourceMappingURL=createRoutesFromMeta.d.ts.map

package/vite-plugin/createRoutesFromMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRoutesFromMeta.d.ts","sourceRoot":"","sources":["../src/vite-plugin/createRoutesFromMeta.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAmDjE;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,eAAe,GAAG,MAAM,CAgD1G"}

package/vite-plugin/createRoutesFromMeta.js

@@ -0,0 +1,79 @@
+import { sep, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { template, transform as transformer } from "@vaadin/hilla-generator-utils/ast.js";
+import createSourceFile from "@vaadin/hilla-generator-utils/createSourceFile.js";
+import ts, {
+} from "typescript";
+import { transformRoute } from "../runtime/utils.js";
+import { convertFSRouteSegmentToURLPatternFormat } from "./utils.js";
+const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+function relativize(url, generatedDir) {
+  const result = relative(fileURLToPath(generatedDir), fileURLToPath(url)).replaceAll(sep, "/");
+  if (!result.startsWith(".")) {
+    return `./${result}`;
+  }
+  return result;
+}
+function createImport(mod, file) {
+  const path = `${file.substring(0, file.lastIndexOf("."))}.js`;
+  return template(`import * as ${mod} from '${path}';
+`, ([statement]) => statement);
+}
+function createRouteData(path, mod, children) {
+  return template(
+    `const route = createRoute("${path}"${mod ? `, ${mod}` : ""}${children.length > 0 ? `, CHILDREN` : ""})`,
+    ([statement]) => statement.declarationList.declarations[0].initializer,
+    [
+      transformer(
+        (node) => ts.isIdentifier(node) && node.text === "CHILDREN" ? ts.factory.createArrayLiteralExpression(children) : node
+      )
+    ]
+  );
+}
+function createRoutesFromMeta(views, { code: codeFile }) {
+  const codeDir = new URL("./", codeFile);
+  const imports = [
+    template(
+      'import { createRoute } from "@vaadin/hilla-file-router/runtime.js";',
+      ([statement]) => statement
+    )
+  ];
+  let id = 0;
+  const routes = transformRoute(
+    views,
+    (view) => view.children.values(),
+    ({ file: file2, layout, path }, children) => {
+      const currentId = id;
+      id += 1;
+      let mod;
+      if (file2) {
+        mod = `Page${currentId}`;
+        imports.push(createImport(mod, relativize(file2, codeDir)));
+      } else if (layout) {
+        mod = `Layout${currentId}`;
+        imports.push(createImport(mod, relativize(layout, codeDir)));
+      }
+      return createRouteData(convertFSRouteSegmentToURLPatternFormat(path), mod, children);
+    }
+  );
+  const routeDeclaration = template(
+    `import a from 'IMPORTS';
+
+const routes = ROUTE;
+
+export default routes;
+`,
+    [
+      transformer(
+        (node) => ts.isImportDeclaration(node) && node.moduleSpecifier.text === "IMPORTS" ? imports : node
+      ),
+      transformer((node) => ts.isIdentifier(node) && node.text === "ROUTE" ? routes : node)
+    ]
+  );
+  const file = createSourceFile(routeDeclaration, "views.ts");
+  return printer.printFile(file);
+}
+export {
+  createRoutesFromMeta as default
+};
+//# sourceMappingURL=createRoutesFromMeta.js.map

package/vite-plugin/createRoutesFromMeta.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/vite-plugin/createRoutesFromMeta.ts"],
+  "sourcesContent": ["import { sep, relative } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { template, transform as transformer } from '@vaadin/hilla-generator-utils/ast.js';\nimport createSourceFile from '@vaadin/hilla-generator-utils/createSourceFile.js';\nimport ts, {\n  type CallExpression,\n  type ImportDeclaration,\n  type StringLiteral,\n  type VariableStatement,\n} from 'typescript';\nimport { transformRoute } from '../runtime/utils.js';\nimport type { RouteMeta } from './collectRoutesFromFS.js';\nimport type { RuntimeFileUrls } from './generateRuntimeFiles.js';\nimport { convertFSRouteSegmentToURLPatternFormat } from './utils.js';\n\nconst printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });\n\n/**\n * Convert a file URL to a relative path from the generated directory.\n *\n * @param url - The file URL to convert.\n * @param generatedDir - The directory where the generated view file will be stored.\n */\nfunction relativize(url: URL, generatedDir: URL): string {\n  const result = relative(fileURLToPath(generatedDir), fileURLToPath(url)).replaceAll(sep, '/');\n\n  if (!result.startsWith('.')) {\n    return `./${result}`;\n  }\n\n  return result;\n}\n\n/**\n * Create an import declaration for a `views` module.\n *\n * @param mod - The name of the route module to import.\n * @param file - The file path of the module.\n */\nfunction createImport(mod: string, file: string): ImportDeclaration {\n  const path = `${file.substring(0, file.lastIndexOf('.'))}.js`;\n  return template(`import * as ${mod} from '${path}';\\n`, ([statement]) => statement as ts.ImportDeclaration);\n}\n\n/**\n * Create an abstract route creation function call. The nested function calls create a route tree.\n *\n * @param path - The path of the route.\n * @param mod - The name of the route module imported as a namespace.\n * @param children - The list of child route call expressions.\n */\nfunction createRouteData(path: string, mod: string | undefined, children: readonly CallExpression[]): CallExpression {\n  return template(\n    `const route = createRoute(\"${path}\"${mod ? `, ${mod}` : ''}${children.length > 0 ? `, CHILDREN` : ''})`,\n    ([statement]) => (statement as VariableStatement).declarationList.declarations[0].initializer as CallExpression,\n    [\n      transformer((node) =>\n        ts.isIdentifier(node) && node.text === 'CHILDREN' ? ts.factory.createArrayLiteralExpression(children) : node,\n      ),\n    ],\n  );\n}\n\n/**\n * Loads all the files from the received metadata and creates a framework-agnostic route tree.\n *\n * @param views - The abstract route tree.\n * @param generatedDir - The directory where the generated view file will be stored.\n */\nexport default function createRoutesFromMeta(views: RouteMeta, { code: codeFile }: RuntimeFileUrls): string {\n  const codeDir = new URL('./', codeFile);\n  const imports: ImportDeclaration[] = [\n    template(\n      'import { createRoute } from \"@vaadin/hilla-file-router/runtime.js\";',\n      ([statement]) => statement as ts.ImportDeclaration,\n    ),\n  ];\n  let id = 0;\n\n  const routes = transformRoute<RouteMeta, CallExpression>(\n    views,\n    (view) => view.children.values(),\n    ({ file, layout, path }, children) => {\n      const currentId = id;\n      id += 1;\n\n      let mod: string | undefined;\n      if (file) {\n        mod = `Page${currentId}`;\n        imports.push(createImport(mod, relativize(file, codeDir)));\n      } else if (layout) {\n        mod = `Layout${currentId}`;\n        imports.push(createImport(mod, relativize(layout, codeDir)));\n      }\n\n      return createRouteData(convertFSRouteSegmentToURLPatternFormat(path), mod, children);\n    },\n  );\n\n  const routeDeclaration = template(\n    `import a from 'IMPORTS';\n\nconst routes = ROUTE;\n\nexport default routes;\n`,\n    [\n      transformer((node) =>\n        ts.isImportDeclaration(node) && (node.moduleSpecifier as StringLiteral).text === 'IMPORTS' ? imports : node,\n      ),\n      transformer((node) => (ts.isIdentifier(node) && node.text === 'ROUTE' ? routes : node)),\n    ],\n  );\n\n  const file = createSourceFile(routeDeclaration, 'views.ts');\n\n  return printer.printFile(file);\n}\n"],
+  "mappings": "AAAA,SAAS,KAAK,gBAAgB;AAC9B,SAAS,qBAAqB;AAC9B,SAAS,UAAU,aAAa,mBAAmB;AACnD,OAAO,sBAAsB;AAC7B,OAAO;AAAA,OAKA;AACP,SAAS,sBAAsB;AAG/B,SAAS,+CAA+C;AAExD,MAAM,UAAU,GAAG,cAAc,EAAE,SAAS,GAAG,YAAY,SAAS,CAAC;AAQrE,SAAS,WAAW,KAAU,cAA2B;AACvD,QAAM,SAAS,SAAS,cAAc,YAAY,GAAG,cAAc,GAAG,CAAC,EAAE,WAAW,KAAK,GAAG;AAE5F,MAAI,CAAC,OAAO,WAAW,GAAG,GAAG;AAC3B,WAAO,KAAK,MAAM;AAAA,EACpB;AAEA,SAAO;AACT;AAQA,SAAS,aAAa,KAAa,MAAiC;AAClE,QAAM,OAAO,GAAG,KAAK,UAAU,GAAG,KAAK,YAAY,GAAG,CAAC,CAAC;AACxD,SAAO,SAAS,eAAe,GAAG,UAAU,IAAI;AAAA,GAAQ,CAAC,CAAC,SAAS,MAAM,SAAiC;AAC5G;AASA,SAAS,gBAAgB,MAAc,KAAyB,UAAqD;AACnH,SAAO;AAAA,IACL,8BAA8B,IAAI,IAAI,MAAM,KAAK,GAAG,KAAK,EAAE,GAAG,SAAS,SAAS,IAAI,eAAe,EAAE;AAAA,IACrG,CAAC,CAAC,SAAS,MAAO,UAAgC,gBAAgB,aAAa,CAAC,EAAE;AAAA,IAClF;AAAA,MACE;AAAA,QAAY,CAAC,SACX,GAAG,aAAa,IAAI,KAAK,KAAK,SAAS,aAAa,GAAG,QAAQ,6BAA6B,QAAQ,IAAI;AAAA,MAC1G;AAAA,IACF;AAAA,EACF;AACF;AAQe,SAAR,qBAAsC,OAAkB,EAAE,MAAM,SAAS,GAA4B;AAC1G,QAAM,UAAU,IAAI,IAAI,MAAM,QAAQ;AACtC,QAAM,UAA+B;AAAA,IACnC;AAAA,MACE;AAAA,MACA,CAAC,CAAC,SAAS,MAAM;AAAA,IACnB;AAAA,EACF;AACA,MAAI,KAAK;AAET,QAAM,SAAS;AAAA,IACb;AAAA,IACA,CAAC,SAAS,KAAK,SAAS,OAAO;AAAA,IAC/B,CAAC,EAAE,MAAAA,OAAM,QAAQ,KAAK,GAAG,aAAa;AACpC,YAAM,YAAY;AAClB,YAAM;AAEN,UAAI;AACJ,UAAIA,OAAM;AACR,cAAM,OAAO,SAAS;AACtB,gBAAQ,KAAK,aAAa,KAAK,WAAWA,OAAM,OAAO,CAAC,CAAC;AAAA,MAC3D,WAAW,QAAQ;AACjB,cAAM,SAAS,SAAS;AACxB,gBAAQ,KAAK,aAAa,KAAK,WAAW,QAAQ,OAAO,CAAC,CAAC;AAAA,MAC7D;AAEA,aAAO,gBAAgB,wCAAwC,IAAI,GAAG,KAAK,QAAQ;AAAA,IACrF;AAAA,EACF;AAEA,QAAM,mBAAmB;AAAA,IACvB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA;AAAA,MACE;AAAA,QAAY,CAAC,SACX,GAAG,oBAAoB,IAAI,KAAM,KAAK,gBAAkC,SAAS,YAAY,UAAU;AAAA,MACzG;AAAA,MACA,YAAY,CAAC,SAAU,GAAG,aAAa,IAAI,KAAK,KAAK,SAAS,UAAU,SAAS,IAAK;AAAA,IACxF;AAAA,EACF;AAEA,QAAM,OAAO,iBAAiB,kBAAkB,UAAU;AAE1D,SAAO,QAAQ,UAAU,IAAI;AAC/B;",
+  "names": ["file"]
+}

package/vite-plugin/createViewConfigJson.d.ts

@@ -0,0 +1,9 @@
+import type { RouteMeta } from './collectRoutesFromFS.js';
+/**
+ * Creates a map of all leaf routes to their configuration. This file is used by the server to provide server-side
+ * routes along with managing the client-side routes.
+ *
+ * @param views - The route metadata tree.
+ */
+export default function createViewConfigJson(views: RouteMeta): Promise<string>;
+//# sourceMappingURL=createViewConfigJson.d.ts.map

package/vite-plugin/createViewConfigJson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createViewConfigJson.d.ts","sourceRoot":"","sources":["../src/vite-plugin/createViewConfigJson.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAgB1D;;;;;GAKG;AACH,wBAA8B,oBAAoB,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CA2DpF"}

package/vite-plugin/createViewConfigJson.js

@@ -0,0 +1,70 @@
+import { readFile } from "node:fs/promises";
+import { Script } from "node:vm";
+import ts, {} from "typescript";
+import { convertComponentNameToTitle } from "../shared/convertComponentNameToTitle.js";
+import traverse from "../shared/traverse.js";
+import { convertFSRouteSegmentToURLPatternFormat, extractParameterFromRouteSegment } from "./utils.js";
+function* walkAST(node) {
+  yield node;
+  for (const child of node.getChildren()) {
+    yield* walkAST(child);
+  }
+}
+async function createViewConfigJson(views) {
+  const res = await Promise.all(
+    Array.from(traverse(views), async (branch) => {
+      const configs = await Promise.all(
+        branch.map(async ({ path, file, layout }) => {
+          if (!file && !layout) {
+            return [
+              convertFSRouteSegmentToURLPatternFormat(path),
+              { params: extractParameterFromRouteSegment(path) }
+            ];
+          }
+          const sourceFile = ts.createSourceFile(
+            "f.ts",
+            await readFile(file ?? layout, "utf8"),
+            ts.ScriptTarget.ESNext,
+            true
+          );
+          let config;
+          let waitingForIdentifier = false;
+          let componentName;
+          for (const node of walkAST(sourceFile)) {
+            if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === "config") {
+              if (node.initializer && ts.isObjectLiteralExpression(node.initializer)) {
+                const code = node.initializer.getText(sourceFile);
+                const script = new Script(`(${code})`);
+                config = script.runInThisContext();
+              }
+            } else if (node.getText(sourceFile).startsWith("export default")) {
+              waitingForIdentifier = true;
+            } else if (waitingForIdentifier && ts.isIdentifier(node)) {
+              componentName = node.text;
+              break;
+            }
+          }
+          const _path = config?.route ?? path;
+          const pattern = convertFSRouteSegmentToURLPatternFormat(_path);
+          return [
+            pattern,
+            {
+              ...config,
+              params: extractParameterFromRouteSegment(_path),
+              title: config?.title ?? convertComponentNameToTitle(componentName)
+            }
+          ];
+        })
+      );
+      const key = configs.map(([path]) => path).join("/");
+      const params = configs.reduce((acc, [, { params: p }]) => Object.assign(acc, p), {});
+      const [, value] = configs[configs.length - 1];
+      return [key, { ...value, params: Object.keys(params).length > 0 ? params : void 0 }];
+    })
+  );
+  return JSON.stringify(Object.fromEntries(res));
+}
+export {
+  createViewConfigJson as default
+};
+//# sourceMappingURL=createViewConfigJson.js.map

package/vite-plugin/createViewConfigJson.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/vite-plugin/createViewConfigJson.ts"],
+  "sourcesContent": ["import { readFile } from 'node:fs/promises';\nimport { Script } from 'node:vm';\nimport ts, { type Node } from 'typescript';\nimport { convertComponentNameToTitle } from '../shared/convertComponentNameToTitle.js';\nimport type { ServerViewConfig } from '../shared/internal.js';\nimport traverse from '../shared/traverse.js';\nimport type { ViewConfig } from '../types.js';\nimport type { RouteMeta } from './collectRoutesFromFS.js';\nimport { convertFSRouteSegmentToURLPatternFormat, extractParameterFromRouteSegment } from './utils.js';\n\n/**\n * Walks the TypeScript AST using the deep-first search algorithm.\n *\n * @param node - The node to walk.\n */\nfunction* walkAST(node: Node): Generator<Node> {\n  yield node;\n\n  for (const child of node.getChildren()) {\n    yield* walkAST(child);\n  }\n}\n\n/**\n * Creates a map of all leaf routes to their configuration. This file is used by the server to provide server-side\n * routes along with managing the client-side routes.\n *\n * @param views - The route metadata tree.\n */\nexport default async function createViewConfigJson(views: RouteMeta): Promise<string> {\n  const res = await Promise.all(\n    Array.from(traverse(views), async (branch) => {\n      const configs = await Promise.all(\n        branch.map(async ({ path, file, layout }): Promise<[string, ServerViewConfig]> => {\n          if (!file && !layout) {\n            return [\n              convertFSRouteSegmentToURLPatternFormat(path),\n              { params: extractParameterFromRouteSegment(path) },\n            ] as const;\n          }\n\n          const sourceFile = ts.createSourceFile(\n            'f.ts',\n            await readFile(file ?? layout!, 'utf8'),\n            ts.ScriptTarget.ESNext,\n            true,\n          );\n          let config: ViewConfig | undefined;\n          let waitingForIdentifier = false;\n          let componentName: string | undefined;\n\n          for (const node of walkAST(sourceFile)) {\n            if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === 'config') {\n              if (node.initializer && ts.isObjectLiteralExpression(node.initializer)) {\n                const code = node.initializer.getText(sourceFile);\n                const script = new Script(`(${code})`);\n                config = script.runInThisContext() as ViewConfig;\n              }\n            } else if (node.getText(sourceFile).startsWith('export default')) {\n              waitingForIdentifier = true;\n            } else if (waitingForIdentifier && ts.isIdentifier(node)) {\n              componentName = node.text;\n              break;\n            }\n          }\n          const _path = config?.route ?? path;\n          const pattern = convertFSRouteSegmentToURLPatternFormat(_path);\n\n          return [\n            pattern,\n            {\n              ...config,\n              params: extractParameterFromRouteSegment(_path),\n              title: config?.title ?? convertComponentNameToTitle(componentName),\n            },\n          ] as const;\n        }),\n      );\n\n      const key = configs.map(([path]) => path).join('/');\n      const params = configs.reduce((acc, [, { params: p }]) => Object.assign(acc, p), {});\n      const [, value] = configs[configs.length - 1];\n\n      return [key, { ...value, params: Object.keys(params).length > 0 ? params : undefined }] as const;\n    }),\n  );\n\n  return JSON.stringify(Object.fromEntries(res));\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,cAAc;AACvB,OAAO,YAAuB;AAC9B,SAAS,mCAAmC;AAE5C,OAAO,cAAc;AAGrB,SAAS,yCAAyC,wCAAwC;AAO1F,UAAU,QAAQ,MAA6B;AAC7C,QAAM;AAEN,aAAW,SAAS,KAAK,YAAY,GAAG;AACtC,WAAO,QAAQ,KAAK;AAAA,EACtB;AACF;AAQA,eAAO,qBAA4C,OAAmC;AACpF,QAAM,MAAM,MAAM,QAAQ;AAAA,IACxB,MAAM,KAAK,SAAS,KAAK,GAAG,OAAO,WAAW;AAC5C,YAAM,UAAU,MAAM,QAAQ;AAAA,QAC5B,OAAO,IAAI,OAAO,EAAE,MAAM,MAAM,OAAO,MAA2C;AAChF,cAAI,CAAC,QAAQ,CAAC,QAAQ;AACpB,mBAAO;AAAA,cACL,wCAAwC,IAAI;AAAA,cAC5C,EAAE,QAAQ,iCAAiC,IAAI,EAAE;AAAA,YACnD;AAAA,UACF;AAEA,gBAAM,aAAa,GAAG;AAAA,YACpB;AAAA,YACA,MAAM,SAAS,QAAQ,QAAS,MAAM;AAAA,YACtC,GAAG,aAAa;AAAA,YAChB;AAAA,UACF;AACA,cAAI;AACJ,cAAI,uBAAuB;AAC3B,cAAI;AAEJ,qBAAW,QAAQ,QAAQ,UAAU,GAAG;AACtC,gBAAI,GAAG,sBAAsB,IAAI,KAAK,GAAG,aAAa,KAAK,IAAI,KAAK,KAAK,KAAK,SAAS,UAAU;AAC/F,kBAAI,KAAK,eAAe,GAAG,0BAA0B,KAAK,WAAW,GAAG;AACtE,sBAAM,OAAO,KAAK,YAAY,QAAQ,UAAU;AAChD,sBAAM,SAAS,IAAI,OAAO,IAAI,IAAI,GAAG;AACrC,yBAAS,OAAO,iBAAiB;AAAA,cACnC;AAAA,YACF,WAAW,KAAK,QAAQ,UAAU,EAAE,WAAW,gBAAgB,GAAG;AAChE,qCAAuB;AAAA,YACzB,WAAW,wBAAwB,GAAG,aAAa,IAAI,GAAG;AACxD,8BAAgB,KAAK;AACrB;AAAA,YACF;AAAA,UACF;AACA,gBAAM,QAAQ,QAAQ,SAAS;AAC/B,gBAAM,UAAU,wCAAwC,KAAK;AAE7D,iBAAO;AAAA,YACL;AAAA,YACA;AAAA,cACE,GAAG;AAAA,cACH,QAAQ,iCAAiC,KAAK;AAAA,cAC9C,OAAO,QAAQ,SAAS,4BAA4B,aAAa;AAAA,YACnE;AAAA,UACF;AAAA,QACF,CAAC;AAAA,MACH;AAEA,YAAM,MAAM,QAAQ,IAAI,CAAC,CAAC,IAAI,MAAM,IAAI,EAAE,KAAK,GAAG;AAClD,YAAM,SAAS,QAAQ,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,MAAM,OAAO,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC;AACnF,YAAM,CAAC,EAAE,KAAK,IAAI,QAAQ,QAAQ,SAAS,CAAC;AAE5C,aAAO,CAAC,KAAK,EAAE,GAAG,OAAO,QAAQ,OAAO,KAAK,MAAM,EAAE,SAAS,IAAI,SAAS,OAAU,CAAC;AAAA,IACxF,CAAC;AAAA,EACH;AAEA,SAAO,KAAK,UAAU,OAAO,YAAY,GAAG,CAAC;AAC/C;",
+  "names": []
+}

package/vite-plugin/generateRuntimeFiles.d.ts

@@ -0,0 +1,25 @@
+import type { Logger } from 'vite';
+/**
+ * The URLs of the files to generate.
+ */
+export type RuntimeFileUrls = Readonly<{
+    /**
+     * The URL of the JSON file with the leaf routes and their metadata. This file
+     * will be processed by the server to provide the final route configuration.
+     */
+    json: URL;
+    /**
+     * The URL of the module with the routes tree in a framework-agnostic format.
+     */
+    code: URL;
+}>;
+/**
+ * Collects all file-based routes from the given directory, and based on them generates two files
+ * described by {@link RuntimeFileUrls} type.
+ * @param viewsDir - The directory that contains file-based routes (views).
+ * @param urls - The URLs of the files to generate.
+ * @param extensions - The list of extensions that will be collected as routes.
+ * @param logger - The Vite logger instance.
+ */
+export declare function generateRuntimeFiles(viewsDir: URL, urls: RuntimeFileUrls, extensions: readonly string[], logger: Logger): Promise<void>;
+//# sourceMappingURL=generateRuntimeFiles.d.ts.map

package/vite-plugin/generateRuntimeFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateRuntimeFiles.d.ts","sourceRoot":"","sources":["../src/vite-plugin/generateRuntimeFiles.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAKnC;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC;;;OAGG;IACH,IAAI,EAAE,GAAG,CAAC;IACV;;OAEG;IACH,IAAI,EAAE,GAAG,CAAC;CACX,CAAC,CAAC;AAyBH;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,GAAG,EACb,IAAI,EAAE,eAAe,EACrB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/vite-plugin/generateRuntimeFiles.js

@@ -0,0 +1,36 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import collectRoutesFromFS from "./collectRoutesFromFS.js";
+import createRoutesFromMeta from "./createRoutesFromMeta.js";
+import createViewConfigJson from "./createViewConfigJson.js";
+async function generateRuntimeFile(url, data) {
+  await mkdir(new URL("./", url), { recursive: true });
+  let contents;
+  try {
+    contents = await readFile(url, "utf-8");
+  } catch (e) {
+    if (!(e != null && typeof e === "object" && "code" in e && e.code === "ENOENT")) {
+      throw e;
+    }
+  }
+  if (contents !== data) {
+    await writeFile(url, data, "utf-8");
+  }
+}
+async function generateRuntimeFiles(viewsDir, urls, extensions, logger) {
+  const routeMeta = await collectRoutesFromFS(viewsDir, { extensions, logger });
+  logger.info("Collected file-based routes");
+  const runtimeRoutesCode = createRoutesFromMeta(routeMeta, urls);
+  const viewConfigJson = await createViewConfigJson(routeMeta);
+  await Promise.all([
+    generateRuntimeFile(urls.json, viewConfigJson).then(
+      () => logger.info(`Frontend route list is generated: ${String(urls.json)}`)
+    ),
+    generateRuntimeFile(urls.code, runtimeRoutesCode).then(
+      () => logger.info(`Views module is generated: ${String(urls.code)}`)
+    )
+  ]);
+}
+export {
+  generateRuntimeFiles
+};
+//# sourceMappingURL=generateRuntimeFiles.js.map

package/vite-plugin/generateRuntimeFiles.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/vite-plugin/generateRuntimeFiles.ts"],
+  "sourcesContent": ["import { mkdir, readFile, writeFile } from 'node:fs/promises';\nimport type { Logger } from 'vite';\nimport collectRoutesFromFS from './collectRoutesFromFS.js';\nimport createRoutesFromMeta from './createRoutesFromMeta.js';\nimport createViewConfigJson from './createViewConfigJson.js';\n\n/**\n * The URLs of the files to generate.\n */\nexport type RuntimeFileUrls = Readonly<{\n  /**\n   * The URL of the JSON file with the leaf routes and their metadata. This file\n   * will be processed by the server to provide the final route configuration.\n   */\n  json: URL;\n  /**\n   * The URL of the module with the routes tree in a framework-agnostic format.\n   */\n  code: URL;\n}>;\n\n/**\n * Generates a file conditionally. If the file already exists and its content is the same as the\n * given data, the file will not be overwritten. It is useful to avoid unnecessary server\n * reboot during development.\n *\n * @param url - The URL of the file to generate.\n * @param data - The data to write to the file.\n */\nasync function generateRuntimeFile(url: URL, data: string): Promise<void> {\n  await mkdir(new URL('./', url), { recursive: true });\n  let contents: string | undefined;\n  try {\n    contents = await readFile(url, 'utf-8');\n  } catch (e: unknown) {\n    if (!(e != null && typeof e === 'object' && 'code' in e && e.code === 'ENOENT')) {\n      throw e;\n    }\n  }\n  if (contents !== data) {\n    await writeFile(url, data, 'utf-8');\n  }\n}\n\n/**\n * Collects all file-based routes from the given directory, and based on them generates two files\n * described by {@link RuntimeFileUrls} type.\n * @param viewsDir - The directory that contains file-based routes (views).\n * @param urls - The URLs of the files to generate.\n * @param extensions - The list of extensions that will be collected as routes.\n * @param logger - The Vite logger instance.\n */\nexport async function generateRuntimeFiles(\n  viewsDir: URL,\n  urls: RuntimeFileUrls,\n  extensions: readonly string[],\n  logger: Logger,\n): Promise<void> {\n  const routeMeta = await collectRoutesFromFS(viewsDir, { extensions, logger });\n  logger.info('Collected file-based routes');\n  const runtimeRoutesCode = createRoutesFromMeta(routeMeta, urls);\n  const viewConfigJson = await createViewConfigJson(routeMeta);\n\n  await Promise.all([\n    generateRuntimeFile(urls.json, viewConfigJson).then(() =>\n      logger.info(`Frontend route list is generated: ${String(urls.json)}`),\n    ),\n    generateRuntimeFile(urls.code, runtimeRoutesCode).then(() =>\n      logger.info(`Views module is generated: ${String(urls.code)}`),\n    ),\n  ]);\n}\n"],
+  "mappings": "AAAA,SAAS,OAAO,UAAU,iBAAiB;AAE3C,OAAO,yBAAyB;AAChC,OAAO,0BAA0B;AACjC,OAAO,0BAA0B;AAyBjC,eAAe,oBAAoB,KAAU,MAA6B;AACxE,QAAM,MAAM,IAAI,IAAI,MAAM,GAAG,GAAG,EAAE,WAAW,KAAK,CAAC;AACnD,MAAI;AACJ,MAAI;AACF,eAAW,MAAM,SAAS,KAAK,OAAO;AAAA,EACxC,SAAS,GAAY;AACnB,QAAI,EAAE,KAAK,QAAQ,OAAO,MAAM,YAAY,UAAU,KAAK,EAAE,SAAS,WAAW;AAC/E,YAAM;AAAA,IACR;AAAA,EACF;AACA,MAAI,aAAa,MAAM;AACrB,UAAM,UAAU,KAAK,MAAM,OAAO;AAAA,EACpC;AACF;AAUA,eAAsB,qBACpB,UACA,MACA,YACA,QACe;AACf,QAAM,YAAY,MAAM,oBAAoB,UAAU,EAAE,YAAY,OAAO,CAAC;AAC5E,SAAO,KAAK,6BAA6B;AACzC,QAAM,oBAAoB,qBAAqB,WAAW,IAAI;AAC9D,QAAM,iBAAiB,MAAM,qBAAqB,SAAS;AAE3D,QAAM,QAAQ,IAAI;AAAA,IAChB,oBAAoB,KAAK,MAAM,cAAc,EAAE;AAAA,MAAK,MAClD,OAAO,KAAK,qCAAqC,OAAO,KAAK,IAAI,CAAC,EAAE;AAAA,IACtE;AAAA,IACA,oBAAoB,KAAK,MAAM,iBAAiB,EAAE;AAAA,MAAK,MACrD,OAAO,KAAK,8BAA8B,OAAO,KAAK,IAAI,CAAC,EAAE;AAAA,IAC/D;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/vite-plugin/utils.d.ts

@@ -0,0 +1,28 @@
+import { RouteParamType } from '../shared/routeParamType.js';
+/**
+ * Converts a file system pattern to a URL pattern string.
+ *
+ * @param segment - a string representing a file system pattern:
+ * - `{param}` - for a required single parameter;
+ * - `{{param}}` - for an optional single parameter;
+ * - `{...wildcard}` - for multiple parameters, including none.
+ *
+ * @returns a string representing a URL pattern, respectively:
+ * - `:param`;
+ * - `:param?`;
+ * - `*`.
+ */
+export declare function convertFSRouteSegmentToURLPatternFormat(segment: string): string;
+/**
+ * Extracts the parameter name and its type from the route segment.
+ *
+ * @param segment - A part of the FS route URL.
+ * @returns A map of parameter names and their types.
+ */
+export declare function extractParameterFromRouteSegment(segment: string): Readonly<Record<string, RouteParamType>>;
+/**
+ * A small helper function that clears route path of the control characters in
+ * order to sort the routes alphabetically.
+ */
+export declare function cleanUp(path: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/vite-plugin/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/vite-plugin/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAqB7D;;;;;;;;;;;;GAYG;AACH,wBAAgB,uCAAuC,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAQ/E;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAc1G;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ5C"}

package/vite-plugin/utils.js

@@ -0,0 +1,49 @@
+import { RouteParamType } from "../shared/routeParamType.js";
+const routeParamTypeMap = /* @__PURE__ */ new Map([
+  [RouteParamType.Wildcard, /\{\.{3}(.+)\}/gu],
+  [RouteParamType.Optional, /\{{2}(.+)\}{2}/gu],
+  [RouteParamType.Required, /\{(.+)\}/gu]
+]);
+function getReplacer(type) {
+  switch (type) {
+    case RouteParamType.Wildcard:
+      return "*";
+    case RouteParamType.Optional:
+      return ":$1?";
+    case RouteParamType.Required:
+      return ":$1";
+  }
+}
+function convertFSRouteSegmentToURLPatternFormat(segment) {
+  let res = segment;
+  routeParamTypeMap.forEach((pattern, type) => {
+    res = res.replaceAll(pattern, getReplacer(type));
+  });
+  return res;
+}
+function extractParameterFromRouteSegment(segment) {
+  let _segment = segment;
+  const params = {};
+  for (const [type, pattern] of routeParamTypeMap) {
+    const _pattern = new RegExp(pattern.source, pattern.flags);
+    _segment = _segment.replaceAll(_pattern, (match) => {
+      const key = match.replaceAll(pattern, getReplacer(type));
+      params[key] = type;
+      return "";
+    });
+  }
+  return params;
+}
+function cleanUp(path) {
+  let res = path;
+  for (const pattern of routeParamTypeMap.values()) {
+    res = res.replaceAll(pattern, "$1");
+  }
+  return res;
+}
+export {
+  cleanUp,
+  convertFSRouteSegmentToURLPatternFormat,
+  extractParameterFromRouteSegment
+};
+//# sourceMappingURL=utils.js.map

package/vite-plugin/utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/vite-plugin/utils.ts"],
+  "sourcesContent": ["import { RouteParamType } from '../shared/routeParamType.js';\n\nconst routeParamTypeMap: ReadonlyMap<RouteParamType, RegExp> = new Map([\n  [RouteParamType.Wildcard, /\\{\\.{3}(.+)\\}/gu],\n  [RouteParamType.Optional, /\\{{2}(.+)\\}{2}/gu],\n  [RouteParamType.Required, /\\{(.+)\\}/gu],\n]);\n\n// eslint-disable-next-line consistent-return\nfunction getReplacer(type: RouteParamType): string {\n  // eslint-disable-next-line default-case\n  switch (type) {\n    case RouteParamType.Wildcard:\n      return '*';\n    case RouteParamType.Optional:\n      return ':$1?';\n    case RouteParamType.Required:\n      return ':$1';\n  }\n}\n\n/**\n * Converts a file system pattern to a URL pattern string.\n *\n * @param segment - a string representing a file system pattern:\n * - `{param}` - for a required single parameter;\n * - `{{param}}` - for an optional single parameter;\n * - `{...wildcard}` - for multiple parameters, including none.\n *\n * @returns a string representing a URL pattern, respectively:\n * - `:param`;\n * - `:param?`;\n * - `*`.\n */\nexport function convertFSRouteSegmentToURLPatternFormat(segment: string): string {\n  let res = segment;\n\n  routeParamTypeMap.forEach((pattern, type) => {\n    res = res.replaceAll(pattern, getReplacer(type));\n  });\n\n  return res;\n}\n\n/**\n * Extracts the parameter name and its type from the route segment.\n *\n * @param segment - A part of the FS route URL.\n * @returns A map of parameter names and their types.\n */\nexport function extractParameterFromRouteSegment(segment: string): Readonly<Record<string, RouteParamType>> {\n  let _segment = segment;\n  const params: Record<string, RouteParamType> = {};\n\n  for (const [type, pattern] of routeParamTypeMap) {\n    const _pattern = new RegExp(pattern.source, pattern.flags);\n    _segment = _segment.replaceAll(_pattern, (match) => {\n      const key = match.replaceAll(pattern, getReplacer(type));\n      params[key] = type;\n      return '';\n    });\n  }\n\n  return params;\n}\n\n/**\n * A small helper function that clears route path of the control characters in\n * order to sort the routes alphabetically.\n */\nexport function cleanUp(path: string): string {\n  let res = path;\n\n  for (const pattern of routeParamTypeMap.values()) {\n    res = res.replaceAll(pattern, '$1');\n  }\n\n  return res;\n}\n"],
+  "mappings": "AAAA,SAAS,sBAAsB;AAE/B,MAAM,oBAAyD,oBAAI,IAAI;AAAA,EACrE,CAAC,eAAe,UAAU,iBAAiB;AAAA,EAC3C,CAAC,eAAe,UAAU,kBAAkB;AAAA,EAC5C,CAAC,eAAe,UAAU,YAAY;AACxC,CAAC;AAGD,SAAS,YAAY,MAA8B;AAEjD,UAAQ,MAAM;AAAA,IACZ,KAAK,eAAe;AAClB,aAAO;AAAA,IACT,KAAK,eAAe;AAClB,aAAO;AAAA,IACT,KAAK,eAAe;AAClB,aAAO;AAAA,EACX;AACF;AAeO,SAAS,wCAAwC,SAAyB;AAC/E,MAAI,MAAM;AAEV,oBAAkB,QAAQ,CAAC,SAAS,SAAS;AAC3C,UAAM,IAAI,WAAW,SAAS,YAAY,IAAI,CAAC;AAAA,EACjD,CAAC;AAED,SAAO;AACT;AAQO,SAAS,iCAAiC,SAA2D;AAC1G,MAAI,WAAW;AACf,QAAM,SAAyC,CAAC;AAEhD,aAAW,CAAC,MAAM,OAAO,KAAK,mBAAmB;AAC/C,UAAM,WAAW,IAAI,OAAO,QAAQ,QAAQ,QAAQ,KAAK;AACzD,eAAW,SAAS,WAAW,UAAU,CAAC,UAAU;AAClD,YAAM,MAAM,MAAM,WAAW,SAAS,YAAY,IAAI,CAAC;AACvD,aAAO,GAAG,IAAI;AACd,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAMO,SAAS,QAAQ,MAAsB;AAC5C,MAAI,MAAM;AAEV,aAAW,WAAW,kBAAkB,OAAO,GAAG;AAChD,UAAM,IAAI,WAAW,SAAS,IAAI;AAAA,EACpC;AAEA,SAAO;AACT;",
+  "names": []
+}

package/vite-plugin.d.ts

@@ -0,0 +1,34 @@
+import type { Plugin } from 'vite';
+/**
+ * The options for the Vite file-based router plugin.
+ */
+export type PluginOptions = Readonly<{
+    /**
+     * The base directory for the router. The folders and files in this directory
+     * will be used as route paths.
+     *
+     * @defaultValue `frontend/views`
+     */
+    viewsDir?: URL | string;
+    /**
+     * The directory where the generated view file will be stored.
+     *
+     * @defaultValue `frontend/generated`
+     */
+    generatedDir?: URL | string;
+    /**
+     * The list of extensions that will be collected as routes of the file-based
+     * router.
+     *
+     * @defaultValue `['.tsx', '.jsx', '.ts', '.js']`
+     */
+    extensions?: readonly string[];
+}>;
+/**
+ * A Vite plugin that generates a router from the files in the specific directory.
+ *
+ * @param options - The plugin options.
+ * @returns A Vite plugin.
+ */
+export default function vitePluginFileSystemRouter({ viewsDir, generatedDir, extensions, }?: PluginOptions): Plugin;
+//# sourceMappingURL=vite-plugin.d.ts.map

package/vite-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin.d.ts","sourceRoot":"","sources":["src/vite-plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAU,MAAM,EAAE,MAAM,MAAM,CAAC;AAG3C;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC;IACxB;;;;OAIG;IACH,YAAY,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,0BAA0B,CAAC,EACjD,QAA4B,EAC5B,YAAoC,EACpC,UAA2C,GAC5C,GAAE,aAAkB,GAAG,MAAM,CA8E7B"}

package/vite-plugin.js

@@ -0,0 +1,70 @@
+import { basename } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { generateRuntimeFiles } from "./vite-plugin/generateRuntimeFiles.js";
+function vitePluginFileSystemRouter({
+  viewsDir = "frontend/views/",
+  generatedDir = "frontend/generated/",
+  extensions = [".tsx", ".jsx", ".ts", ".js"]
+} = {}) {
+  const hmrInjectionPattern = /(?<=import\.meta\.hot\.accept[\s\S]+)if\s\(!nextExports\)\s+return;/u;
+  let _viewsDir;
+  let _outDir;
+  let _logger;
+  let runtimeUrls;
+  return {
+    name: "vite-plugin-file-router",
+    configResolved({ logger, root, build: { outDir } }) {
+      const _root = pathToFileURL(root);
+      const _generatedDir = new URL(generatedDir, _root);
+      _viewsDir = new URL(viewsDir, _root);
+      _outDir = pathToFileURL(outDir);
+      _logger = logger;
+      _logger.info(`The directory of route files: ${String(_viewsDir)}`);
+      _logger.info(`The directory of generated files: ${String(_generatedDir)}`);
+      _logger.info(`The output directory: ${String(_outDir)}`);
+      runtimeUrls = {
+        json: new URL("views.json", _outDir),
+        code: new URL("views.ts", _generatedDir)
+      };
+    },
+    async buildStart() {
+      try {
+        await generateRuntimeFiles(_viewsDir, runtimeUrls, extensions, _logger);
+      } catch (e) {
+        _logger.error(String(e));
+      }
+    },
+    configureServer(server) {
+      const dir = fileURLToPath(_viewsDir);
+      const changeListener = (file) => {
+        if (!file.startsWith(dir)) {
+          return;
+        }
+        generateRuntimeFiles(_viewsDir, runtimeUrls, extensions, _logger).catch(
+          (e) => _logger.error(String(e))
+        );
+      };
+      server.watcher.on("add", changeListener);
+      server.watcher.on("change", changeListener);
+      server.watcher.on("unlink", changeListener);
+    },
+    transform(code, id) {
+      if (id.startsWith(fileURLToPath(_viewsDir)) && !basename(id).startsWith("_")) {
+        return {
+          code: code.replace(
+            hmrInjectionPattern,
+            `if (!nextExports) return;
+      if (Object.keys(nextExports).length === 2 && 'default' in nextExports && 'config' in nextExports) {
+        nextExports = { ...nextExports, config: currentExports.config };
+      }`
+          )
+        };
+      }
+      return void 0;
+    }
+  };
+}
+export {
+  vitePluginFileSystemRouter as default
+};
+//# sourceMappingURL=vite-plugin.js.map

package/vite-plugin.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/vite-plugin.ts"],
+  "sourcesContent": ["import { basename } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport type { TransformResult } from 'rollup';\nimport type { Logger, Plugin } from 'vite';\nimport { generateRuntimeFiles, type RuntimeFileUrls } from './vite-plugin/generateRuntimeFiles.js';\n\n/**\n * The options for the Vite file-based router plugin.\n */\nexport type PluginOptions = Readonly<{\n  /**\n   * The base directory for the router. The folders and files in this directory\n   * will be used as route paths.\n   *\n   * @defaultValue `frontend/views`\n   */\n  viewsDir?: URL | string;\n  /**\n   * The directory where the generated view file will be stored.\n   *\n   * @defaultValue `frontend/generated`\n   */\n  generatedDir?: URL | string;\n  /**\n   * The list of extensions that will be collected as routes of the file-based\n   * router.\n   *\n   * @defaultValue `['.tsx', '.jsx', '.ts', '.js']`\n   */\n  extensions?: readonly string[];\n}>;\n\n/**\n * A Vite plugin that generates a router from the files in the specific directory.\n *\n * @param options - The plugin options.\n * @returns A Vite plugin.\n */\nexport default function vitePluginFileSystemRouter({\n  viewsDir = 'frontend/views/',\n  generatedDir = 'frontend/generated/',\n  extensions = ['.tsx', '.jsx', '.ts', '.js'],\n}: PluginOptions = {}): Plugin {\n  const hmrInjectionPattern = /(?<=import\\.meta\\.hot\\.accept[\\s\\S]+)if\\s\\(!nextExports\\)\\s+return;/u;\n\n  let _viewsDir: URL;\n  let _outDir: URL;\n  let _logger: Logger;\n  let runtimeUrls: RuntimeFileUrls;\n\n  return {\n    name: 'vite-plugin-file-router',\n    configResolved({ logger, root, build: { outDir } }) {\n      const _root = pathToFileURL(root);\n      const _generatedDir = new URL(generatedDir, _root);\n\n      _viewsDir = new URL(viewsDir, _root);\n      _outDir = pathToFileURL(outDir);\n      _logger = logger;\n\n      _logger.info(`The directory of route files: ${String(_viewsDir)}`);\n      _logger.info(`The directory of generated files: ${String(_generatedDir)}`);\n      _logger.info(`The output directory: ${String(_outDir)}`);\n\n      runtimeUrls = {\n        json: new URL('views.json', _outDir),\n        code: new URL('views.ts', _generatedDir),\n      };\n    },\n    async buildStart() {\n      try {\n        await generateRuntimeFiles(_viewsDir, runtimeUrls, extensions, _logger);\n      } catch (e: unknown) {\n        _logger.error(String(e));\n      }\n    },\n    configureServer(server) {\n      const dir = fileURLToPath(_viewsDir);\n\n      const changeListener = (file: string): void => {\n        if (!file.startsWith(dir)) {\n          return;\n        }\n\n        generateRuntimeFiles(_viewsDir, runtimeUrls, extensions, _logger).catch((e: unknown) =>\n          _logger.error(String(e)),\n        );\n      };\n\n      server.watcher.on('add', changeListener);\n      server.watcher.on('change', changeListener);\n      server.watcher.on('unlink', changeListener);\n    },\n    transform(code, id): Promise<TransformResult> | TransformResult {\n      if (id.startsWith(fileURLToPath(_viewsDir)) && !basename(id).startsWith('_')) {\n        // To enable HMR for route files with exported configurations, we need\n        // to address a limitation in `react-refresh`. This library requires\n        // strict equality (`===`) for non-component exports. However, the\n        // dynamic nature of HMR makes maintaining this equality between object\n        // literals challenging.\n        //\n        // To work around this, we implement a strategy that preserves the\n        // reference to the original configuration object (`currentExports.config`),\n        // replacing any newly created configuration objects (`nextExports.config`)\n        // with it. This ensures that the HMR mechanism perceives the\n        // configuration as unchanged.\n        return {\n          code: code.replace(\n            hmrInjectionPattern,\n            `if (!nextExports) return;\n      if (Object.keys(nextExports).length === 2 && 'default' in nextExports && 'config' in nextExports) {\n        nextExports = { ...nextExports, config: currentExports.config };\n      }`,\n          ),\n        };\n      }\n\n      return undefined;\n    },\n  };\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,eAAe,qBAAqB;AAG7C,SAAS,4BAAkD;AAkC5C,SAAR,2BAA4C;AAAA,EACjD,WAAW;AAAA,EACX,eAAe;AAAA,EACf,aAAa,CAAC,QAAQ,QAAQ,OAAO,KAAK;AAC5C,IAAmB,CAAC,GAAW;AAC7B,QAAM,sBAAsB;AAE5B,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AAEJ,SAAO;AAAA,IACL,MAAM;AAAA,IACN,eAAe,EAAE,QAAQ,MAAM,OAAO,EAAE,OAAO,EAAE,GAAG;AAClD,YAAM,QAAQ,cAAc,IAAI;AAChC,YAAM,gBAAgB,IAAI,IAAI,cAAc,KAAK;AAEjD,kBAAY,IAAI,IAAI,UAAU,KAAK;AACnC,gBAAU,cAAc,MAAM;AAC9B,gBAAU;AAEV,cAAQ,KAAK,iCAAiC,OAAO,SAAS,CAAC,EAAE;AACjE,cAAQ,KAAK,qCAAqC,OAAO,aAAa,CAAC,EAAE;AACzE,cAAQ,KAAK,yBAAyB,OAAO,OAAO,CAAC,EAAE;AAEvD,oBAAc;AAAA,QACZ,MAAM,IAAI,IAAI,cAAc,OAAO;AAAA,QACnC,MAAM,IAAI,IAAI,YAAY,aAAa;AAAA,MACzC;AAAA,IACF;AAAA,IACA,MAAM,aAAa;AACjB,UAAI;AACF,cAAM,qBAAqB,WAAW,aAAa,YAAY,OAAO;AAAA,MACxE,SAAS,GAAY;AACnB,gBAAQ,MAAM,OAAO,CAAC,CAAC;AAAA,MACzB;AAAA,IACF;AAAA,IACA,gBAAgB,QAAQ;AACtB,YAAM,MAAM,cAAc,SAAS;AAEnC,YAAM,iBAAiB,CAAC,SAAuB;AAC7C,YAAI,CAAC,KAAK,WAAW,GAAG,GAAG;AACzB;AAAA,QACF;AAEA,6BAAqB,WAAW,aAAa,YAAY,OAAO,EAAE;AAAA,UAAM,CAAC,MACvE,QAAQ,MAAM,OAAO,CAAC,CAAC;AAAA,QACzB;AAAA,MACF;AAEA,aAAO,QAAQ,GAAG,OAAO,cAAc;AACvC,aAAO,QAAQ,GAAG,UAAU,cAAc;AAC1C,aAAO,QAAQ,GAAG,UAAU,cAAc;AAAA,IAC5C;AAAA,IACA,UAAU,MAAM,IAAgD;AAC9D,UAAI,GAAG,WAAW,cAAc,SAAS,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,WAAW,GAAG,GAAG;AAY5E,eAAO;AAAA,UACL,MAAM,KAAK;AAAA,YACT;AAAA,YACA;AAAA;AAAA;AAAA;AAAA,UAIF;AAAA,QACF;AAAA,MACF;AAEA,aAAO;AAAA,IACT;AAAA,EACF;AACF;",
+  "names": []
+}