Re-add Pattern token, only add regex with pipe special char

Author: Kakulukian

Readme.md

@@ -192,10 +192,18 @@ Parameter names must be provided after `:` or `*`, and they must be a valid Java
 
 Parameter names can be wrapped in double quote characters, and this error means you forgot to close the quote character.
 
-### Unterminated parameter pattern
+### Unbalanced pattern
 
 Parameter patterns must be wrapped in parentheses, and this error means you forgot to close the parentheses.
 
+### Only '|' is allowed as a special character in patterns
+
+When defining a custom pattern for a parameter (e.g., `:id(<pattern>)`), only the pipe character (`|`) is allowed as a special character inside the pattern.
+
+### Missing pattern
+
+When defining a custom pattern for a parameter (e.g., `:id(<pattern>)`), you must provide a pattern.
+
 ### Express <= 4.x
 
 Path-To-RegExp breaks compatibility with Express <= `4.x` in the following ways:

src/cases.spec.ts

@@ -412,15 +412,6 @@ export const MATCH_TESTS: MatchTestSet[] = [
       { input: "/", expected: false },
     ],
   },
-  {
-    path: "/:foo(\\d)",
-    tests: [
-      { input: "/1", expected: { path: "/1", params: { foo: "1" } } },
-      { input: "/123", expected: false },
-      { input: "/", expected: false },
-      { input: "/foo", expected: false },
-    ],
-  },
 
   /**
    * Case-sensitive paths.

src/index.spec.ts

@@ -51,10 +51,26 @@ describe("path-to-regexp", () => {
       );
     });
 
-    it("should throw on unterminated parameter pattern", () => {
-      expect(() => parse("/:foo((bar")).toThrow(
+    it("should throw on unbalanced pattern", () => {
+      expect(() => parse("/:foo((bar|sdfsdf)/")).toThrow(
         new TypeError(
-          "Unterminated parameter pattern at 10: https://git.new/pathToRegexpError",
+          "Unbalanced pattern at 5: https://git.new/pathToRegexpError",
+        ),
+      );
+    });
+
+    it("should throw on not allowed characters in pattern", () => {
+      expect(() => parse("/:foo(\\d)")).toThrow(
+        new TypeError(
+          `Only "|" is allowed as a special character in patterns at 6: https://git.new/pathToRegexpError`,
+        ),
+      );
+    });
+
+    it("should throw on missing pattern", () => {
+      expect(() => parse("//:foo()")).toThrow(
+        new TypeError(
+          "Missing pattern at 6: https://git.new/pathToRegexpError",
         ),
       );
     });

src/index.ts

@@ -3,6 +3,7 @@ const NOOP_VALUE = (value: string) => value;
 const ID_START = /^[$_\p{ID_Start}]$/u;
 const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
 const DEBUG_URL = "https://git.new/pathToRegexpError";
+const INVALID_PATTERN_CHARS = "^$.+*?[]{}\\^";
 
 /**
  * Encode a string into another string.
@@ -63,6 +64,7 @@ type TokenType =
   | "}"
   | "WILDCARD"
   | "PARAM"
+  | "PATTERN"
   | "CHAR"
   | "ESCAPED"
   | "END"
@@ -81,15 +83,15 @@ type TokenType =
 interface LexToken {
   type: TokenType;
   index: number;
-  value: string | { name: string; pattern?: string };
+  value: string;
 }
 
 const SIMPLE_TOKENS: Record<string, TokenType> = {
   // Groups.
   "{": "{",
   "}": "}",
   // Reserved.
-  "(": "(",
+  // "(": "(",
   ")": ")",
   "[": "[",
   "]": "]",
@@ -119,10 +121,7 @@ function* lexer(str: string): Generator<LexToken, LexToken> {
   const chars = [...str];
   let i = 0;
 
-  function name(options?: { pattern?: boolean }): {
-    name: string;
-    pattern?: string;
-  } {
+  function name() {
     let value = "";
 
     if (ID_START.test(chars[++i])) {
@@ -156,29 +155,47 @@ function* lexer(str: string): Generator<LexToken, LexToken> {
       throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);
     }
 
-    if (chars[i] === "(" && options?.pattern) {
-      let depth = 1;
-      let pattern = "";
-      i++;
-      while (i < chars.length && depth > 0) {
-        if (chars[i] === "(") {
-          depth++;
-        } else if (chars[i] === ")") {
-          depth--;
-        }
-        if (depth > 0) {
-          pattern += chars[i++];
-        }
-      }
-      if (depth !== 0) {
+    return value;
+  }
+
+  function pattern() {
+    const pos = i++;
+    let depth = 1;
+    let pattern = "";
+
+    while (i < chars.length && depth > 0) {
+      const char = chars[i];
+
+      if (INVALID_PATTERN_CHARS.includes(char)) {
+        console.log({ char });
         throw new TypeError(
-          `Unterminated parameter pattern at ${i}: ${DEBUG_URL}`,
+          `Only "|" is allowed as a special character in patterns at ${i}: ${DEBUG_URL}`,
         );
       }
+
+      if (char === ")") {
+        depth--;
+        if (depth === 0) {
+          i++;
+          break;
+        }
+      } else if (char === "(") {
+        depth++;
+      }
+
+      pattern += char;
       i++;
-      return { name: value, pattern };
     }
-    return { name: value };
+
+    if (depth) {
+      throw new TypeError(`Unbalanced pattern at ${pos}: ${DEBUG_URL}`);
+    }
+
+    if (!pattern) {
+      throw new TypeError(`Missing pattern at ${pos}: ${DEBUG_URL}`);
+    }
+
+    return pattern;
   }
 
   while (i < chars.length) {
@@ -190,14 +207,13 @@ function* lexer(str: string): Generator<LexToken, LexToken> {
     } else if (value === "\\") {
       yield { type: "ESCAPED", index: i++, value: chars[i++] };
     } else if (value === ":") {
-      const value = name({ pattern: true });
-      yield {
-        type: "PARAM",
-        index: i,
-        value,
-      };
+      const value = name();
+      yield { type: "PARAM", index: i, value };
+    } else if (value === "(") {
+      const value = pattern();
+      yield { type: "PATTERN", index: i, value };
     } else if (value === "*") {
-      const { name: value } = name();
+      const value = name();
       yield { type: "WILDCARD", index: i, value };
     } else {
       yield { type: "CHAR", index: i, value: chars[i++] };
@@ -220,23 +236,15 @@ class Iter {
     return this._peek;
   }
 
-  tryConsume(type: Extract<TokenType, "PARAM">): {
-    name: string;
-    pattern?: string;
-  };
-  tryConsume(type: Exclude<TokenType, "PARAM">): string;
-  tryConsume(
-    type: TokenType,
-  ): string | { name: string; pattern?: string } | undefined {
+  tryConsume(type: TokenType): string | undefined {
     const token = this.peek();
     if (token.type !== type) return;
     this._peek = undefined; // Reset after consumed.
     return token.value;
   }
 
-  consume(type: TokenType): string | { name: string; pattern?: string } {
-    const value =
-      type === "PARAM" ? this.tryConsume(type) : this.tryConsume(type);
+  consume(type: TokenType): string {
+    const value = this.tryConsume(type);
     if (value !== undefined) return value;
     const { type: nextType, index } = this.peek();
     throw new TypeError(
@@ -325,10 +333,10 @@ export function parse(str: string, options: ParseOptions = {}): TokenData {
 
       const param = it.tryConsume("PARAM");
       if (param) {
-        const { name, pattern } = param;
+        const pattern = it.tryConsume("PATTERN");
         tokens.push({
           type: "param",
-          name,
+          name: param,
           pattern,
         });
         continue;