next-vite-router 1.2.2 → 1.2.3

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
@@ -203,8 +189,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";

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.3";
 const pkg = {
   version
 };

package/dist/plugin.js

@@ -1,60 +1,60 @@
 import h 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);
+import { a as b, n as j } from "./tree-HwBRWJNI.js";
+function $(n) {
+  const e = n.split(l.sep).filter(Boolean).map(j).filter(Boolean);
   return e.length > 0 ? `/${e.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 T(n, e) {
+  const r = /* @__PURE__ */ new Map();
+  function i(a) {
+    for (const o of h.readdirSync(a, { withFileTypes: !0 })) {
+      const p = l.join(a, o.name);
+      if (o.isDirectory())
+        i(p);
+      else if (o.isFile() && o.name === e) {
+        const s = l.relative(n, a), u = s.split(l.sep).filter(Boolean), y = u.map((t) => {
+          const c = t.match(/^\[\[\.\.\.(.+)\]\]$/);
+          if (c)
+            return { name: c[1], optional: !0 };
+          const m = t.match(/^\[\.\.\.(.+)\]$/);
+          return m ? { name: m[1], optional: !1 } : void 0;
+        }).filter((t) => !!t), d = $(s);
+        r.set(d, { path: d, params: y });
+        const f = u[u.length - 1];
+        if (f == null ? void 0 : f.match(/^\[\[\.\.\.(.+)\]\]$/)) {
+          const t = u.slice(0, -1).join(l.sep), c = $(t);
+          r.has(c) || r.set(c, { path: c, params: [] });
         }
       }
     }
   }
-  return h.existsSync(r) && s(r), [...n.values()].sort((a, t) => a.path.localeCompare(t.path));
+  return h.existsSync(n) && i(n), [...r.values()].sort((a, o) => a.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 F(n, e) {
+  const r = [];
+  function i(a) {
+    for (const o of h.readdirSync(a, { withFileTypes: !0 })) {
+      const p = l.join(a, o.name);
+      o.isDirectory() ? i(p) : o.isFile() && o.name === e && r.push(l.relative(n, p));
     }
   }
-  return h.existsSync(r) && s(r), n;
+  return h.existsSync(n) && i(n), r;
 }
-function F(r) {
-  const e = r.match(/^\/(?:\[\.\.\.|:)([^/\]]+)\]?$/);
+function k(n) {
+  const e = n.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 w(n) {
+  const e = n.map(({ path: i }) => `  | "${i}"`).join(`
+`), r = n.map(({ path: i, params: a }) => {
+    const o = i.split("/").map((s) => k(`/${s}`)).filter((s) => !!s), p = o.length > 0 || a.length > 0 ? [
+      ...o.map((s) => `    ${s}: string;`),
+      ...a.map(({ name: s, optional: u }) => `    ${s}${u ? "?" : ""}: string;`)
     ].join(`
 `) : "    [key: string]: never;";
-    return `  "${s}": {
-${c}
+    return `  "${i}": {
+${p}
   };`;
   }).join(`
 `);
@@ -70,7 +70,7 @@ ${e || '  | "/"'};
     : never;
 
   export interface RoutePathParams {
-${n}
+${r}
   }
 
   export const generateRoutes: () => RouteObject[];
@@ -80,53 +80,62 @@ ${n}
 }
 `;
 }
-function S(r = {}) {
+function D(n = {}) {
   const {
     pagesDir: e = "src/app",
-    pageFile: n = "page.tsx",
-    layoutFile: s = "layout.tsx",
+    pageFile: r = "page.tsx",
+    layoutFile: i = "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");
+  } = n, o = { pagesDir: e, pageFile: r, layoutFile: i, notFoundFile: a }, p = "virtual:next-vite-router", s = "\0" + p;
+  let u = "", y = "", d, f;
+  function g() {
+    const t = w(T(u, r));
+    h.writeFileSync(y, 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) {
+      u = l.resolve(t.root, e), y = l.join(l.dirname(u), "virtual-next-vite-router.d.ts"), b(F(u, r), o), g();
     },
-    configureServer(o) {
-      const g = (p) => {
-        if (l.relative(u, p).startsWith("..") || ![n, s, a].includes(l.basename(p)))
+    configureServer(t) {
+      if (d === t)
+        return;
+      f == null || f(), d = t;
+      const c = (P) => {
+        if (l.relative(u, P).startsWith("..") || ![r, i, a].includes(l.basename(P)))
           return;
         try {
-          v(P(u, n), t);
-        } catch (R) {
-          o.config.logger.error(
-            R instanceof Error ? R.message : String(R)
+          b(F(u, r), o);
+        } catch (x) {
+          t.config.logger.error(
+            x instanceof Error ? x.message : String(x)
           );
           return;
         }
-        f();
-        const d = o.moduleGraph.getModuleById(i);
-        d && (o.moduleGraph.invalidateModule(d), o.ws.send({ type: "full-reload", path: "*" }));
+        g();
+        const v = t.moduleGraph.getModuleById(s);
+        v && (t.moduleGraph.invalidateModule(v), m && clearTimeout(m), m = setTimeout(() => {
+          m = void 0, t.ws.send({ type: "full-reload", path: "*" });
+        }, 0));
       };
-      o.watcher.on("add", g), o.watcher.on("unlink", g);
+      let m;
+      const R = () => {
+        m && (clearTimeout(m), m = void 0), t.watcher.off("add", c), t.watcher.off("unlink", c), t.watcher.off("close", R), d === t && (d = void 0, f = void 0);
+      };
+      t.watcher.on("add", c), t.watcher.on("unlink", c), t.watcher.once("close", R), f = R;
     },
-    resolveId(o) {
-      if (o === c)
-        return i;
+    resolveId(t) {
+      if (t === p)
+        return s;
     },
-    load(o) {
-      if (o === i)
+    load(t) {
+      if (t === s)
         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 pagesGlob = import.meta.glob('/${e}/**/${r}');
+const layoutsGlob = import.meta.glob('/${e}/**/${i}', { eager: true });
 const notFoundsGlob = import.meta.glob('/${e}/**/${a}');
 
 const transformPath = (path) => path.replace('/${e}/', '');
@@ -142,7 +151,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(o)});
   const routes = treeToRoutes(tree, true);
   return routes;
 }
@@ -154,6 +163,12 @@ export function Router() {
 
 let routes;
 
+if (import.meta.hot) {
+  import.meta.hot.accept(() => {
+    routes = undefined;
+  });
+}
+
 export { Link, useRoutes };
 export { useParams };
 `;
@@ -161,5 +176,5 @@ export { useParams };
   };
 }
 export {
-  S as nextViteRouter
+  D as nextViteRouter
 };

package/package.json

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