hono 1.0.0 → 1.2.0

package/dist/router/reg-exp-router/router.d.ts

@@ -1,7 +1,26 @@
 import { Router, Result } from '../../router';
-declare type Route<T> = [string, T];
+interface Hint {
+    components: string[];
+    regExpComponents: Array<true | string>;
+    componentsLength: number;
+    endWithWildcard: boolean;
+    paramIndexList: number[];
+    maybeHandler: boolean;
+    namedParams: [number, string, string][];
+}
+interface Route<T> {
+    method: string;
+    path: string;
+    hint: Hint;
+    handlers: T[];
+    middleware: T[];
+    paramAliasMap: Record<string, string[]>;
+}
 export declare class RegExpRouter<T> extends Router<T> {
-    routes?: Record<string, Route<T>[]>;
+    routeData?: {
+        routes: Route<T>[];
+        methods: Set<string>;
+    };
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T> | null;
     private buildAllMatchers;

package/dist/router/reg-exp-router/router.js

@@ -3,112 +3,332 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegExpRouter = void 0;
 const router_1 = require("../../router");
 const trie_1 = require("../../router/reg-exp-router/trie");
-const regExpMatchAll = new RegExp('');
 const emptyParam = {};
+const nullMatcher = [/^$/, []];
+function initHint(path) {
+    const components = path.match(/\/(?::\w+{[^}]+}|[^\/]*)/g) || [];
+    let componentsLength = components.length;
+    const paramIndexList = [];
+    const regExpComponents = [];
+    const namedParams = [];
+    for (let i = 0, len = components.length; i < len; i++) {
+        if (i === len - 1 && components[i] === '/*') {
+            componentsLength--;
+            break;
+        }
+        const m = components[i].match(/^\/:(\w+)({[^}]+})?/);
+        if (m) {
+            namedParams.push([i, m[1], m[2] || '[^/]+']);
+            regExpComponents[i] = m[2] || true;
+        }
+        else if (components[i] === '/*') {
+            regExpComponents[i] = true;
+        }
+        else {
+            regExpComponents[i] = components[i];
+        }
+        if (/\/(?::|\*)/.test(components[i])) {
+            paramIndexList.push(i);
+        }
+    }
+    return {
+        components,
+        regExpComponents,
+        componentsLength,
+        endWithWildcard: path.endsWith('*'),
+        paramIndexList,
+        namedParams,
+        maybeHandler: true,
+    };
+}
+function compareRoute(a, b) {
+    if (a.path === '*') {
+        return 1;
+    }
+    let i = 0;
+    const len = a.hint.regExpComponents.length;
+    for (; i < len; i++) {
+        if (a.hint.regExpComponents[i] !== b.hint.regExpComponents[i]) {
+            if (a.hint.regExpComponents[i] === true) {
+                break;
+            }
+            return 0;
+        }
+    }
+    // may be ambiguous
+    for (; i < len; i++) {
+        if (a.hint.regExpComponents[i] !== true &&
+            a.hint.regExpComponents[i] !== b.hint.regExpComponents[i]) {
+            return 2;
+        }
+    }
+    return i === b.hint.regExpComponents.length || a.hint.endWithWildcard ? 1 : 0;
+}
+function buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous = false) {
+    const trie = new trie_1.Trie({ reverse: hasAmbiguous });
+    const handlers = [];
+    if (routes.length === 0) {
+        return nullMatcher;
+    }
+    for (let i = 0, len = routes.length; i < len; i++) {
+        const paramMap = trie.insert(routes[i].path, i);
+        handlers[i] = [
+            [...routes[i].middleware, ...routes[i].handlers],
+            Object.keys(paramMap).length !== 0 ? paramMap : null,
+        ];
+    }
+    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+    for (let i = 0, len = handlers.length; i < len; i++) {
+        const paramMap = handlers[i][1];
+        if (paramMap) {
+            for (let j = 0, len = paramMap.length; j < len; j++) {
+                paramMap[j][1] = paramReplacementMap[paramMap[j][1]];
+                const aliasTo = routes[i].paramAliasMap[paramMap[j][0]];
+                if (aliasTo) {
+                    for (let k = 0, len = aliasTo.length; k < len; k++) {
+                        paramMap.push([aliasTo[k], paramMap[j][1]]);
+                    }
+                }
+            }
+        }
+    }
+    const handlerMap = [];
+    // using `in` because indexReplacementMap is a sparse array
+    for (const i in indexReplacementMap) {
+        handlerMap[i] = handlers[indexReplacementMap[i]];
+    }
+    return [regexp, handlerMap];
+}
+function verifyDuplicateParam(routes) {
+    const nameMap = {};
+    for (let i = 0, len = routes.length; i < len; i++) {
+        const route = routes[i];
+        for (let k = 0, len = route.hint.namedParams.length; k < len; k++) {
+            const [index, name] = route.hint.namedParams[k];
+            if (name in nameMap && index !== nameMap[name]) {
+                return false;
+            }
+            else {
+                nameMap[name] = index;
+            }
+        }
+        const paramAliasMap = route.paramAliasMap;
+        const paramAliasMapKeys = Object.keys(paramAliasMap);
+        for (let k = 0, len = paramAliasMapKeys.length; k < len; k++) {
+            const aliasFrom = paramAliasMapKeys[k];
+            for (let l = 0, len = paramAliasMap[aliasFrom].length; l < len; l++) {
+                const aliasTo = paramAliasMap[aliasFrom][l];
+                const index = nameMap[aliasFrom];
+                if (aliasTo in nameMap && index !== nameMap[aliasTo]) {
+                    return false;
+                }
+                else {
+                    nameMap[aliasTo] = index;
+                }
+            }
+        }
+    }
+    return true;
+}
 class RegExpRouter extends router_1.Router {
     constructor() {
         super(...arguments);
-        this.routes = {};
+        this.routeData = { routes: [], methods: new Set() };
     }
     add(method, path, handler) {
-        var _a;
-        if (!this.routes) {
+        if (!this.routeData) {
             throw new Error('Can not add a route since the matcher is already built.');
         }
-        (_a = this.routes)[method] || (_a[method] = []);
-        this.routes[method].push([path, handler]);
+        const { routes, methods } = this.routeData;
+        if (path === '/*') {
+            path = '*';
+        }
+        for (let i = 0, len = routes.length; i < len; i++) {
+            if (routes[i].method === method && routes[i].path === path) {
+                routes[i].handlers.push(handler);
+                return;
+            }
+        }
+        methods.add(method);
+        routes.push({
+            method,
+            path,
+            handlers: [handler],
+            hint: initHint(path),
+            middleware: [],
+            paramAliasMap: {},
+        });
     }
     match(method, path) {
-        const matchers = this.buildAllMatchers();
-        let match;
-        // Optimization for middleware
-        const methods = Object.keys(matchers);
-        if (methods.length === 1 && methods[0] === router_1.METHOD_NAME_OF_ALL) {
-            const [regexp, handlers] = matchers[router_1.METHOD_NAME_OF_ALL];
-            if (handlers.length === 1) {
-                const result = new router_1.Result(handlers[0][0], emptyParam);
-                if (regexp === regExpMatchAll) {
-                    match = () => result;
+        const [primaryMatchers, secondaryMatchers, hasAmbiguous] = this.buildAllMatchers();
+        this.match = hasAmbiguous
+            ? (method, path) => {
+                const matcher = primaryMatchers[method] || primaryMatchers[router_1.METHOD_NAME_ALL];
+                let match = path.match(matcher[0]);
+                if (!match) {
+                    // do not support secondary matchers here.
+                    return null;
                 }
-                else if (handlers.length === 1 && !handlers[0][1]) {
-                    match = (_, path) => (regexp.test(path) ? result : null);
+                const params = {};
+                const handlers = new Set();
+                let regExpSrc = matcher[0].source;
+                while (match) {
+                    let index = match.indexOf('', 1);
+                    for (;;) {
+                        const [handler, paramMap] = matcher[1][index];
+                        if (paramMap) {
+                            for (let i = 0, len = paramMap.length; i < len; i++) {
+                                params[paramMap[i][0]] = match[paramMap[i][1]];
+                            }
+                        }
+                        for (let i = 0, len = handler.length; i < len; i++) {
+                            handlers.add(handler[i]);
+                        }
+                        const newIndex = match.indexOf('', index + 1);
+                        if (newIndex === -1) {
+                            break;
+                        }
+                        index = newIndex;
+                    }
+                    regExpSrc = regExpSrc.replace(new RegExp(`((?:(?:\\(\\?:|.)*?\\([^)]*\\)){${index - 1}}.*?)\\(\\)`), '$1(^)');
+                    match = path.match(new RegExp(regExpSrc));
                 }
+                return new router_1.Result([...handlers.values()], params);
             }
-        }
-        match || (match = (method, path) => {
-            const matcher = matchers[method] || matchers[router_1.METHOD_NAME_OF_ALL];
-            if (!matcher) {
-                return null;
-            }
-            const match = path.match(matcher[0]);
-            if (!match) {
-                return null;
+            : (method, path) => {
+                let matcher = primaryMatchers[method] || primaryMatchers[router_1.METHOD_NAME_ALL];
+                let match = path.match(matcher[0]);
+                if (!match) {
+                    const matchers = secondaryMatchers[method] || secondaryMatchers[router_1.METHOD_NAME_ALL];
+                    for (let i = 0, len = matchers.length; i < len && !match; i++) {
+                        matcher = matchers[i];
+                        match = path.match(matcher[0]);
+                    }
+                    if (!match) {
+                        return null;
+                    }
+                }
+                const index = match.indexOf('', 1);
+                const [handler, paramMap] = matcher[1][index];
+                if (!paramMap) {
+                    return new router_1.Result(handler, emptyParam);
+                }
+                const params = {};
+                for (let i = 0, len = paramMap.length; i < len; i++) {
+                    params[paramMap[i][0]] = match[paramMap[i][1]];
+                }
+                return new router_1.Result(handler, params);
+            };
+        return this.match(method, path);
+    }
+    buildAllMatchers() {
+        this.routeData.routes.sort(({ hint: a }, { hint: b }) => {
+            if (a.componentsLength !== b.componentsLength) {
+                return a.componentsLength - b.componentsLength;
             }
-            const index = match.indexOf('', 1);
-            const [handler, paramMap] = matcher[1][index];
-            if (!paramMap) {
-                return new router_1.Result(handler, emptyParam);
+            for (let i = 0, len = Math.min(a.paramIndexList.length, b.paramIndexList.length) + 1; i < len; i++) {
+                if (a.paramIndexList[i] !== b.paramIndexList[i]) {
+                    if (a.paramIndexList[i] === undefined) {
+                        return -1;
+                    }
+                    else if (b.paramIndexList[i] === undefined) {
+                        return 1;
+                    }
+                    else {
+                        return a.paramIndexList[i] - b.paramIndexList[i];
+                    }
+                }
             }
-            const params = {};
-            for (let i = 0; i < paramMap.length; i++) {
-                params[paramMap[i][0]] = match[paramMap[i][1]];
+            if (a.endWithWildcard !== b.endWithWildcard) {
+                return a.endWithWildcard ? -1 : 1;
             }
-            return new router_1.Result(handler, params);
+            return 0;
         });
-        this.match = match;
-        return this.match(method, path);
-    }
-    buildAllMatchers() {
-        const matchers = {};
-        Object.keys(this.routes).forEach((method) => {
-            matchers[method] = this.buildMatcher(method);
+        const primaryMatchers = {};
+        const secondaryMatchers = {};
+        let hasAmbiguous = false;
+        this.routeData.methods.forEach((method) => {
+            let _hasAmbiguous;
+            [primaryMatchers[method], secondaryMatchers[method], _hasAmbiguous] =
+                this.buildMatcher(method);
+            hasAmbiguous = hasAmbiguous || _hasAmbiguous;
         });
-        delete this.routes; // to reduce memory usage
-        return matchers;
+        primaryMatchers[router_1.METHOD_NAME_ALL] || (primaryMatchers[router_1.METHOD_NAME_ALL] = nullMatcher);
+        secondaryMatchers[router_1.METHOD_NAME_ALL] || (secondaryMatchers[router_1.METHOD_NAME_ALL] = []);
+        delete this.routeData; // to reduce memory usage
+        return [primaryMatchers, secondaryMatchers, hasAmbiguous];
     }
     buildMatcher(method) {
-        const trie = new trie_1.Trie();
-        const handlers = [];
-        const targetMethods = [method];
-        if (method !== router_1.METHOD_NAME_OF_ALL) {
-            targetMethods.unshift(router_1.METHOD_NAME_OF_ALL);
-        }
-        const routes = targetMethods.flatMap((method) => this.routes[method] || []);
-        if (routes.length === 0) {
-            return null;
-        }
-        if (method === router_1.METHOD_NAME_OF_ALL) {
-            if (routes.length === 1 && routes[0][0] === '*') {
-                return [regExpMatchAll, [[routes[0][1], null]]];
+        var _a, _b;
+        let hasAmbiguous = false;
+        const targetMethods = new Set([method, router_1.METHOD_NAME_ALL]);
+        const routes = this.routeData.routes.filter(({ method }) => targetMethods.has(method));
+        // Reset temporary data per method
+        for (let i = 0, len = routes.length; i < len; i++) {
+            routes[i].middleware = [];
+            routes[i].paramAliasMap = {};
+        }
+        // preprocess routes
+        for (let i = 0, len = routes.length; i < len; i++) {
+            for (let j = i + 1; j < len; j++) {
+                const compareResult = compareRoute(routes[i], routes[j]);
+                // i includes j
+                if (compareResult === 1) {
+                    const components = routes[j].hint.components;
+                    const namedParams = routes[i].hint.namedParams;
+                    for (let k = 0, len = namedParams.length; k < len; k++) {
+                        const c = components[namedParams[k][0]];
+                        const m = c.match(/^\/:(\w+)({[^}]+})?/);
+                        if (m && namedParams[k][1] === m[1]) {
+                            continue;
+                        }
+                        if (m) {
+                            (_a = routes[j].paramAliasMap)[_b = m[1]] || (_a[_b] = []);
+                            routes[j].paramAliasMap[m[1]].push(namedParams[k][1]);
+                        }
+                        else {
+                            components[namedParams[k][0]] = `/:${namedParams[k][1]}{${c.substring(1)}}`;
+                            routes[j].hint.namedParams.push([
+                                namedParams[k][0],
+                                namedParams[k][1],
+                                c.substring(1),
+                            ]);
+                            routes[j].path = components.join('');
+                        }
+                    }
+                    routes[j].middleware.push(...routes[i].handlers);
+                    routes[i].hint.maybeHandler = false;
+                }
+                else if (compareResult === 2) {
+                    // ambiguous
+                    hasAmbiguous = true;
+                    if (!verifyDuplicateParam([routes[i], routes[j]])) {
+                        throw new Error('Duplicate param name');
+                    }
+                }
             }
-            if (routes.length === 1 && !routes[0][0].match(/:/)) {
-                // there is only one route and no capture
-                const tmp = routes[0][0].endsWith('*')
-                    ? routes[0][0].replace(/\/\*$/, '(?:$|/)') // /path/to/* => /path/to(?:$|/)
-                    : `${routes[0][0]}$`; // /path/to/action => /path/to/action$
-                const regExpStr = `^${tmp.replace(/\*/g, '[^/]+')}`; // /prefix/*/path/to => /prefix/[^/]+/path/to
-                return [new RegExp(regExpStr), [[routes[0][1], null]]];
+            if (!verifyDuplicateParam([routes[i]])) {
+                throw new Error('Duplicate param name');
             }
         }
-        for (let i = 0; i < routes.length; i++) {
-            const paramMap = trie.insert(routes[i][0], i);
-            handlers[i] = [routes[i][1], Object.keys(paramMap).length !== 0 ? paramMap : null];
+        if (hasAmbiguous) {
+            return [buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous), [], hasAmbiguous];
         }
-        const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-        for (let i = 0; i < handlers.length; i++) {
-            const paramMap = handlers[i][1];
-            if (paramMap) {
-                for (let i = 0; i < paramMap.length; i++) {
-                    paramMap[i][1] = paramReplacementMap[paramMap[i][1]];
-                }
+        const primaryRoutes = [];
+        const secondaryRoutes = [];
+        for (let i = 0, len = routes.length; i < len; i++) {
+            if (routes[i].hint.maybeHandler || !routes[i].hint.endWithWildcard) {
+                primaryRoutes.push(routes[i]);
+            }
+            else {
+                secondaryRoutes.push(routes[i]);
             }
         }
-        const handlerMap = [];
-        // using `in` because indexReplacementMap is a sparse array
-        for (const i in indexReplacementMap) {
-            handlerMap[i] = handlers[indexReplacementMap[i]];
-        }
-        return [regexp, handlerMap];
+        return [
+            buildMatcherFromPreprocessedRoutes(primaryRoutes, hasAmbiguous),
+            [buildMatcherFromPreprocessedRoutes(secondaryRoutes, hasAmbiguous)],
+            hasAmbiguous,
+        ];
     }
 }
 exports.RegExpRouter = RegExpRouter;

package/dist/router/reg-exp-router/trie.d.ts

@@ -2,9 +2,13 @@ import type { ParamMap, Context } from '../../router/reg-exp-router/node';
 import { Node } from '../../router/reg-exp-router/node';
 export type { ParamMap } from '../../router/reg-exp-router/node';
 export declare type ReplacementMap = number[];
+interface InitOptions {
+    reverse: boolean;
+}
 export declare class Trie {
     context: Context;
     root: Node;
+    constructor({ reverse }?: InitOptions);
     insert(path: string, index: number): ParamMap;
     buildRegExp(): [RegExp, ReplacementMap, ReplacementMap];
 }

package/dist/router/reg-exp-router/trie.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trie = void 0;
 const node_1 = require("../../router/reg-exp-router/node");
 class Trie {
-    constructor() {
+    constructor({ reverse } = { reverse: false }) {
         this.context = { varIndex: 0 };
-        this.root = new node_1.Node();
+        this.root = new node_1.Node({ reverse });
     }
     insert(path, index) {
         const paramMap = [];

package/dist/router/trie-router/node.d.ts

@@ -1,12 +1,13 @@
 import { Result } from '../../router';
 import type { Pattern } from '../../utils/url';
 export declare class Node<T> {
-    method: Record<string, T>;
-    handler: T;
+    methods: Record<string, T>[];
+    handlers: T[];
     children: Record<string, Node<T>>;
-    middlewares: [];
     patterns: Pattern[];
     constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;
+    private getHandlers;
+    private next;
     search(method: string, path: string): Result<T>;
 }