feat: support hyphens in route parameter names

Allow `:test-id` style params by updating `\w+` → `[\w-]+` in all
param name regex patterns across add, regexp, and utils modules.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: pi0

src/operations/_utils.ts

@@ -20,14 +20,14 @@ export function decodeEscaped(segment: string): string {
 
 export function expandModifiers(segments: string[]): string[] | undefined {
   for (let i = 0; i < segments.length; i++) {
-    const m = segments[i].match(/^(.*:\w+(?:\([^)]*\))?)([?+*])$/);
+    const m = segments[i].match(/^(.*:[\w-]+(?:\([^)]*\))?)([?+*])$/);
     if (!m) continue;
     const pre = segments.slice(0, i);
     const suf = segments.slice(i + 1);
     if (m[2] === "?") {
       return ["/" + pre.concat(m[1]).concat(suf).join("/"), "/" + pre.concat(suf).join("/")];
     }
-    const name = m[1].match(/:(\w+)/)?.[1] || "_";
+    const name = m[1].match(/:([\w-]+)/)?.[1] || "_";
     const wc = "/" + [...pre, `**:${name}`, ...suf].join("/");
     const without = "/" + [...pre, ...suf].join("/");
     return m[2] === "+" ? [wc] : [wc, without];

src/operations/add.ts

@@ -80,7 +80,7 @@ export function addRoute<T>(
         segment.includes(":", 1) ||
         segment.includes("(") ||
         hasSegmentWildcard(segment) ||
-        !/^:\w+$/.test(segment)
+        !/^:[\w-]+$/.test(segment)
       ) {
         const [regexp, nextIndex] = getParamRegexp(segment, _unnamedParamIndex);
         _unnamedParamIndex = nextIndex;
@@ -153,7 +153,7 @@ function getParamRegexp(segment: string, unnamedStart = 0): [RegExp, number] {
   [_s, _i] = replaceSegmentWildcards(_s, _i);
 
   const regex = _s
-    .replace(/:(\w+)(?:\(([^)]*)\))?/g, (_, id, p) => `(?<${id}>${p || "[^/]+"})`)
+    .replace(/:([\w-]+)(?:\(([^)]*)\))?/g, (_, id, p) => `(?<${id}>${p || "[^/]+"})`)
     .replace(/\((?![?<])/g, () => `(?<${toUnnamedGroupKey(_i++)}>`)
     .replace(/\./g, "\\.")
     .replace(/\uFFFE(.)/g, (_, c) => (/[.*+?^${}()|[\]\\]/.test(c) ? `\\${c}` : c));

src/regexp.ts

@@ -33,15 +33,15 @@ function _routeToRegExp(route: string): RegExp {
       /(^|[^\\])\(/.test(segment) ||
       hasSegmentWildcard(segment)
     ) {
-      const modMatch = segment.match(/^(.*:\w+(?:\([^)]*\))?)([?+*])$/);
+      const modMatch = segment.match(/^(.*:[\w-]+(?:\([^)]*\))?)([?+*])$/);
       if (modMatch) {
         const [, base, mod] = modMatch;
-        const name = base.match(/:(\w+)/)?.[1] || `_${idCtr++}`;
+        const name = base.match(/:([\w-]+)/)?.[1] || `_${idCtr++}`;
 
         if (mod === "?") {
           const inner = base
             .replace(
-              /:(\w+)(?:\(([^)]*)\))?/g,
+              /:([\w-]+)(?:\(([^)]*)\))?/g,
               (_, id, pattern) => `(?<${id}>${pattern || "[^/]+"})`,
             )
             .replace(/\./g, "\\.");
@@ -91,7 +91,7 @@ function _routeToRegExp(route: string): RegExp {
         resolveEscapePlaceholders(
           dynamicSegment
             .replace(
-              /:(\w+)(?:\(([^)]*)\))?/g,
+              /:([\w-]+)(?:\(([^)]*)\))?/g,
               (_, id, pattern) => `(?<${id}>${pattern || "[^/]+"})`,
             )
             .replace(/(^|[^\\])\((?![?<])/g, (_, p) => `${p}(?<${toRegExpUnnamedKey(idCtr++)}>`)

test/find.test.ts

@@ -169,3 +169,45 @@ describe("route matching", () => {
     expect(findRoute(router, "GET", "/test")).toBeUndefined();
   });
 });
+
+describe("hyphenated param names", () => {
+  const router = createRouter([
+    "/users/:user-id",
+    "/users/:user-id/posts/:post-id",
+    "/items/:item-name/details",
+  ]);
+
+  const compiledLookup = compileRouter(router);
+
+  const lookups = [
+    {
+      name: "findRoute",
+      match: (method: string, path: string) => findRoute(router, method, path),
+    },
+    {
+      name: "compiledLookup",
+      match: (method: string, path: string) => compiledLookup(method, path),
+    },
+  ];
+
+  for (const { name, match } of lookups) {
+    it(`match hyphenated params with ${name}`, () => {
+      expect(match("GET", "/users/123")).toMatchObject({
+        data: { path: "/users/:user-id" },
+        params: { "user-id": "123" },
+      });
+      expect(match("GET", "/users/abc/posts/456")).toMatchObject({
+        data: { path: "/users/:user-id/posts/:post-id" },
+        params: { "user-id": "abc", "post-id": "456" },
+      });
+      expect(match("GET", "/items/widget/details")).toMatchObject({
+        data: { path: "/items/:item-name/details" },
+        params: { "item-name": "widget" },
+      });
+      // Hyphenated param should still be single-segment
+      expect(match("GET", "/users/foo/bar")).not.toMatchObject({
+        data: { path: "/users/:user-id" },
+      });
+    });
+  }
+});