Expose utility for normalizePathname behavior

Author: blakeembrey

Readme.md

@@ -18,12 +18,19 @@ npm install path-to-regexp --save
 ## Usage
 
 ```javascript
-const { pathToRegexp, match, parse, compile } = require("path-to-regexp");
+const {
+  pathToRegexp,
+  match,
+  parse,
+  compile,
+  normalizePathname
+} = require("path-to-regexp");
 
 // pathToRegexp(path, keys?, options?)
 // match(path)
 // parse(path)
 // compile(path)
+// normalizePathname(path)
 ```
 
 - **path** A string, array of strings, or a regular expression.
@@ -162,6 +169,17 @@ match("/user/123"); //=> { path: '/user/123', index: 0, params: { id: '123' } }
 match("/invalid"); //=> false
 ```
 
+### Normalize Pathname
+
+The `normalizePathname` function will return a normalized string for matching with `pathToRegexp`.
+
+```js
+const re = pathToRegexp("/caf\u00E9");
+const input = encodeURI("/cafe\u0301");
+
+re.test(normalizePathname(input)); //=> true
+```
+
 ### Parse
 
 The `parse` function will return a list of strings and keys from a path string:
@@ -231,9 +249,9 @@ Path-To-RegExp exposes the two functions used internally that accept an array of
 Path-To-RegExp breaks compatibility with Express <= `4.x`:
 
 - RegExp special characters can only be used in a parameter
-  - Express.js 4.x used all `RegExp` special characters regardless of position - this considered a bug
+  - Express.js 4.x supported `RegExp` special characters regardless of position - this is considered a bug
 - Parameters have suffixes that augment meaning - `*`, `+` and `?`. E.g. `/:user*`
-- No wildcard asterisk (`*`) - use parameters instead (`(.*)`)
+- No wildcard asterisk (`*`) - use parameters instead (`(.*)` or `:splat*`)
 
 ## Live Demo
 

src/index.spec.ts

@@ -5,7 +5,14 @@ type Test = [
   pathToRegexp.Path,
   (pathToRegexp.RegExpOptions & pathToRegexp.ParseOptions) | undefined,
   pathToRegexp.Token[],
-  Array<[string, (string | undefined)[] | null, pathToRegexp.Match?]>,
+  Array<
+    [
+      string,
+      (string | undefined)[] | null,
+      pathToRegexp.Match?,
+      pathToRegexp.RegexpToFunctionOptions?
+    ]
+  >,
   Array<[any, string | null, pathToRegexp.TokensToFunctionOptions?]>
 ];
 
@@ -166,6 +173,17 @@ const TESTS: Test[] = [
         "/route",
         ["/route", "route"],
         { path: "/route", index: 0, params: { test: "route" } }
+      ],
+      [
+        "/caf%C3%A9",
+        ["/caf%C3%A9", "caf%C3%A9"],
+        { path: "/caf%C3%A9", index: 0, params: { test: "caf%C3%A9" } }
+      ],
+      [
+        "/caf%C3%A9",
+        ["/caf%C3%A9", "caf%C3%A9"],
+        { path: "/caf%C3%A9", index: 0, params: { test: "café" } },
+        { decode: decodeURIComponent }
       ]
     ],
     [
@@ -2732,7 +2750,7 @@ describe("path-to-regexp", function() {
           "match" + (opts ? " using " + util.inspect(opts) : ""),
           function() {
             matchCases.forEach(function(io) {
-              const [pathname, matches, params] = io;
+              const [pathname, matches, params, options] = io;
               const message = `should ${
                 matches ? "" : "not "
               }match ${util.inspect(pathname)}`;
@@ -2742,7 +2760,7 @@ describe("path-to-regexp", function() {
               });
 
               if (typeof path === "string" && params !== undefined) {
-                const match = pathToRegexp.match(path);
+                const match = pathToRegexp.match(path, options);
 
                 it(message + " params", function() {
                   expect(match(pathname)).toEqual(params);
@@ -2802,6 +2820,23 @@ describe("path-to-regexp", function() {
       );
     });
   });
+
+  describe("normalize pathname", function() {
+    it("should match normalized pathnames", function() {
+      const re = pathToRegexp.pathToRegexp("/caf\u00E9");
+      const input = encodeURI("/cafe\u0301");
+
+      expect(exec(re, pathToRegexp.normalizePathname(input))).toEqual([
+        "/caf\u00E9"
+      ]);
+    });
+
+    it("should fix repeated slashes", function() {
+      const input = encodeURI("/test///route");
+
+      expect(pathToRegexp.normalizePathname(input)).toEqual("/test/route");
+    });
+  });
 });
 
 /**

src/index.ts

@@ -14,6 +14,17 @@ export interface ParseOptions {
   whitelist?: string | string[];
 }
 
+/**
+ * Normalize a pathname for matching, replaces multiple slashes with a single
+ * slash and normalizes unicode characters to "NFC". When using this method,
+ * `decode` should be an identity function so you don't decode strings twice.
+ */
+export function normalizePathname(pathname: string) {
+  return decodeURIComponent(pathname)
+    .replace(/\/+/g, "/")
+    .normalize();
+}
+
 /**
  * Balanced bracket helper function.
  */
@@ -46,7 +57,8 @@ function balanced(open: string, close: string, str: string, index: number) {
 /**
  * Parse a string for the raw tokens.
  */
-export function parse(str: string, options: ParseOptions = {}): Token[] {
+export function parse(input: string, options: ParseOptions = {}): Token[] {
+  const str = input.normalize();
   const tokens = [];
   const defaultDelimiter = options.delimiter ?? DEFAULT_DELIMITER;
   const whitelist = options.whitelist ?? undefined;
@@ -97,6 +109,7 @@ export function parse(str: string, options: ParseOptions = {}): Token[] {
     if (str[i] === "(") {
       const end = balanced("(", ")", str, i);
 
+      // False positive on matching brackets.
       if (end > -1) {
         pattern = str.slice(i + 1, end - 1);
         i = end;
@@ -312,7 +325,7 @@ export function match<P extends object = object>(
 ) {
   const keys: Key[] = [];
   const re = pathToRegexp(str, keys, options);
-  return regexpToFunction<P>(re, keys);
+  return regexpToFunction<P>(re, keys, options);
 }
 
 /**
@@ -323,7 +336,7 @@ export function regexpToFunction<P extends object = object>(
   keys: Key[],
   options: RegexpToFunctionOptions = {}
 ): MatchFunction<P> {
-  const { decode = decodeURIComponent } = options;
+  const { decode = (x: string) => x } = options;
 
   return function(pathname: string) {
     const m = re.exec(pathname);