@midwayjs/core 3.3.6 → 3.4.0-beta.11

package/dist/util/pathToRegexp.js

@@ -1,250 +1,382 @@
 "use strict";
-/**
- * this file fork from path-to-regexp package v1.8.0
- */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pathToRegexp = void 0;
+exports.PathToRegexpUtil = void 0;
 /**
- * The main path matching regexp utility.
- *
- * @type {RegExp}
+ * Tokenize input string.
  */
-const PATH_REGEXP = new RegExp([
-    // Match escaped characters that would otherwise appear in future matches.
-    // This allows the user to escape special characters that won't transform.
-    '(\\\\.)',
-    // Match Express-style parameters and un-named parameters with a prefix
-    // and optional suffixes. Matches appear as:
-    //
-    // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]
-    // "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined, undefined]
-    // "/*"            => ["/", undefined, undefined, undefined, undefined, "*"]
-    '([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))',
-].join('|'), 'g');
+function lexer(str) {
+    const tokens = [];
+    let i = 0;
+    while (i < str.length) {
+        const char = str[i];
+        if (char === '*' || char === '+' || char === '?') {
+            tokens.push({ type: 'MODIFIER', index: i, value: str[i++] });
+            continue;
+        }
+        if (char === '\\') {
+            tokens.push({ type: 'ESCAPED_CHAR', index: i++, value: str[i++] });
+            continue;
+        }
+        if (char === '{') {
+            tokens.push({ type: 'OPEN', index: i, value: str[i++] });
+            continue;
+        }
+        if (char === '}') {
+            tokens.push({ type: 'CLOSE', index: i, value: str[i++] });
+            continue;
+        }
+        if (char === ':') {
+            let name = '';
+            let j = i + 1;
+            while (j < str.length) {
+                const code = str.charCodeAt(j);
+                if (
+                // `0-9`
+                (code >= 48 && code <= 57) ||
+                    // `A-Z`
+                    (code >= 65 && code <= 90) ||
+                    // `a-z`
+                    (code >= 97 && code <= 122) ||
+                    // `_`
+                    code === 95) {
+                    name += str[j++];
+                    continue;
+                }
+                break;
+            }
+            if (!name)
+                throw new TypeError(`Missing parameter name at ${i}`);
+            tokens.push({ type: 'NAME', index: i, value: name });
+            i = j;
+            continue;
+        }
+        if (char === '(') {
+            let count = 1;
+            let pattern = '';
+            let j = i + 1;
+            if (str[j] === '?') {
+                throw new TypeError(`Pattern cannot start with "?" at ${j}`);
+            }
+            while (j < str.length) {
+                if (str[j] === '\\') {
+                    pattern += str[j++] + str[j++];
+                    continue;
+                }
+                if (str[j] === ')') {
+                    count--;
+                    if (count === 0) {
+                        j++;
+                        break;
+                    }
+                }
+                else if (str[j] === '(') {
+                    count++;
+                    if (str[j + 1] !== '?') {
+                        throw new TypeError(`Capturing groups are not allowed at ${j}`);
+                    }
+                }
+                pattern += str[j++];
+            }
+            if (count)
+                throw new TypeError(`Unbalanced pattern at ${i}`);
+            if (!pattern)
+                throw new TypeError(`Missing pattern at ${i}`);
+            tokens.push({ type: 'PATTERN', index: i, value: pattern });
+            i = j;
+            continue;
+        }
+        tokens.push({ type: 'CHAR', index: i, value: str[i++] });
+    }
+    tokens.push({ type: 'END', index: i, value: '' });
+    return tokens;
+}
 /**
  * Parse a string for the raw tokens.
- *
- * @param  {string}  str
- * @param  {Object=} options
- * @return {!Array}
  */
