path-to-regexp 2.1.0 → 2.4.0

package/History.md

@@ -1,3 +1,24 @@
+2.3.0 / 2018-08-20
+==================
+
+  * Use `delimiter` when processing repeated matching groups (e.g. `foo/bar` has no prefix, but has a delimiter)
+
+2.2.1 / 2018-04-24
+==================
+
+  * Allow empty string with `end: false` to match both relative and absolute paths
+
+2.2.0 / 2018-03-06
+==================
+
+  * Pass `token` as second argument to `encode` option (e.g. `encode(value, token)`)
+
+2.1.0 / 2017-10-20
+==================
+
+  * Handle non-ending paths where the final character is a delimiter
+    * E.g. `/foo/` before required either `/foo/` or `/foo//` to match in non-ending mode
+
 2.0.0 / 2017-08-23
 ==================
 

package/Readme.md

@@ -26,11 +26,12 @@ var pathToRegexp = require('path-to-regexp')
 ```
 
 - **path** A string, array of strings, or a regular expression.
-- **keys** An array to be populated with the keys found in the path.
+- **keys** An array to be populated with keys found in the path.
 - **options**
-  - **sensitive** When `true` the route will be case sensitive. (default: `false`)
-  - **strict** When `false` the trailing slash is optional. (default: `false`)
-  - **end** When `false` the path will match at the beginning. (default: `true`)
+  - **sensitive** When `true` the regexp will be case sensitive. (default: `false`)
+  - **strict** When `true` the regexp allows an optional trailing delimiter to match. (default: `false`)
+  - **end** When `true` the regexp will match to the end of the string. (default: `true`)
+  - **start** When `true` the regexp will match from the beginning of the string. (default: `true`)
   - Advanced options (use for non-pathname strings, e.g. host names):
     - **delimiter** The default delimiter for segments. (default: `'/'`)
     - **endsWith** Optional character, or list of characters, to treat as "end" characters.
@@ -61,15 +62,7 @@ re.exec('/test/route')
 //=> ['/test/route', 'test', 'route']
 ```
 
-**Please note:** Named parameters must be made up of "word characters" (`[A-Za-z0-9_]`).
-
-```js
-var re = pathToRegexp('/(apple-)?icon-:res(\\d+).png')
-// keys = [{ name: 0, prefix: '/', ... }, { name: 'res', prefix: '', ... }]
-
-re.exec('/icon-76.png')
-//=> ['/icon-76.png', undefined, '76']
-```
+**Please note:** Parameter names must be made up of "word characters" (`[A-Za-z0-9_]`).
 
 #### Parameter Modifiers
 
@@ -120,18 +113,18 @@ re.exec('/bar/baz')
 //=> ['/bar/baz', 'bar/baz']
 ```
 
-#### Custom Match Parameters
+#### Custom Matching Parameters
 
-All parameters can be provided a custom regexp, which overrides the default (`[^\/]+`).
+All parameters can be provided a custom regexp, which overrides the default match (`[^\/]+`). For example, you can match digits in the path:
 
 ```js
-var re = pathToRegexp('/:foo(\\d+)')
+var re = pathToRegexp('/icon-:foo(\\d+).png')
 // keys = [{ name: 'foo', ... }]
 
-re.exec('/123')
-//=> ['/123', '123']
+re.exec('/icon-123.png')
+//=> ['/icon-123.png', '123']
 
