next-vite-router 1.2.2 → 1.2.4

package/README.md

@@ -6,33 +6,19 @@ Define routes with folders and let the package generate the
 [React Router](https://reactrouter.com/) `RouteObject[]`. It does not replace
 React Router, navigation, history, loaders, or application state.
 
-## Release notes
-
-### Plugin import
-
-The Vite plugin is no longer exported from the main
-`next-vite-router` entry point. Existing imports must be migrated:
-
-```ts
-// Previous import
-import { nextViteRouter } from "next-vite-router";
-
-// Current import
-import { nextViteRouter } from "next-vite-router/plugin";
-```
-
-The plugin remains available through `next-vite-router/plugin`. This separation
-prevents the plugin's Node dependencies from being included in the application's
-browser dependency graph.
-
 ## Start here
 
 ```bash
 npm create vite@latest my-app -- --template react-ts
 cd my-app
-npm install next-vite-router react-router-dom
+npm install next-vite-router
 ```
 
+`next-vite-router` declares `react-router-dom` as a peer dependency. Recent
+versions of npm install this dependency automatically; if your package manager
+does not resolve peer dependencies automatically, install
+`react-router-dom` explicitly.
+
 Add the plugin to `vite.config.ts`:
 
 ```ts
@@ -147,13 +133,17 @@ create competing navigation or data-loading APIs.
 | `(admin)` | Route group omitted from the URL |
 
 Catch-all pages and `not-found.tsx` at the same level both use React Router's
-`*` path and should not be declared together if their fallback behavior must
-be distinct. The catch-all parameter provider wraps the page route, so a
-layout cannot read that parameter through the package `useParams` hook.
+`*` path and are rejected during route validation because their fallback
+behavior would be ambiguous. The catch-all parameter provider wraps the page
+route, so a layout cannot read that parameter through the package `useParams`
+hook.
 
 The Vite plugin accepts custom `pageFile`, `layoutFile`, and `notFoundFile`
 names. `createRouteGenerator` accepts the same options, plus `pagesDir`, as
 its optional fourth argument when custom glob paths or extensions are used.
+For the Vite plugin, `pagesDir` is relative to the Vite project root (the
+default is `src/app`). The lower-level route path utility also accepts an
+absolute `pagesDir`, which is useful for custom route generators.
 
 Layouts are the recommended way to add route-scoped navigation, providers, or
 authorization:
@@ -203,8 +193,14 @@ No manual declaration for the virtual module is required.
 
 Pages and `not-found.tsx` files use Vite's non-eager `import.meta.glob`, so
 Vite can emit separate chunks for pages. Layouts are eager because they wrap
-the generated route tree; changing a layout can therefore cause a full
-development reload. Lazy loading is enabled by default:
+the generated route tree. Vite handles ordinary content changes to pages,
+layouts, and `not-found.tsx` through its normal HMR mechanism. Creating,
+deleting, or renaming a route-related file also refreshes the generated route
+module and route declarations. Because Vite cannot reliably preserve a cached
+route tree when an `import.meta.glob` entry is added or removed, these
+structural changes trigger a full-page reload as a fallback. Lazy-loaded route
+components remain lazy-loaded during normal navigation. Lazy loading is
+enabled by default:
 
 ```tsx
 import { configureRouter } from "next-vite-router";
@@ -310,7 +306,12 @@ pnpm exec tsc -p test/fixture/tsconfig.json --noEmit
 pnpm run test:local
 ```
 
-The route matrix lives in [`test/routes.test.js`](./test/routes.test.js).
+The route matrix lives in [`test/routes.test.js`](./test/routes.test.js) and
+includes React Router `matchRoutes` assertions for dynamic parameters, route
+groups, nested `not-found.tsx` fallbacks, and catch-all pages under layouts.
+`test/test-route-types.js` covers generated TypeScript declarations and HMR
+updates, while `test/test-compatibility.js` checks the supported dependency
+ranges and generated production bootstrap.
 
 ## License
 

package/dist/cli.cjs

@@ -548,7 +548,7 @@ const init = new commander.Command().name("init").description(
 Project "${projectName}" is ready!
 `);
 });
-const version = "1.2.2";
+const version = "1.2.4";
 const pkg = {
   version
 };

package/dist/index.d.ts

@@ -5,6 +5,8 @@ import { RouteObject } from 'react-router-dom';
 
 export declare function assertNoDuplicateRoutes(filePaths: string[], fileOptions?: RouteFileOptions): void;
 