-function parse(str, options) {
-    const tokens = [];
+function parse(str, options = {}) {
+    const tokens = lexer(str);
+    const { prefixes = './' } = options;
+    const defaultPattern = `[^${escapeString(options.delimiter || '/#?')}]+?`;
+    const result = [];
     let key = 0;
-    let index = 0;
+    let i = 0;
     let path = '';
-    const defaultDelimiter = (options && options.delimiter) || '/';
-    let res;
-    while ((res = PATH_REGEXP.exec(str)) != null) {
-        const m = res[0];
-        const escaped = res[1];
-        const offset = res.index;
-        path += str.slice(index, offset);
-        index = offset + m.length;
-        // Ignore already escaped sequences.
-        if (escaped) {
-            path += escaped[1];
+    const tryConsume = (type) => {
+        if (i < tokens.length && tokens[i].type === type)
+            return tokens[i++].value;
+    };
+    const mustConsume = (type) => {
+        const value = tryConsume(type);
+        if (value !== undefined)
+            return value;
+        const { type: nextType, index } = tokens[i];
+        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}`);
+    };
+    const consumeText = () => {
+        let result = '';
+        let value;
+        while ((value = tryConsume('CHAR') || tryConsume('ESCAPED_CHAR'))) {
+            result += value;
+        }
+        return result;
+    };
+    while (i < tokens.length) {
+        const char = tryConsume('CHAR');
+        const name = tryConsume('NAME');
+        const pattern = tryConsume('PATTERN');
+        if (name || pattern) {
+            let prefix = char || '';
+            if (prefixes.indexOf(prefix) === -1) {
+                path += prefix;
+                prefix = '';
+            }
+            if (path) {
+                result.push(path);
+                path = '';
+            }
+            result.push({
+                name: name || key++,
+                prefix,
+                suffix: '',
+                pattern: pattern || defaultPattern,
+                modifier: tryConsume('MODIFIER') || '',
+            });
+            continue;
+        }
+        const value = char || tryConsume('ESCAPED_CHAR');
+        if (value) {
+            path += value;
             continue;
         }
-        const next = str[index];
-        const prefix = res[2];
-        const name = res[3];
-        const capture = res[4];
-        const group = res[5];
-        const modifier = res[6];
-        const asterisk = res[7];
-        // Push the current path onto the tokens.
         if (path) {
-            tokens.push(path);
+            result.push(path);
             path = '';
         }
-        const partial = prefix != null && next != null && next !== prefix;
-        const repeat = modifier === '+' || modifier === '*';
-        const optional = modifier === '?' || modifier === '*';
-        const delimiter = res[2] || defaultDelimiter;
-        const pattern = capture || group;
-        tokens.push({
-            name: name || key++,
-            prefix: prefix || '',
-            delimiter: delimiter,
-            optional: optional,
-            repeat: repeat,
-            partial: partial,
-            asterisk: !!asterisk,
-            pattern: pattern
-                ? escapeGroup(pattern)
-                : asterisk
-                    ? '.*'
-                    : '[^' + escapeString(delimiter) + ']+?',
-        });
-    }
-    // Match any characters still remaining.
-    if (index < str.length) {
-        path += str.slice(index);
-    }
-    // If the path exists, push it onto the end.
-    if (path) {
-        tokens.push(path);
+        const open = tryConsume('OPEN');
+        if (open) {
+            const prefix = consumeText();
+            const name = tryConsume('NAME') || '';
+            const pattern = tryConsume('PATTERN') || '';
+            const suffix = consumeText();
+            mustConsume('CLOSE');
+            result.push({
+                name: name || (pattern ? key++ : ''),
+                pattern: name && !pattern ? defaultPattern : pattern,
+                prefix,
+                suffix,
+                modifier: tryConsume('MODIFIER') || '',
+            });
+            continue;
+        }
+        mustConsume('END');
     }
-    return tokens;
+    return result;
 }
 /**
- * Escape a regular expression string.
- *
- * @param  {string} str
- * @return {string}
+ * Compile a string to a template function for the path.
  */
-function escapeString(str) {
-    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+function compile(str, options) {
+    return tokensToFunction(parse(str, options), options);
 }
 /**
- * Escape the capturing group by escaping special characters and meaning.
- *
- * @param  {string} group
- * @return {string}
+ * Expose a method for transforming tokens into the path function.
+ */
+function tokensToFunction(tokens, options = {}) {
+    const reFlags = flags(options);
+    const { encode = (x) => x, validate = true } = options;
+    // Compile all the tokens into regexps.
+    const matches = tokens.map(token => {
+        if (typeof token === 'object') {
+            return new RegExp(`^(?:${token.pattern})$`, reFlags);
+        }
+    });
+    return (data) => {
+        let path = '';
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (typeof token === 'string') {
+                path += token;
+                continue;
+            }
+            const value = data ? data[token.name] : undefined;
+            const optional = token.modifier === '?' || token.modifier === '*';
+            const repeat = token.modifier === '*' || token.modifier === '+';
+            if (Array.isArray(value)) {
+                if (!repeat) {
+                    throw new TypeError(`Expected "${token.name}" to not repeat, but got an array`);
+                }
+                if (value.length === 0) {
+                    if (optional)
+                        continue;
+                    throw new TypeError(`Expected "${token.name}" to not be empty`);
+                }
+                for (let j = 0; j < value.length; j++) {
+                    const segment = encode(value[j], token);
+                    if (validate && !matches[i].test(segment)) {
+                        throw new TypeError(`Expected all "${token.name}" to match "${token.pattern}", but got "${segment}"`);
+                    }
+                    path += token.prefix + segment + token.suffix;
+                }
+                continue;
+            }
+            if (typeof value === 'string' || typeof value === 'number') {
+                const segment = encode(String(value), token);
+                if (validate && !matches[i].test(segment)) {
+                    throw new TypeError(`Expected "${token.name}" to match "${token.pattern}", but got "${segment}"`);
+                }
+                path += token.prefix + segment + token.suffix;
+                continue;
+            }
+            if (optional)
+                continue;
+            const typeOfMessage = repeat ? 'an array' : 'a string';
+            throw new TypeError(`Expected "${token.name}" to be ${typeOfMessage}`);
+        }
+        return path;
+    };
+}
+/**
+ * Create path match function from `path-to-regexp` spec.
  */
-function escapeGroup(group) {
-    return group.replace(/([=!:$/()])/g, '\\$1');
+function match(str, options) {
+    const keys = [];
+    const re = toRegexp(str, keys, options);
+    return regexpToFunction(re, keys, options);
 }
 /**
- * Attach the keys as a property of the regexp.
- *
- * @param  {!RegExp} re
- * @param  {Array}   keys
- * @return {!RegExp}
+ * Create a path match function from `path-to-regexp` output.
+ */
+function regexpToFunction(re, keys, options = {}) {
+    const { decode = (x) => x } = options;
+    return function (pathname) {
+        const m = re.exec(pathname);
+        if (!m)
+            return false;
+        const { 0: path, index } = m;
+        const params = Object.create(null);
+        for (let i = 1; i < m.length; i++) {
+            if (m[i] === undefined)
+                continue;
+            const key = keys[i - 1];
+            if (key.modifier === '*' || key.modifier === '+') {
+                params[key.name] = m[i].split(key.prefix + key.suffix).map(value => {
+                    return decode(value, key);
+                });
+            }
+            else {
+                params[key.name] = decode(m[i], key);
+            }
+        }
+        return { path, index, params };
+    };
+}
+/**
+ * Escape a regular expression string.
  */
-function attachKeys(re, keys) {
-    re.keys = keys;
-    return re;
+function escapeString(str) {
+    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
 }
 /**
  * Get the flags for a regexp from the options.
- *
- * @param  {Object} options
- * @return {string}
  */
 function flags(options) {
     return options && options.sensitive ? '' : 'i';
 }
 /**
  * Pull out keys from a regexp.
- *
- * @param  {!RegExp} path
- * @param  {!Array}  keys
- * @return {!RegExp}
  */
 function regexpToRegexp(path, keys) {
-    // Use a negative lookahead to match only capturing groups.
-    const groups = path.source.match(/\((?!\?)/g);
-    if (groups) {
-        for (let i = 0; i < groups.length; i++) {
-            keys.push({
-                name: i,
-                prefix: null,
-                delimiter: null,
-                optional: false,
-                repeat: false,
-                partial: false,
-                asterisk: false,
-                pattern: null,
-            });
-        }
+    if (!keys)
+        return path;
+    const groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+    let index = 0;
+    let execResult = groupsRegex.exec(path.source);
+    while (execResult) {
+        keys.push({
+            // Use parenthesized substring match if available, index otherwise
+            name: execResult[1] || index++,
+            prefix: '',
+            suffix: '',
+            modifier: '',
+            pattern: '',
+        });
+        execResult = groupsRegex.exec(path.source);
     }
-    return attachKeys(path, keys);
+    return path;
 }
 /**
  * Transform an array into a regexp.
- *
- * @param  {!Array}  path
- * @param  {Array}   keys
- * @param  {!Object} options
- * @return {!RegExp}
  */
-function arrayToRegexp(path, keys, options) {
-    const parts = [];
-    for (let i = 0; i < path.length; i++) {
-        parts.push(pathToRegexp(path[i], keys, options).source);
-    }
-    const regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));
-    return attachKeys(regexp, keys);
+function arrayToRegexp(paths, keys, options) {
+    const parts = paths.map(path => toRegexp(path, keys, options).source);
+    return new RegExp(`(?:${parts.join('|')})`, flags(options));
 }
 /**
  * Create a path regexp from string input.
- *
- * @param  {string}  path
- * @param  {!Array}  keys
- * @param  {!Object} options
- * @return {!RegExp}
  */
 function stringToRegexp(path, keys, options) {
-    return tokensToRegExp(parse(path, options), keys, options);
+    return tokensToRegexp(parse(path, options), keys, options);
 }
 /**
  * Expose a function for taking tokens and returning a RegExp.
- *
- * @param  {!Array}          tokens
- * @param  {(Array|Object)=} keys
- * @param  {Object=}         options
- * @return {!RegExp}
  */
-function tokensToRegExp(tokens, keys, options) {
-    if (!Array.isArray(keys)) {
-        options = /** @type {!Object} */ keys || options;
-        keys = [];
-    }
-    options = options || {};
-    const strict = options.strict;
-    const end = options.end !== false;
-    let route = '';
+function tokensToRegexp(tokens, keys, options = {}) {
+    const { strict = false, start = true, end = true, encode = (x) => x, delimiter = '/#?', endsWith = '', } = options;
+    const endsWithRe = `[${escapeString(endsWith)}]|$`;
+    const delimiterRe = `[${escapeString(delimiter)}]`;
+    let route = start ? '^' : '';
     // Iterate over the tokens and create our regexp string.
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
+    for (const token of tokens) {
         if (typeof token === 'string') {
-            route += escapeString(token);
+            route += escapeString(encode(token));
         }
         else {
-            const prefix = escapeString(token.prefix);
-            let capture = '(?:' + token.pattern + ')';
-            keys.push(token);
-            if (token.repeat) {
-                capture += '(?:' + prefix + capture + ')*';
-            }
-            if (token.optional) {
-                if (!token.partial) {
-                    capture = '(?:' + prefix + '(' + capture + '))?';
+            const prefix = escapeString(encode(token.prefix));
+            const suffix = escapeString(encode(token.suffix));
+            if (token.pattern) {
+                if (keys)
+                    keys.push(token);
+                if (prefix || suffix) {
+                    if (token.modifier === '+' || token.modifier === '*') {
+                        const mod = token.modifier === '*' ? '?' : '';
+                        route += `(?:${prefix}((?:${token.pattern})(?:${suffix}${prefix}(?:${token.pattern}))*)${suffix})${mod}`;
+                    }
+                    else {
+                        route += `(?:${prefix}(${token.pattern})${suffix})${token.modifier}`;
+                    }
                 }
                 else {
-                    capture = prefix + '(' + capture + ')?';
+                    if (token.modifier === '+' || token.modifier === '*') {
+                        route += `((?:${token.pattern})${token.modifier})`;
+                    }
+                    else {
+                        route += `(${token.pattern})${token.modifier}`;
+                    }
                 }
             }
             else {
-                capture = prefix + '(' + capture + ')';
+                route += `(?:${prefix}${suffix})${token.modifier}`;
             }
-            route += capture;
         }
     }
-    const delimiter = escapeString(options.delimiter || '/');
-    const endsWithDelimiter = route.slice(-delimiter.length) === delimiter;
-    // In non-strict mode we allow a slash at the end of match. If the path to
-    // match already ends with a slash, we remove it for consistency. The slash
-    // is valid at the end of a path match, not in the middle. This is important
-    // in non-ending mode, where "/test/" shouldn't match "/test//route".
-    if (!strict) {
-        route =
-            (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) +
-                '(?:' +
-                delimiter +
-                '(?=$))?';
-    }
     if (end) {
-        route += '$';
+        if (!strict)
+            route += `${delimiterRe}?`;
+        route += !options.endsWith ? '$' : `(?=${endsWithRe})`;
     }
     else {
-        // In non-ending mode, we need the capturing groups to match as much as
-        // possible by using a positive lookahead to the end or next path segment.
-        route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';
+        const endToken = tokens[tokens.length - 1];
+        const isEndDelimited = typeof endToken === 'string'
+            ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1
+            : endToken === undefined;
+        if (!strict) {
+            route += `(?:${delimiterRe}(?=${endsWithRe}))?`;
+        }
+        if (!isEndDelimited) {
+            route += `(?=${delimiterRe}|${endsWithRe})`;
+        }
     }
-    return attachKeys(new RegExp('^' + route, flags(options)), keys);
+    return new RegExp(route, flags(options));
 }
 /**
  * Normalize the given path string, returning a regular expression.
@@ -252,29 +384,18 @@ function tokensToRegExp(tokens, keys, options) {
  * An empty array can be passed in for the keys, which will hold the
  * placeholder key descriptions. For example, using `/user/:id`, `keys` will
  * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
- *
- * @param  {(string|RegExp|Array)} path
- * @param  {(Array|Object)=}       keys
- * @param  {Object=}               options
- * @return {!RegExp}
  */
-function pathToRegexp(path, keys, options) {
-    if (!Array.isArray(keys)) {
-        options = /** @type {!Object} */ keys || options;
-        keys = [];
-    }
-    options = options || {};
-    if (path instanceof RegExp) {
-        return regexpToRegexp(path, /** @type {!Array} */ keys);
-    }
-    if (Array.isArray(path)) {
-        return arrayToRegexp(
-        /** @type {!Array} */ path, 
-        /** @type {!Array} */ keys, options);
-    }
-    return stringToRegexp(
-    /** @type {string} */ path, 
-    /** @type {!Array} */ keys, options);
+function toRegexp(path, keys, options) {
+    if (path instanceof RegExp)
+        return regexpToRegexp(path, keys);
+    if (Array.isArray(path))
+        return arrayToRegexp(path, keys, options);
+    return stringToRegexp(path, keys, options);
 }
-exports.pathToRegexp = pathToRegexp;
+exports.PathToRegexpUtil = {
+    toRegexp,
+    compile,
+    parse,
+    match,
+};
 //# sourceMappingURL=pathToRegexp.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.3.6",
+  "version": "3.4.0-beta.11",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -21,7 +21,7 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/decorator": "^3.3.4",
+    "@midwayjs/decorator": "^3.4.0-beta.11",
     "koa": "2.13.4",
     "midway-test-component": "*",
     "mm": "3.2.0",
@@ -45,5 +45,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "a603d2348d6141f8f723901498f03a162a037708"
+  "gitHead": "b1c7a439b0df37d3e381cd182ea3b9e74323107b"
 }