stx-router 0.2.148 → 0.2.150

package/dist/index.d.ts

@@ -23,7 +23,7 @@ export type {
 // File-based router
 export { createRouter, findErrorPage, formatRoutes, Router } from './file-router';
 // Route pattern matching
-export { filePathToPattern, matchRoute, patternToRegex } from './matcher';
+export { bracketPathToRegex, filePathToPattern, matchRoute, patternToRegex } from './matcher';
 // Named routes
 export { defineRoute, defineRoutes, resetRoutes, route, setAppUrl } from './named-routes';
 // Middleware system

package/dist/index.js

@@ -1,5 +1,5 @@
 export { createRouter, findErrorPage, formatRoutes, Router } from "./file-router.js";
-export { filePathToPattern, matchRoute, patternToRegex } from "./matcher.js";
+export { bracketPathToRegex, filePathToPattern, matchRoute, patternToRegex } from "./matcher.js";
 export { defineRoute, defineRoutes, resetRoutes, route, setAppUrl } from "./named-routes.js";
 export {
   abortNavigation,

package/dist/matcher.d.ts

@@ -1,3 +1,38 @@
 export declare function filePathToPattern(filePath: string, pagesDir: string): string;
+/**
+ * Compile a route pattern into a regex and the parameter names its capture
+ * groups correspond to.
+ *
+ * Single left-to-right pass, which is the whole point. Doing it as three
+ * successive `.replace()` sweeps - optional, then catch-all, then required -
+ * collects the names in *sweep* order while the capture groups end up in
+ * *pattern* order, and the two disagree the moment one pattern mixes kinds.
+ *
+ * `/:owner/:repository/tree/:ref/:path*` collected as
+ * `[path, owner, repository, ref]` against groups `(owner)(repository)(ref)(path)`,
+ * so every value was bound to the wrong name: a repository browser given a URL
+ * showed the root of a repository named after the branch. Nothing errored -
+ * the regex matched and the page rendered - which is why it reads as a routing
+ * mystery rather than an off-by-one.
+ */
 export declare function patternToRegex(pattern: string): { regex: RegExp, params: string[] };
 export declare function matchRoute(pathname: string, routes: { pattern: string, regex: RegExp, params: string[] }[]): { route: typeof routes[0], params: Record<string, string> } | null;
+/**
+ * Compile a *file-style* route path - the one with `[param]` brackets - into a
+ * regex and its parameter names.
+ *
+ * File-based routers keep re-deriving this by hand, and the hand-rolled version
+ * is always the same two lines:
+ *
+ *   paramNames = [...p.matchAll(/\[([^\]]+)\]/g)].map(m => m[1])
+ *   regex      = p.replace(/\[([^\]]+)\]/g, '([^/]+)')
+ *
+ * which is correct for `[id]` and wrong for `[...path]` in two ways at once:
+ * the name keeps its dots, so a lookup by `path` finds nothing, and the segment
+ * compiles to `([^/]+)`, which cannot span a separator, so any multi-segment
+ * URL simply fails to match. Both symptoms, one cause, and neither is obvious
+ * from the outside - the route just quietly does not exist.
+ *
+ * Exported so nothing has to write those two lines again.
+ */
+export declare function bracketPathToRegex(routePath: string): { regex: RegExp, params: string[] };

package/dist/matcher.js

@@ -13,21 +13,33 @@ export function filePathToPattern(filePath, pagesDir) {
 }
 export function patternToRegex(pattern) {
   const params = [];
-  let regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-  regexStr = regexStr.replace(/\/:([^/]+)\?/g, (_, name) => {
-    params.push(name);
-    return "(?:/([^/]+))?";
-  });
-  regexStr = regexStr.replace(/:([^/]+)\*/g, (_, name) => {
-    params.push(name);
-    return "(.+)";
-  });
-  regexStr = regexStr.replace(/:([^/]+)/g, (_, name) => {
-    params.push(name);
-    return "([^/]+)";
-  });
-  regexStr = `^${regexStr}$`;
-  return { regex: new RegExp(regexStr), params };
+  let regexStr = "", i = 0;
+  while (i < pattern.length) {
+    const rest = pattern.slice(i), optional = /^\/:([^/?*]+)\?/.exec(rest);
+    if (optional) {
+      params.push(optional[1]);
+      regexStr += "(?:/([^/]+))?";
+      i += optional[0].length;
+      continue;
+    }
+    const catchAll = /^:([^/?*]+)\*/.exec(rest);
+    if (catchAll) {
+      params.push(catchAll[1]);
+      regexStr += "(.+)";
+      i += catchAll[0].length;
+      continue;
+    }
+    const required = /^:([^/?*]+)/.exec(rest);
+    if (required) {
+      params.push(required[1]);
+      regexStr += "([^/]+)";
+      i += required[0].length;
+      continue;
+    }
+    regexStr += pattern[i].replace(/[.+^${}()|[\]\\*?]/g, "\\$&");
+    i += 1;
+  }
+  return { regex: new RegExp(`^${regexStr}$`), params };
 }
 export function matchRoute(pathname, routes) {
   const normalizedPath = pathname === "" ? "/" : pathname;
@@ -43,3 +55,7 @@ export function matchRoute(pathname, routes) {
   }
   return null;
 }
+export function bracketPathToRegex(routePath) {
+  const pattern = routePath.replace(/\[\[([^\]]+)\]\]/g, ":$1?").replace(/\[([^\]]+)\]/g, ":$1").replace(/:\.\.\.([^/]+)/g, ":$1*");
+  return patternToRegex(pattern);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "stx-router",
   "type": "module",
-  "version": "0.2.148",
+  "version": "0.2.150",
   "description": "File-based router for STX — .stx template discovery, nested layouts, typed route params, middleware, and client-side SPA navigation.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",