+export declare function assertNoRouteConflicts(pageFiles: string[], notFoundFiles: string[], fileOptions?: RouteFileOptions): void;
+
 export declare function buildRouteTree(pages: Record<string, () => Promise<any>>, layouts: Record<string, any>, notFounds: Record<string, () => Promise<any>>, fileOptions?: RouteFileOptions): RouteNode;
 
 export declare function CatchAllParamProvider({ name, children, }: {
@@ -47,6 +49,9 @@ export declare function createRouteGenerator(pages: Record<string, () => Promise
  * Extract the route path from a file path
  * @example "../../app/blog/[id]/page.tsx" -> "blog/[id]"
  * @example "../../app/page.tsx" -> ""
+ *
+ * `pagesDir` may be relative or absolute. The plugin resolves it relative to
+ * the Vite project root before passing it here.
  */
 export declare function extractRoutePath(filePath: string, { pagesDir, pageFile, layoutFile, notFoundFile }?: RouteFileOptions): string;
 
@@ -58,6 +63,8 @@ export declare function extractRoutePath(filePath: string, { pagesDir, pageFile,
  */
 export declare function normalizeSegment(segment: string): string;
 
+export declare function parseRouteSegments(routePath: string): RouteSegment[];
+
 export declare function registerMiddleware(pattern: RegExp, middleware: RouteMiddleware): void;
 
 export declare type RouteFileOptions = {
@@ -84,10 +91,26 @@ export declare type RouteNode = {
 
 export declare type RouterConfig = {
     loadingFallback?: React.ComponentType;
-    pagesDir?: string;
     enableLazyLoading?: boolean;
 };
 
+export declare type RouteSegment = {
+    kind: "group";
+    name: string;
+} | {
+    kind: "static";
+    name: string;
+} | {
+    kind: "dynamic";
+    name: string;
+} | {
+    kind: "catchAll";
+    name: string;
+    optional: boolean;
+};
+
+export declare function routeSegmentToPath(segment: RouteSegment): string;
+
 export declare function treeToRoutes(node: RouteNode, isRoot?: boolean, currentPath?: string): RouteObject[];
 
 export declare function useParams<T extends Record<string, string | undefined> = Record<string, string | undefined>>(): T;

package/dist/index.js

@@ -1,193 +1,222 @@
-import { n as p, b as z } from "./tree-HwBRWJNI.js";
-import { a as V, e as W } from "./tree-HwBRWJNI.js";
-import c, { Suspense as d, lazy as b, createContext as v, useContext as L } from "react";
-import { useParams as A } from "react-router-dom";
-const M = {
+import { p, r as v, b as z } from "./tree-DW5A1s6W.js";
+import { a as K, c as tt, e as et, n as nt } from "./tree-DW5A1s6W.js";
+import u, { Suspense as R, lazy as F, createContext as $, useContext as A } from "react";
+import { useParams as k } from "react-router-dom";
+const N = {
   enableLazyLoading: !0
 };
-let m = { ...M };
-function j(e) {
-  m = { ...m, ...e };
+let f = { ...N };
+function U(t) {
+  f = { ...f, ...t };
 }
-function k() {
-  return m;
+function M() {
+  return f;
 }
-let g = [];
-function q(e, t) {
-  g.push({ pattern: e, middleware: t });
+let h = [];
+function V(t, e) {
+  h.push({ pattern: t, middleware: e });
 }
-function B() {
-  g = [];
+function W() {
+  h = [];
 }
-function h(e, t) {
-  let n = t;
-  for (const r of g)
-    r.pattern.lastIndex = 0, r.pattern.test(e) && (n = r.middleware(n)), r.pattern.lastIndex = 0;
+function m(t, e) {
+  let n = e;
+  for (const r of h)
+    r.pattern.lastIndex = 0, r.pattern.test(t) && (n = r.middleware(n)), r.pattern.lastIndex = 0;
   return n;
 }
-const S = () => c.createElement("div"), C = /* @__PURE__ */ new Map();
-function R(e, t, n) {
-  const r = k();
+const T = () => u.createElement("div"), C = /* @__PURE__ */ new Map();
+function y(t, e, n) {
+  const r = M();
   if (r.enableLazyLoading === !1) {
-    const s = c.lazy(e), i = c.createElement(
-      d,
+    const c = u.lazy(t), d = u.createElement(
+      R,
       { fallback: null },
       // No loading fallback when disabled
-      c.createElement(s)
+      u.createElement(c)
     );
-    return n ? h(n, i) : i;
+    return n ? m(n, d) : d;
   }
-  let a = C.get(t);
-  a || (a = b(e), C.set(t, a));
-  const l = r.loadingFallback || S, o = c.createElement(
-    d,
-    { fallback: c.createElement(l) },
-    c.createElement(a)
+  let a = C.get(e);
+  a || (a = F(t), C.set(e, a));
+  const o = r.loadingFallback || T, l = u.createElement(
+    R,
+    { fallback: u.createElement(o) },
+    u.createElement(a)
   );
-  return n ? h(n, o) : o;
+  return n ? m(n, l) : l;
 }
-const w = v(void 0);
+const E = $(void 0);
 function D({
-  name: e,
-  children: t
+  name: t,
+  children: e
 }) {
-  return c.createElement(
-    w.Provider,
-    { value: e },
-    t
+  return u.createElement(
+    E.Provider,
+    { value: t },
+    e
   );
 }
-function N() {
-  return L(w);
+function I() {
+  return A(E);
 }
-function y(e, t) {
-  return h(e, c.createElement(t));
+function w(t, e) {
+  return m(t, u.createElement(e));
 }
-function T(e) {
-  return /^\[\[\.\.\..+\]\]$/.test(e);
+function S(t) {
+  const e = p(t)[0];
+  return (e == null ? void 0 : e.kind) === "catchAll" && e.optional;
 }
-function f(e, t, n = !1) {
-  const r = e.page;
+function g(t) {
+  const e = p(t)[0];
+  return e ? v(e) : "";
+}
+function s(t, e) {
+  return i(t, e, !0);
+}
+function i(t, e, n = !1) {
+  const r = t.page;
   if (!r)
-    throw new Error(`Route node "${e.fullPath}" has no page loader`);
-  const a = R(
+    throw new Error(`Route node "${t.fullPath}" has no page loader`);
+  const a = y(
     async () => ({ default: (await r()).default }),
-    `page:${e.fullPath || t}`,
-    t
-  ), l = e.segment.match(/^\[\[?\.\.\.(.+?)\]\]?$/), o = l ? c.createElement(D, {
-    name: l[1],
+    `page:${t.fullPath || e}`,
+    e
+  ), o = p(t.segment)[0], l = (o == null ? void 0 : o.kind) === "catchAll" ? u.createElement(D, {
+    name: o.name,
     children: a
   }) : a;
-  return n ? { index: !0, element: o } : { path: p(e.segment), element: o };
+  return n ? { index: !0, element: l } : { path: g(t.segment), element: l };
 }
-function P(e) {
-  const t = e.notFound;
-  if (!t)
-    throw new Error(`Route node "${e.fullPath}" has no not-found loader`);
-  const n = e.fullPath ? `/${e.fullPath}` : "/";
+function G(t) {
+  const e = t.notFound;
+  if (!e)
+    throw new Error(`Route node "${t.fullPath}" has no not-found loader`);
+  const n = t.fullPath ? `/${t.fullPath}` : "/";
   return {
     path: "*",
-    element: R(
-      async () => ({ default: (await t()).default }),
-      `notfound:${e.fullPath}`,
+    element: y(
+      async () => ({ default: (await e()).default }),
+      `notfound:${t.fullPath}`,
       n
     )
   };
 }
-function F(e, t) {
+function P(t) {
+  return t.notFound ? [G(t)] : [];
+}
+function O(t, e, n, r) {
+  return {
+    ...e ? { path: e } : {},
+    element: w(t, n),
+    children: r.length > 0 ? r : void 0
+  };
+}
+function x(t, e) {
   const n = [];
-  return [...e.children.entries()].sort(([r], [a]) => r.localeCompare(a)).forEach(([r, a]) => {
-    const l = p(r), o = l ? t ? `${t}/${l}` : `/${l}` : t;
-    n.push(...$(a, !1, o));
+  return [...t.children.entries()].sort(([r], [a]) => r.localeCompare(a)).forEach(([r, a]) => {
+    const o = g(r), l = o ? e ? `${e}/${o}` : `/${o}` : e;
+    n.push(...b(a, !1, l));
   }), n;
 }
-function E(e, t) {
+function L(t, e) {
   const n = [];
-  return e.page && n.push(f(e, t || "/", !0)), n.push(...F(e, t)), e.notFound && n.push(P(e)), n;
-}
-function $(e, t = !1, n = "") {
-  const r = [];
-  if (t) {
-    const u = E(e, "");
-    return e.layout ? (r.push({
-      path: "/",
-      element: y("/", e.layout),
-      children: u
-    }), r) : e.page ? u.length > 1 ? [{
-      path: "/",
-      children: u
-    }] : [{
-      path: "/",
-      element: f(e, "/", !1).element
-    }] : e.notFound ? (r.push({
-      path: "/",
-      children: u
-    }), r) : u;
-  }
-  const a = p(e.segment), l = !a, o = l ? n : n + "/" + a, s = F(e, o), i = e.notFound ? [P(e)] : [];
-  if (e.layout) {
-    const u = E(e, o);
-    return [{
-      ...l ? {} : { path: a },
-      element: y(o, e.layout),
-      children: u.length > 0 ? u : void 0
-    }];
-  }
-  if (e.page && !l) {
-    if (T(e.segment)) {
-      const u = f(e, n, !0), x = {
-        path: a,
-        element: f(e, o).element,
-        children: [...s, ...i].length > 0 ? [...s, ...i] : void 0
-      };
-      return [u, x];
-    }
-    return s.length > 0 || i.length > 0 ? [{
-      path: a,
-      children: [
-        f(e, o, !0),
-        ...s,
-        ...i
-      ]
-    }] : [{
-      path: a,
-      element: f(e, o).element
-    }];
-  }
-  if (e.page || e.notFound || !l) {
-    const u = [
-      ...e.page ? [f(e, o, !0)] : [],
-      ...s,
-      ...i
+  return t.page && n.push(s(t, e || "/")), n.push(...x(t, e)), n.push(...P(t)), n;
+}
+function j(t, e, n, r, a, o) {
+  if (S(t.segment)) {
+    const l = [...a, ...o];
+    return [
+      s(t, e),
+      {
+        path: r,
+        element: i(t, n).element,
+        children: l.length > 0 ? l : void 0
+      }
     ];
-    return [{
-      ...l ? {} : { path: a },
-      children: u.length > 0 ? u : void 0
-    }];
   }
-  return s;
-}
-function H(e, t, n, r) {
+  return a.length > 0 || o.length > 0 ? [{
+    path: r,
+    children: [
+      s(t, n),
+      ...a,
+      ...o
+    ]
+  }] : [{
+    path: r,
+    element: i(t, n).element
+  }];
+}
+function q(t, e, n, r) {
+  const a = [
+    ...t.page ? [s(t, e)] : [],
+    ...n,
+    ...r
+  ];
+  return [{
+    children: a.length > 0 ? a : void 0
+  }];
+}
+function B(t) {
+  const e = L(t, "");
+  return t.layout ? [{
+    path: "/",
+    element: w("/", t.layout),
+    children: e
+  }] : t.page ? e.length > 1 ? [{ path: "/", children: e }] : [{
+    path: "/",
+    element: i(t, "/", !1).element
+  }] : t.notFound ? [{ path: "/", children: e }] : e;
+}
+function b(t, e = !1, n = "") {
+  if (e)
+    return B(t);
+  const r = g(t.segment), a = !r, o = a ? n : n + "/" + r, l = x(t, o), c = P(t);
+  return t.layout ? [O(
+    o,
+    a ? "" : r,
+    t.layout,
+    L(t, o)
+  )] : t.page && !a ? j(
+    t,
+    n,
+    o,
+    r,
+    l,
+    c
+  ) : t.page || t.notFound || !a ? a ? q(t, o, l, c) : [{
+    path: r,
+    children: [
+      ...t.page ? [s(t, o)] : [],
+      ...l,
+      ...c
+    ]
+  }] : l;
+}
+function X(t, e, n, r) {
   return () => {
-    const a = z(e, t, n, r);
-    return $(a, !0);
+    const a = z(t, e, n, r);
+    return b(a, !0);
   };
 }
-function J() {
-  const e = A(), t = N();
-  return typeof t == "string" && e["*"] !== void 0 ? { ...e, [t]: e["*"] } : e;
+function Y() {
+  const t = k(), e = I();
+  return typeof e == "string" && t["*"] !== void 0 ? { ...t, [e]: t["*"] } : t;
 }
 export {
   D as CatchAllParamProvider,
-  V as assertNoDuplicateRoutes,
+  K as assertNoDuplicateRoutes,
+  tt as assertNoRouteConflicts,
   z as buildRouteTree,
-  B as clearMiddlewares,
-  j as configureRouter,
-  R as createLazyElement,
-  H as createRouteGenerator,
-  W as extractRoutePath,
-  p as normalizeSegment,
-  q as registerMiddleware,
-  $ as treeToRoutes,
-  J as useParams
+  W as clearMiddlewares,
+  U as configureRouter,
+  y as createLazyElement,
+  X as createRouteGenerator,
+  et as extractRoutePath,
+  nt as normalizeSegment,
+  p as parseRouteSegments,
+  V as registerMiddleware,
+  v as routeSegmentToPath,
+  b as treeToRoutes,
+  Y as useParams
 };

package/dist/plugin.js

@@ -1,60 +1,77 @@
-import h from "node:fs";
+import P from "node:fs";
 import l from "node:path";
-import { a as v, n as b } from "./tree-HwBRWJNI.js";
-function x(r) {
-  const e = r.split(l.sep).filter(Boolean).map(b).filter(Boolean);
-  return e.length > 0 ? `/${e.join("/")}` : "/";
+import { c as $, p as S, r as k } from "./tree-DW5A1s6W.js";
+function j(n) {
+  const a = n.map(k).filter(Boolean);
+  return a.length > 0 ? `/${a.join("/")}` : "/";
 }
-function $(r, e) {
-  const n = /* @__PURE__ */ new Map();
-  function s(a) {
-    for (const t of h.readdirSync(a, { withFileTypes: !0 })) {
-      const c = l.join(a, t.name);
-      if (t.isDirectory())
-        s(c);
-      else if (t.isFile() && t.name === e) {
-        const i = l.relative(r, a), u = i.split(l.sep).filter(Boolean), y = u.map((p) => {
-          const m = p.match(/^\[\[\.\.\.(.+)\]\]$/);
-          if (m)
-            return { name: m[1], optional: !0 };
-          const d = p.match(/^\[\.\.\.(.+)\]$/);
-          return d ? { name: d[1], optional: !1 } : void 0;
-        }).filter((p) => !!p), f = x(i);
-        n.set(f, { path: f, params: y });
-        const o = u[u.length - 1];
-        if (o == null ? void 0 : o.match(/^\[\[\.\.\.(.+)\]\]$/)) {
-          const p = u.slice(0, -1).join(l.sep), m = x(p);
-          n.has(m) || n.set(m, { path: m, params: [] });
+function w(n) {
+  const a = [
+    ["pagesDir", n.pagesDir],
+    ["pageFile", n.pageFile],
+    ["layoutFile", n.layoutFile],
+    ["notFoundFile", n.notFoundFile]
+  ];
+  for (const [e, o] of a)
+    if (!o.trim())
+      throw new Error(`nextViteRouter option "${e}" must not be empty.`);
+  const r = a.slice(1), i = r.find(
+    ([, e], o) => r.slice(o + 1).some(([, u]) => u === e)
+  );
+  if (i)
+    throw new Error(
+      `nextViteRouter file options must be distinct; "${i[0]}" is duplicated.`
+    );
+}
+function O(n) {
+  return n.replace(/\\/g, "/").replace(/^\/|\/$/g, "");
+}
+function T(n, a) {
+  const r = /* @__PURE__ */ new Map();
+  function i(e) {
+    for (const o of P.readdirSync(e, { withFileTypes: !0 })) {
+      const u = l.join(e, o.name);
+      if (o.isDirectory())
+        i(u);
+      else if (o.isFile() && o.name === a) {
+        const d = l.relative(n, e).split(l.sep).filter(Boolean), s = S(d.join("/")), R = s.filter(
+          (c) => c.kind === "dynamic" || c.kind === "catchAll"
+        ).map((c) => ({
+          name: c.name,
+          optional: c.kind === "catchAll" && c.optional
+        })), m = j(s);
+        r.set(m, { path: m, params: R });
+        const f = s[s.length - 1];
+        if ((f == null ? void 0 : f.kind) === "catchAll" && f.optional) {
+          const c = d.slice(0, -1).join(l.sep), t = j(
+            S(c.split(l.sep).join("/"))
+          );
+          r.has(t) || r.set(t, { path: t, params: [] });
         }
       }
     }
   }
-  return h.existsSync(r) && s(r), [...n.values()].sort((a, t) => a.path.localeCompare(t.path));
+  return P.existsSync(n) && i(n), [...r.values()].sort((e, o) => e.path.localeCompare(o.path));
 }
-function P(r, e) {
-  const n = [];
-  function s(a) {
-    for (const t of h.readdirSync(a, { withFileTypes: !0 })) {
-      const c = l.join(a, t.name);
-      t.isDirectory() ? s(c) : t.isFile() && t.name === e && n.push(l.relative(r, c));
+function b(n, a) {
+  const r = [];
+  function i(e) {
+    for (const o of P.readdirSync(e, { withFileTypes: !0 })) {
+      const u = l.join(e, o.name);
+      o.isDirectory() ? i(u) : o.isFile() && o.name === a && r.push(l.relative(n, u));
     }
   }
-  return h.existsSync(r) && s(r), n;
+  return P.existsSync(n) && i(n), r;
 }
-function F(r) {
-  const e = r.match(/^\/(?:\[\.\.\.|:)([^/\]]+)\]?$/);
-  return e == null ? void 0 : e[1];
-}
-function j(r) {
-  const e = r.map(({ path: s }) => `  | "${s}"`).join(`
-`), n = r.map(({ path: s, params: a }) => {
-    const t = s.split("/").map((i) => F(`/${i}`)).filter((i) => !!i), c = t.length > 0 || a.length > 0 ? [
-      ...t.map((i) => `    ${i}: string;`),
-      ...a.map(({ name: i, optional: u }) => `    ${i}${u ? "?" : ""}: string;`)
+function G(n) {
+  const a = n.map(({ path: i }) => `  | ${JSON.stringify(i)}`).join(`
+`), r = n.map(({ path: i, params: e }) => {
+    const o = e.length > 0 ? [
+      ...e.map(({ name: u, optional: y }) => `    ${u}${y ? "?" : ""}: string;`)
     ].join(`
 `) : "    [key: string]: never;";
-    return `  "${s}": {
-${c}
+    return `  ${JSON.stringify(i)}: {
+${o}
   };`;
   }).join(`
 `);
@@ -63,14 +80,14 @@ ${c}
   import type { RouteObject } from 'react-router-dom';
 
   export type RoutePath =
-${e || '  | "/"'};
+${a || '  | "/"'};
 
   export type RouteParams<P extends RoutePath> = P extends keyof RoutePathParams
     ? RoutePathParams[P]
     : never;
 
   export interface RoutePathParams {
-${n}
+${r}
   }
 
   export const generateRoutes: () => RouteObject[];
@@ -80,56 +97,76 @@ ${n}
 }
 `;
 }
-function S(r = {}) {
+function M(n = {}) {
   const {
-    pagesDir: e = "src/app",
-    pageFile: n = "page.tsx",
-    layoutFile: s = "layout.tsx",
-    notFoundFile: a = "not-found.tsx"
-  } = r, t = { pagesDir: e, pageFile: n, layoutFile: s, notFoundFile: a }, c = "virtual:next-vite-router", i = "\0" + c;
-  let u = "", y = "";
-  function f() {
-    const o = j($(u, n));
-    h.writeFileSync(y, o, "utf-8");
+    pagesDir: a = "src/app",
+    pageFile: r = "page.tsx",
+    layoutFile: i = "layout.tsx",
+    notFoundFile: e = "not-found.tsx"
+  } = n;
+  w({ pagesDir: a, pageFile: r, layoutFile: i, notFoundFile: e });
+  const o = O(a), u = { pagesDir: a, pageFile: r, layoutFile: i, notFoundFile: e }, y = "virtual:next-vite-router", d = "\0" + y;
+  let s = "", R = "", m, f;
+  function c() {
+    const t = G(T(s, r));
+    P.writeFileSync(R, t, "utf-8");
   }
   return {
     name: "next-vite-router",
-    configResolved(o) {
-      u = l.resolve(o.root, e), y = l.join(l.dirname(u), "virtual-next-vite-router.d.ts"), v(P(u, n), t), f();
+    configResolved(t) {
+      s = l.resolve(t.root, a), R = l.join(l.dirname(s), "virtual-next-vite-router.d.ts"), $(
+        b(s, r),
+        b(s, e),
+        u
+      ), c();
     },
-    configureServer(o) {
-      const g = (p) => {
-        if (l.relative(u, p).startsWith("..") || ![n, s, a].includes(l.basename(p)))
+    configureServer(t) {
+      if (m === t)
+        return;
+      f == null || f(), m = t;
+      const h = (x) => {
+        if (l.relative(s, x).startsWith("..") || ![r, i, e].includes(l.basename(x)))
           return;
         try {
-          v(P(u, n), t);
-        } catch (R) {
-          o.config.logger.error(
-            R instanceof Error ? R.message : String(R)
+          $(
+            b(s, r),
+            b(s, e),
+            u
+          );
+        } catch (v) {
+          t.config.logger.error(
+            v instanceof Error ? v.message : String(v)
           );
           return;
         }
-        f();
-        const d = o.moduleGraph.getModuleById(i);
-        d && (o.moduleGraph.invalidateModule(d), o.ws.send({ type: "full-reload", path: "*" }));
+        c();
+        const F = t.moduleGraph.getModuleById(d);
+        F && (t.moduleGraph.invalidateModule(F), p && clearTimeout(p), p = setTimeout(() => {
+          p = void 0, t.ws.send({ type: "full-reload", path: "*" });
+        }, 0));
       };
-      o.watcher.on("add", g), o.watcher.on("unlink", g);
+      let p;
+      const g = () => {
+        p && (clearTimeout(p), p = void 0), t.watcher.off("add", h), t.watcher.off("unlink", h), t.watcher.off("close", g), m === t && (m = void 0, f = void 0);
+      };
+      t.watcher.on("add", h), t.watcher.on("unlink", h), t.watcher.once("close", g), f = g;
     },
-    resolveId(o) {
-      if (o === c)
-        return i;
+    resolveId(t) {
+      if (t === y)
+        return d;
     },
-    load(o) {
-      if (o === i)
+    load(t) {
+      if (t === d) {
+        const h = `/${o}/**/${r}`, p = `/${o}/**/${i}`, g = `/${o}/**/${e}`, x = `/${o}/`;
         return `
 import { buildRouteTree, treeToRoutes, normalizeSegment, createLazyElement, useParams } from 'next-vite-router';
 import { Link, useRoutes } from 'react-router-dom';
 
-const pagesGlob = import.meta.glob('/${e}/**/${n}');
-const layoutsGlob = import.meta.glob('/${e}/**/${s}', { eager: true });
-const notFoundsGlob = import.meta.glob('/${e}/**/${a}');
+const pagesGlob = import.meta.glob(${JSON.stringify(h)});
+const layoutsGlob = import.meta.glob(${JSON.stringify(p)}, { eager: true });
+const notFoundsGlob = import.meta.glob(${JSON.stringify(g)});
 
-const transformPath = (path) => path.replace('/${e}/', '');
+const transformPath = (path) => path.replace(${JSON.stringify(x)}, '');
 
 const pages = Object.fromEntries(
   Object.entries(pagesGlob).map(([key, value]) => [transformPath(key), value])
@@ -142,7 +179,7 @@ const notFounds = Object.fromEntries(
 );
 
 export function generateRoutes() {
-  const tree = buildRouteTree(pages, layouts, notFounds, ${JSON.stringify(t)});
+  const tree = buildRouteTree(pages, layouts, notFounds, ${JSON.stringify(u)});
   const routes = treeToRoutes(tree, true);
   return routes;
 }
@@ -154,12 +191,19 @@ export function Router() {
 
 let routes;
 
+if (import.meta.hot) {
+  import.meta.hot.accept(() => {
+    routes = undefined;
+  });
+}
+
 export { Link, useRoutes };
 export { useParams };
 `;
+      }
     }
   };
 }
 export {
-  S as nextViteRouter
+  M as nextViteRouter
 };

package/dist/tree-DW5A1s6W.js

@@ -0,0 +1,143 @@
+function R(t) {
+  return /^\([^)]+\)$/.test(t) ? "" : /^\[\[\.\.\.(.+)\]\]$/.test(t) || /^\[\.\.\.(.+)\]$/.test(t) ? "*" : /^\[([^\]]+)\]$/.test(t) ? t.replace(/^\[([^\]]+)\]$/, ":$1") : t;
+}
+const P = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function A(t) {
+  return t.kind === "group" ? "" : t.kind === "dynamic" ? `:${t.name}` : t.kind === "catchAll" ? "*" : t.name;
+}
+function m(t) {
+  const s = t ? t.split("/").filter(Boolean) : [], o = [], c = /* @__PURE__ */ new Set();
+  for (const a of s) {
+    const n = a.match(/^\(([^)]+)\)$/), e = a.match(/^\[\[\.\.\.(.+)\]\]$/), r = a.match(/^\[\.\.\.(.+)\]$/), i = a.match(/^\[([^\]]+)\]$/), l = e ? { name: e[1], optional: !0, kind: "catchAll" } : r ? { name: r[1], optional: !1, kind: "catchAll" } : i ? { name: i[1], optional: !1, kind: "dynamic" } : void 0;
+    if (n)
+      o.push({ kind: "group", name: n[1] });
+    else if (l) {
+      if (!P.test(l.name))
+        throw new Error(
+          `Invalid route parameter name "${l.name}" in segment "${a}". Parameter names must start with a letter or underscore and contain only letters, numbers, and underscores.`
+        );
+      if (c.has(l.name))
+        throw new Error(
+          `Duplicate route parameter "${l.name}" in route "${t || "/"}".`
+        );
+      c.add(l.name), o.push(l);
+    } else
+      o.push({ kind: "static", name: a });
+  }
+  return o;
+}
+function f(t, { pagesDir: s, pageFile: o = "page.tsx", layoutFile: c = "layout.tsx", notFoundFile: a = "not-found.tsx" } = {}) {
+  const n = t.replace(/\\/g, "/"), e = s == null ? void 0 : s.replace(/\\/g, "/").replace(/^\/|\/$/g, ""), r = e == null ? void 0 : e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), i = [o, c, a].map((l) => l.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  return n.replace(
+    e ? new RegExp(`^.*(?:^|/)${r}/`) : /^.*(?:^|\/)(?:app|pages)\//,
+    ""
+  ).replace(/\\/g, "/").replace(new RegExp(`/?(?:${i})$`), "");
+}
+function $(t) {
+  return t.kind === "group" ? "" : t.kind === "catchAll" ? "*" : t.kind === "dynamic" ? ":param" : A(t);
+}
+function g(t, s) {
+  const o = f(t, s), c = m(o), a = c.map($).filter(Boolean), n = [
+    a.length > 0 ? `/${a.join("/")}` : "/"
+  ], e = c[c.length - 1];
+  if ((e == null ? void 0 : e.kind) === "catchAll" && e.optional) {
+    const r = a.slice(0, -1);
+    n.push(r.length > 0 ? `/${r.join("/")}` : "/");
+  }
+  return n;
+}
+function w(t) {
+  return /(^|\/)(:param|\*)($|\/)/.test(t) ? "pattern" : "literal";
+}
+function j(t, s, o) {
+  const c = t.flatMap((n) => {
+    const e = f(n, o), r = m(e), i = r[r.length - 1];
+    if ((i == null ? void 0 : i.kind) !== "catchAll")
+      return [];
+    const l = r.map($).filter(Boolean), u = l.length > 0 ? `/${l.join("/")}` : "/", p = l.slice(0, -1), k = p.length > 0 ? `/${p.join("/")}` : "/";
+    return [{ filePath: n, paths: /* @__PURE__ */ new Set([u, k]) }];
+  }), a = /* @__PURE__ */ new Map();
+  for (const n of s)
+    for (const e of g(n, o))
+      for (const r of c)
+        if (r.paths.has(e)) {
+          const i = `${e}\0${r.filePath}\0${n}`;
+          a.set(i, {
+            routePath: e,
+            pageFile: r.filePath,
+            notFoundFile: n
+          });
+        }
+  if (a.size > 0)
+    throw new Error(
+      [...a.values()].sort((n, e) => n.routePath.localeCompare(e.routePath)).map(
+        ({ routePath: n, pageFile: e, notFoundFile: r }) => `Conflicting fallback routes "${n}" detected:
+  catch-all page: ${e}
+  not-found file: ${r}
+A not-found route and a catch-all page cannot coexist at the same route level.`
+      ).join(`
+
+`)
+    );
+}
+function d(t, s) {
+  const o = /* @__PURE__ */ new Map();
+  for (const a of t)
+    for (const n of g(a, s)) {
+      const e = o.get(n) ?? [];
+      e.push({ kind: w(n), filePath: a }), o.set(n, e);
+    }
+  const c = [...o.entries()].filter(([, a]) => a.length > 1).sort(([a], [n]) => a.localeCompare(n));
+  if (c.length > 0)
+    throw new Error(
+      c.map(
+        ([a, n]) => `${n[0].kind === "pattern" ? "Ambiguous route pattern" : "Duplicate route"} "${a}" detected:
+${n.sort((e, r) => e.filePath.localeCompare(r.filePath)).map((e) => `  ${e.filePath}`).join(`
+`)}`
+      ).join(`
+
+`)
+    );
+}
+function E(t, s, o) {
+  d(t, o), d(s, o), j(t, s, o);
+}
+function h(t, s, o, c, a) {
+  const n = f(s, a), e = n ? n.split("/") : [];
+  let r = t, i = "";
+  e.forEach((l, u) => {
+    i = i ? `${i}/${l}` : l, r.children.has(l) || r.children.set(l, {
+      segment: l,
+      fullPath: i,
+      children: /* @__PURE__ */ new Map()
+    }), r = r.children.get(l), u === e.length - 1 && (r[c] = o);
+  }), e.length === 0 && (t[c] = o);
+}
+function b(t, s, o, c) {
+  E(
+    Object.keys(t),
+    Object.keys(o),
+    c
+  );
+  const a = {
+    segment: "",
+    fullPath: "",
+    children: /* @__PURE__ */ new Map()
+  };
+  return Object.entries(s).forEach(([n, e]) => {
+    h(a, n, e.default, "layout", c);
+  }), Object.entries(t).forEach(([n, e]) => {
+    h(a, n, e, "page", c);
+  }), Object.entries(o).forEach(([n, e]) => {
+    h(a, n, e, "notFound", c);
+  }), a;
+}
+export {
+  d as a,
+  b,
+  E as c,
+  f as e,
+  R as n,
+  m as p,
+  A as r
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-vite-router",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Next.js-like file-based routing for React + Vite",
   "type": "module",
   "main": "./dist/index.js",

package/dist/tree-HwBRWJNI.js

@@ -1,64 +0,0 @@
-function p(t) {
-  return /^\([^)]+\)$/.test(t) ? "" : /^\[\[\.\.\.(.+)\]\]$/.test(t) || /^\[\.\.\.(.+)\]$/.test(t) ? "*" : /^\[([^\]]+)\]$/.test(t) ? t.replace(/^\[([^\]]+)\]$/, ":$1") : t;
-}
-function h(t, { pagesDir: c, pageFile: a = "page.tsx", layoutFile: o = "layout.tsx", notFoundFile: r = "not-found.tsx" } = {}) {
-  const n = t.replace(/\\/g, "/"), e = c == null ? void 0 : c.replace(/\\/g, "/").replace(/^\/|\/$/g, ""), l = [a, o, r].map((u) => u.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
-  return n.replace(
-    e ? new RegExp(`^.*(?:^|/)${e}/`) : /^.*(?:^|\/)(?:app|pages)\//,
-    ""
-  ).replace(/\\/g, "/").replace(new RegExp(`/?(?:${l})$`), "");
-}
-function $(t, c) {
-  const a = h(t, c), o = a ? a.split("/").map(p).filter(Boolean) : [];
-  return o.length > 0 ? `/${o.join("/")}` : "/";
-}
-function d(t, c) {
-  const a = /* @__PURE__ */ new Map();
-  for (const r of t) {
-    const n = $(r, c), e = a.get(n) ?? [];
-    e.push(r), a.set(n, e);
-  }
-  const o = [...a.entries()].filter(([, r]) => r.length > 1).sort(([r], [n]) => r.localeCompare(n));
-  if (o.length > 0)
-    throw new Error(
-      o.map(
-        ([r, n]) => `Duplicate route "${r}" detected:
-${n.sort((e, l) => e.localeCompare(l)).map((e) => `  ${e}`).join(`
-`)}`
-      ).join(`
-
-`)
-    );
-}
-function i(t, c, a, o, r) {
-  const n = h(c, r), e = n ? n.split("/") : [];
-  let l = t, u = "";
-  e.forEach((s, f) => {
-    u = u ? `${u}/${s}` : s, l.children.has(s) || l.children.set(s, {
-      segment: s,
-      fullPath: u,
-      children: /* @__PURE__ */ new Map()
-    }), l = l.children.get(s), f === e.length - 1 && (l[o] = a);
-  }), e.length === 0 && (t[o] = a);
-}
-function P(t, c, a, o) {
-  d(Object.keys(t), o);
-  const r = {
-    segment: "",
-    fullPath: "",
-    children: /* @__PURE__ */ new Map()
-  };
-  return Object.entries(c).forEach(([n, e]) => {
-    i(r, n, e.default, "layout", o);
-  }), Object.entries(t).forEach(([n, e]) => {
-    i(r, n, e, "page", o);
-  }), Object.entries(a).forEach(([n, e]) => {
-    i(r, n, e, "notFound", o);
-  }), r;
-}
-export {
-  d as a,
-  P as b,
-  h as e,
-  p as n
-};