path-to-regexp 3.0.0 → 3.1.0

package/History.md

@@ -1,3 +1,9 @@
+3.0.0 / 2019-01-13
+==================
+
+  * Always use prefix character as delimiter token, allowing any character to be a delimiter (e.g. `/:att1-:att2-:att3-:att4-:att5`)
+  * Remove `partial` support, prefer escaping the prefix delimiter explicitly (e.g. `\\/(apple-)?icon-:res(\\d+).png`)
+
 2.4.0 / 2018-08-26
 ==================
 

package/Readme.md

@@ -57,8 +57,8 @@ Named parameters are defined by prefixing a colon to the parameter name (`:foo`)
 const regexp = pathToRegexp('/:foo/:bar')
 // keys = [{ name: 'foo', prefix: '/', ... }, { name: 'bar', prefix: '/', ... }]
 
-re.exec('/test/route')
-//=> ['/test/route', 'test', 'route']
+regexp.exec('/test/route')
+//=> [ '/test/route', 'test', 'route', index: 0, input: '/test/route', groups: undefined ]
 ```
 
 **Please note:** Parameter names must use "word characters" (`[A-Za-z0-9_]`).
@@ -73,11 +73,11 @@ Parameters can be suffixed with a question mark (`?`) to make the parameter opti
 const regexp = pathToRegexp('/:foo/:bar?')
 // keys = [{ name: 'foo', ... }, { name: 'bar', delimiter: '/', optional: true, repeat: false }]
 
-re.exec('/test')
-//=> ['/test', 'test', undefined]
+regexp.exec('/test')
+//=> [ '/test', 'test', undefined, index: 0, input: '/test', groups: undefined ]
 
-re.exec('/test/route')
-//=> ['/test', 'test', 'route']
+regexp.exec('/test/route')
+//=> [ '/test/route', 'test', 'route', index: 0, input: '/test/route', groups: undefined ]
 ```
 
 **Tip:** The prefix is also optional, escape the prefix `\/` to make it required.
@@ -90,11 +90,11 @@ Parameters can be suffixed with an asterisk (`*`) to denote a zero or more param
 const regexp = pathToRegexp('/:foo*')
 // keys = [{ name: 'foo', delimiter: '/', optional: true, repeat: true }]
 
-re.exec('/')
-//=> ['/', undefined]
+regexp.exec('/')
+//=> [ '/', undefined, index: 0, input: '/', groups: undefined ]
 
-re.exec('/bar/baz')
-//=> ['/bar/baz', 'bar/baz']
+regexp.exec('/bar/baz')
+//=> [ '/bar/baz', 'bar/baz', index: 0, input: '/bar/baz', groups: undefined ]
 ```
 
 ##### One or more
@@ -105,11 +105,11 @@ Parameters can be suffixed with a plus sign (`+`) to denote a one or more parame
 const regexp = pathToRegexp('/:foo+')
 // keys = [{ name: 'foo', delimiter: '/', optional: false, repeat: true }]
 
-re.exec('/')
+regexp.exec('/')
 //=> null
 
-re.exec('/bar/baz')
-//=> ['/bar/baz', 'bar/baz']
+regexp.exec('/bar/baz')
+//=> [ '/bar/baz','bar/baz', index: 0, input: '/bar/baz', groups: undefined ]
 ```
 
 #### Unnamed Parameters
@@ -121,7 +121,7 @@ const regexp = pathToRegexp('/:foo/(.*)')
 // keys = [{ name: 'foo', ... }, { name: 0, ... }]
 
 regexp.exec('/test/route')
-//=> ['/test/route', 'test', 'route']
+//=> [ '/test/route', 'test', 'route', index: 0, input: '/test/route', groups: undefined ]
 ```
 
 #### Custom Matching Parameters
@@ -193,6 +193,7 @@ const toPathRegexp = pathToRegexp.compile('/user/:id(\\d+)')
 toPathRegexp({ id: 123 }) //=> "/user/123"
 toPathRegexp({ id: '123' }) //=> "/user/123"
 toPathRegexp({ id: 'abc' }) //=> Throws `TypeError`.
+toPathRegexp({ id: 'abc' }, { validate: true }) //=> "/user/abc"
 ```
 
 **Note:** The generated function will throw on invalid input. It will do all necessary checks to ensure the generated path is valid. This method only works with strings.