-re.exec('/abc')
+re.exec('/icon-abc.png')
 //=> null
 ```
 
@@ -180,7 +173,7 @@ toPath({ id: 'café' }) //=> "/user/caf%C3%A9"
 toPath({ id: '/' }) //=> "/user/%2F"
 
 toPath({ id: ':/' }) //=> "/user/%3A%2F"
-toPath({ id: ':/' }, { encode: (x) => x }) //=> "/user/:/"
+toPath({ id: ':/' }, { encode: (value, token) => value }) //=> "/user/:/"
 
 var toPathRepeated = pathToRegexp.compile('/:segment+')
 
@@ -200,7 +193,7 @@ toPathRegexp({ id: 'abc' }) //=> Throws `TypeError`.
 
 Path-To-RegExp exposes the two functions used internally that accept an array of tokens.
 
-* `pathToRegexp.tokensToRegExp(tokens, options)` Transform an array of tokens into a matching regular expression.
+* `pathToRegexp.tokensToRegExp(tokens, keys?, options?)` Transform an array of tokens into a matching regular expression.
 * `pathToRegexp.tokensToFunction(tokens)` Transform an array of tokens into a path generator function.
 
 #### Token Information

package/index.d.ts

@@ -3,17 +3,21 @@ declare function pathToRegexp (path: pathToRegexp.Path, keys?: pathToRegexp.Key[
 declare namespace pathToRegexp {
   export interface RegExpOptions {
     /**
-     * When `true` the route will be case sensitive. (default: `false`)
+     * When `true` the regexp will be case sensitive. (default: `false`)
      */
     sensitive?: boolean;
     /**
-     * When `false` the trailing slash is optional. (default: `false`)
+     * When `true` the regexp allows an optional trailing delimiter to match. (default: `false`)
      */
     strict?: boolean;
     /**
-     * When `false` the path will match at the beginning. (default: `true`)
+     * When `true` the regexp will match to the end of the string. (default: `true`)
      */
     end?: boolean;
+    /**
+     * When `true` the regexp will match from the beginning of the string. (default: `true`)
+     */
+    start?: boolean;
     /**
      * Sets the final character for non-ending optimistic matches. (default: `/`)
      */
@@ -69,7 +73,7 @@ declare namespace pathToRegexp {
     /**
      * Function for encoding input strings for output.
      */
-    encode?: (value: string) => string;
+    encode?: (value: string, token: Key) => string;
   }
 
   export type Token = string | Key;

package/index.js

@@ -25,8 +25,8 @@ var PATH_REGEXP = new RegExp([
   // Match Express-style parameters and un-named parameters with a prefix
   // and optional suffixes. Matches appear as:
   //
-  // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?"]
-  // "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined]
+  // ":test(\\d+)?" => ["test", "\d+", undefined, "?"]
+  // "(\\d+)"  => [undefined, undefined, "\d+", undefined]
   '(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?'
 ].join('|'), 'g')
 
@@ -161,7 +161,7 @@ function tokensToFunction (tokens) {
         }
 
         for (var j = 0; j < value.length; j++) {
-          segment = encode(value[j])
+          segment = encode(value[j], token)
 
           if (!matches[i].test(segment)) {
             throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '"')
@@ -174,7 +174,7 @@ function tokensToFunction (tokens) {
       }
 
       if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-        segment = encode(String(value))
+        segment = encode(String(value), token)
 
         if (!matches[i].test(segment)) {
           throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but got "' + segment + '"')
@@ -300,12 +300,13 @@ function tokensToRegExp (tokens, keys, options) {
   options = options || {}
 
   var strict = options.strict
+  var start = options.start !== false
   var end = options.end !== false
   var delimiter = escapeString(options.delimiter || DEFAULT_DELIMITER)
   var delimiters = options.delimiters || DEFAULT_DELIMITERS
   var endsWith = [].concat(options.endsWith || []).map(escapeString).concat('$').join('|')
-  var route = ''
-  var isEndDelimited = false
+  var route = start ? '^' : ''
+  var isEndDelimited = tokens.length === 0
 
   // Iterate over the tokens and create our regexp string.
   for (var i = 0; i < tokens.length; i++) {
@@ -315,21 +316,20 @@ function tokensToRegExp (tokens, keys, options) {
       route += escapeString(token)
       isEndDelimited = i === tokens.length - 1 && delimiters.indexOf(token[token.length - 1]) > -1
     } else {
-      var prefix = escapeString(token.prefix)
       var capture = token.repeat
-        ? '(?:' + token.pattern + ')(?:' + prefix + '(?:' + token.pattern + '))*'
+        ? '(?:' + token.pattern + ')(?:' + escapeString(token.delimiter) + '(?:' + token.pattern + '))*'
         : token.pattern
 
       if (keys) keys.push(token)
 
       if (token.optional) {
         if (token.partial) {
-          route += prefix + '(' + capture + ')?'
+          route += escapeString(token.prefix) + '(' + capture + ')?'
         } else {
-          route += '(?:' + prefix + '(' + capture + '))?'
+          route += '(?:' + escapeString(token.prefix) + '(' + capture + '))?'
         }
       } else {
-        route += prefix + '(' + capture + ')'
+        route += escapeString(token.prefix) + '(' + capture + ')'
       }
     }
   }
@@ -343,7 +343,7 @@ function tokensToRegExp (tokens, keys, options) {
     if (!isEndDelimited) route += '(?=' + delimiter + '|' + endsWith + ')'
   }
 
-  return new RegExp('^' + route, flags(options))
+  return new RegExp(route, flags(options))
 }
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "path-to-regexp",
   "description": "Express style path to RegExp utility",
-  "version": "2.1.0",
+  "version": "2.4.0",
   "main": "index.js",
   "typings": "index.d.ts",
   "files": [
@@ -33,13 +33,13 @@
   },
   "devDependencies": {
     "@types/chai": "^4.0.4",
-    "@types/mocha": "^2.2.42",
-    "@types/node": "^8.0.24",
+    "@types/mocha": "^5.2.5",
+    "@types/node": "^10.7.1",
     "chai": "^4.1.1",
     "istanbul": "^0.4.5",
-    "mocha": "^3.5.0",
-    "standard": "^10.0.3",
-    "ts-node": "^3.3.0",
-    "typescript": "^2.4.2"
+    "mocha": "^5.2.0",
+    "standard": "^11.0.1",
+    "ts-node": "^7.0.1",
+    "typescript": "^3.0.1"
   }
 }