package/index.d.ts

@@ -39,6 +39,13 @@ declare namespace pathToRegexp {
     delimiter?: string;
   }
 
+  export interface TokensToFunctionOptions {
+    /**
+     * When `true` the regexp will be case sensitive. (default: `false`)
+     */
+    sensitive?: boolean;
+  }
+
   /**
    * Parse an Express-style path into an array of tokens.
    */
@@ -47,12 +54,12 @@ declare namespace pathToRegexp {
   /**
    * Transforming an Express-style path into a valid path.
    */
-  export function compile <P extends object = object> (path: string, options?: ParseOptions): PathFunction<P>;
+  export function compile <P extends object = object> (path: string, options?: ParseOptions & TokensToFunctionOptions): PathFunction<P>;
 
   /**
    * Transform an array of tokens into a path generator function.
    */
-  export function tokensToFunction <P extends object = object> (tokens: Token[]): PathFunction<P>;
+  export function tokensToFunction <P extends object = object> (tokens: Token[], options?: TokensToFunctionOptions): PathFunction<P>;
 
   /**
    * Transform an array of tokens into a matching regular expression.
@@ -73,6 +80,10 @@ declare namespace pathToRegexp {
      * Function for encoding input strings for output.
      */
     encode?: (value: string, token: Key) => string;
+    /**
+     * When `false` the function can produce an invalid (unmatched) path. (default: `true`)
+     */
+    validate?: boolean;
   }
 
   export type Token = string | Key;

package/index.js

@@ -117,26 +117,27 @@ function parse (str, options) {
  * @return {!function(Object=, Object=)}
  */
 function compile (str, options) {
-  return tokensToFunction(parse(str, options))
+  return tokensToFunction(parse(str, options), options)
 }
 
 /**
  * Expose a method for transforming tokens into the path function.
  */
-function tokensToFunction (tokens) {
+function tokensToFunction (tokens, options) {
   // Compile all the tokens into regexps.
   var matches = new Array(tokens.length)
 
   // Compile all the patterns before compilation.
   for (var i = 0; i < tokens.length; i++) {
     if (typeof tokens[i] === 'object') {
-      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$')
+      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$', flags(options))
     }
   }
 
   return function (data, options) {
     var path = ''
     var encode = (options && options.encode) || encodeURIComponent
+    var validate = options ? options.validate !== false : true
 
     for (var i = 0; i < tokens.length; i++) {
       var token = tokens[i]
@@ -163,7 +164,7 @@ function tokensToFunction (tokens) {
         for (var j = 0; j < value.length; j++) {
           segment = encode(value[j], token)
 
-          if (!matches[i].test(segment)) {
+          if (validate && !matches[i].test(segment)) {
             throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '"')
           }
 
@@ -176,7 +177,7 @@ function tokensToFunction (tokens) {
       if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
         segment = encode(String(value), token)
 
-        if (!matches[i].test(segment)) {
+        if (validate && !matches[i].test(segment)) {
           throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but got "' + segment + '"')
         }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "path-to-regexp",
   "description": "Express style path to RegExp utility",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "main": "index.js",
   "typings": "index.d.ts",
   "files": [
@@ -34,12 +34,12 @@
   "devDependencies": {
     "@types/chai": "^4.0.4",
     "@types/mocha": "^5.2.5",
-    "@types/node": "^10.7.1",
+    "@types/node": "^12.7.3",
     "chai": "^4.1.1",
     "istanbul": "^0.4.5",
-    "mocha": "^5.2.0",
-    "standard": "^12.0.1",
-    "ts-node": "^7.0.1",
+    "mocha": "^6.2.0",
+    "standard": "^14.1.0",
+    "ts-node": "^8.3.0",
     "typescript": "^3.0.1"
   }
 }