hono 2.3.1 → 2.4.0

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

@@ -1,157 +1,155 @@
-import { METHOD_NAME_ALL, METHODS, UnsupportedPathError } from '../../router';
-import { checkOptionalParameter } from '../../utils/url';
-import { PATH_ERROR } from './node';
-import { Trie } from './trie';
-const METHOD_NAMES = [METHOD_NAME_ALL, ...METHODS].map((method) => method.toUpperCase());
-const emptyParam = {};
-const nullMatcher = [/^$/, []];
+// src/router/reg-exp-router/router.ts
+import { METHOD_NAME_ALL, METHODS, UnsupportedPathError } from "../../router.js";
+import { checkOptionalParameter } from "../../utils/url.js";
+import { PATH_ERROR } from "./node.js";
+import { Trie } from "./trie.js";
+var METHOD_NAMES = [METHOD_NAME_ALL, ...METHODS].map((method) => method.toUpperCase());
+var emptyParam = {};
+var nullMatcher = [/^$/, []];
 function buildWildcardRegExp(path) {
-    return new RegExp(path === '*' ? '' : `^${path.replace(/\/\*/, '(?:|/.*)')}$`);
+  return new RegExp(path === "*" ? "" : `^${path.replace(/\/\*/, "(?:|/.*)")}$`);
 }
 function buildMatcherFromPreprocessedRoutes(routes) {
-    const trie = new Trie();
-    const handlers = [];
-    if (routes.length === 0) {
-        return nullMatcher;
+  const trie = new Trie();
+  const handlers = [];
+  if (routes.length === 0) {
+    return nullMatcher;
+  }
+  for (let i = 0, len = routes.length; i < len; i++) {
+    let paramMap;
+    try {
+      paramMap = trie.insert(routes[i][0], i);
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(routes[i][0]) : e;
     }
-    for (let i = 0, len = routes.length; i < len; i++) {
-        let paramMap;
-        try {
-            paramMap = trie.insert(routes[i][0], i);
-        }
-        catch (e) {
-            throw e === PATH_ERROR ? new UnsupportedPathError(routes[i][0]) : e;
-        }
-        handlers[i] = [routes[i][1], 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]];
-            }
-        }
+    handlers[i] = [routes[i][1], 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, len2 = paramMap.length; j < len2; j++) {
+        paramMap[j][1] = paramReplacementMap[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];
+  }
+  const handlerMap = [];
+  for (const i in indexReplacementMap) {
+    handlerMap[i] = handlers[indexReplacementMap[i]];
+  }
+  return [regexp, handlerMap];
 }
 function findMiddleware(middleware, path) {
-    if (!middleware) {
-        return undefined;
-    }
-    for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-        if (buildWildcardRegExp(k).test(path)) {
-            return [...middleware[k]];
-        }
+  if (!middleware) {
+    return void 0;
+  }
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path)) {
+      return [...middleware[k]];
     }
-    return undefined;
+  }
+  return void 0;
 }
-export class RegExpRouter {
-    constructor() {
-        this.middleware = { [METHOD_NAME_ALL]: {} };
-        this.routes = { [METHOD_NAME_ALL]: {} };
+var RegExpRouter = class {
+  constructor() {
+    this.middleware = { [METHOD_NAME_ALL]: {} };
+    this.routes = { [METHOD_NAME_ALL]: {} };
+  }
+  add(method, path, handler) {
+    var _a;
+    const { middleware, routes } = this;
+    if (!middleware || !routes) {
+      throw new Error("Can not add a route since the matcher is already built.");
     }
-    add(method, path, handler) {
-        var _a;
-        const { middleware, routes } = this;
-        if (!middleware || !routes) {
-            throw new Error('Can not add a route since the matcher is already built.');
-        }
-        if (path === '/*') {
-            path = '*';
-        }
-        if (/\*$/.test(path)) {
-            middleware[method] || (middleware[method] = {});
-            const re = buildWildcardRegExp(path);
-            (_a = middleware[method])[path] || (_a[path] = findMiddleware(middleware[METHOD_NAME_ALL], path) || []);
-            Object.keys(middleware).forEach((m) => {
-                if (method === METHOD_NAME_ALL || method === m) {
-                    Object.keys(middleware[m]).forEach((p) => {
-                        ;
-                        (path === '*' || path === p) && middleware[m][p].push(handler);
-                    });
-                }
-            });
-            Object.keys(routes).forEach((m) => {
-                if (method === METHOD_NAME_ALL || method === m) {
-                    Object.keys(routes[m]).forEach((p) => (path === '*' || re.test(p)) && routes[m][p].push(handler));
-                }
-            });
-            return;
+    if (path === "/*") {
+      path = "*";
+    }
+    if (/\*$/.test(path)) {
+      middleware[method] || (middleware[method] = {});
+      const re = buildWildcardRegExp(path);
+      (_a = middleware[method])[path] || (_a[path] = findMiddleware(middleware[METHOD_NAME_ALL], path) || []);
+      Object.keys(middleware).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(middleware[m]).forEach((p) => {
+            ;
+            (path === "*" || path === p) && middleware[m][p].push(handler);
+          });
         }
-        const paths = checkOptionalParameter(path) || [path];
-        for (let i = 0, len = paths.length; i < len; i++) {
-            const path = paths[i];
-            routes[method] || (routes[method] = {});
-            Object.keys(routes).forEach((m) => {
-                var _a;
-                if (method === METHOD_NAME_ALL || method === m) {
-                    (_a = routes[m])[path] || (_a[path] = [
-                        ...(routes[METHOD_NAME_ALL][path] ||
-                            findMiddleware(middleware[method], path) ||
-                            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
-                            []),
-                    ]);
-                    routes[m][path].push(handler);
-                }
-            });
+      });
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(routes[m]).forEach(
+            (p) => (path === "*" || re.test(p)) && routes[m][p].push(handler)
+          );
         }
+      });
+      return;
     }
-    match(method, path) {
-        const matchers = this.buildAllMatchers();
-        this.match = (method, path) => {
-            const matcher = matchers[method];
-            const match = path.match(matcher[0]);
-            if (!match) {
-                return null;
-            }
-            const index = match.indexOf('', 1);
-            const [handlers, paramMap] = matcher[1][index];
-            if (!paramMap) {
-                return { handlers, params: emptyParam };
-            }
-            const params = {};
-            for (let i = 0, len = paramMap.length; i < len; i++) {
-                params[paramMap[i][0]] = match[paramMap[i][1]];
-            }
-            return { handlers, params };
-        };
-        return this.match(method, path);
-    }
-    buildAllMatchers() {
-        const matchers = {};
-        METHOD_NAMES.forEach((method) => {
-            matchers[method] = this.buildMatcher(method) || matchers[METHOD_NAME_ALL];
-        });
-        // Release cache
-        this.middleware = this.routes = undefined;
-        return matchers;
-    }
-    buildMatcher(method) {
-        const routes = [];
-        let hasOwnRoute = method === METHOD_NAME_ALL;
-        [this.middleware, this.routes].forEach((r) => {
-            const ownRoute = r[method]
-                ? Object.keys(r[method]).map((path) => [path, r[method][path]])
-                : [];
-            if (ownRoute.length !== 0) {
-                hasOwnRoute || (hasOwnRoute = true);
-                routes.push(...ownRoute);
-            }
-            else if (method !== METHOD_NAME_ALL) {
-                routes.push(...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]]));
-            }
-        });
-        if (!hasOwnRoute) {
-            return null;
-        }
-        else {
-            return buildMatcherFromPreprocessedRoutes(routes);
+    const paths = checkOptionalParameter(path) || [path];
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const path2 = paths[i];
+      routes[method] || (routes[method] = {});
+      Object.keys(routes).forEach((m) => {
+        var _a2;
+        if (method === METHOD_NAME_ALL || method === m) {
+          (_a2 = routes[m])[path2] || (_a2[path2] = [
+            ...routes[METHOD_NAME_ALL][path2] || findMiddleware(middleware[method], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
+          ]);
+          routes[m][path2].push(handler);
         }
+      });
     }
-}
+  }
+  match(method, path) {
+    const matchers = this.buildAllMatchers();
+    this.match = (method2, path2) => {
+      const matcher = matchers[method2];
+      const match = path2.match(matcher[0]);
+      if (!match) {
+        return null;
+      }
+      const index = match.indexOf("", 1);
+      const [handlers, paramMap] = matcher[1][index];
+      if (!paramMap) {
+        return { handlers, params: emptyParam };
+      }
+      const params = {};
+      for (let i = 0, len = paramMap.length; i < len; i++) {
+        params[paramMap[i][0]] = match[paramMap[i][1]];
+      }
+      return { handlers, params };
+    };
+    return this.match(method, path);
+  }
+  buildAllMatchers() {
+    const matchers = {};
+    METHOD_NAMES.forEach((method) => {
+      matchers[method] = this.buildMatcher(method) || matchers[METHOD_NAME_ALL];
+    });
+    this.middleware = this.routes = void 0;
+    return matchers;
+  }
+  buildMatcher(method) {
+    const routes = [];
+    let hasOwnRoute = method === METHOD_NAME_ALL;
+    [this.middleware, this.routes].forEach((r) => {
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
+      if (ownRoute.length !== 0) {
+        hasOwnRoute || (hasOwnRoute = true);
+        routes.push(...ownRoute);
+      } else if (method !== METHOD_NAME_ALL) {
+        routes.push(
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]])
+        );
+      }
+    });
+    if (!hasOwnRoute) {
+      return null;
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes);
+    }
+  }
+};
+export {
+  RegExpRouter
+};

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

@@ -1,38 +1,35 @@
-import { Node } from './node';
-export class Trie {
-    constructor() {
-        this.context = { varIndex: 0 };
-        this.root = new Node();
-    }
-    insert(path, index) {
-        const paramMap = [];
-        /**
-         *  - pattern (:label, :label{0-9]+}, ...)
-         *  - /* wildcard
-         *  - character
-         */
-        const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g);
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        this.root.insert(tokens, index, paramMap, this.context);
-        return paramMap;
-    }
-    buildRegExp() {
-        let regexp = this.root.buildRegExpStr();
-        let captureIndex = 0;
-        const indexReplacementMap = [];
-        const paramReplacementMap = [];
-        regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-            if (typeof handlerIndex !== 'undefined') {
-                indexReplacementMap[++captureIndex] = Number(handlerIndex);
-                return '$()';
-            }
-            if (typeof paramIndex !== 'undefined') {
-                paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-                return '';
-            }
-            return '';
-        });
-        return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
-    }
-}
+// src/router/reg-exp-router/trie.ts
+import { Node } from "./node.js";
+var Trie = class {
+  constructor() {
+    this.context = { varIndex: 0 };
+    this.root = new Node();
+  }
+  insert(path, index) {
+    const paramMap = [];
+    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g);
+    this.root.insert(tokens, index, paramMap, this.context);
+    return paramMap;
+  }
+  buildRegExp() {
+    let regexp = this.root.buildRegExpStr();
+    let captureIndex = 0;
+    const indexReplacementMap = [];
+    const paramReplacementMap = [];
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (typeof handlerIndex !== "undefined") {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (typeof paramIndex !== "undefined") {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
+};
+export {
+  Trie
+};

package/dist/router/smart-router/index.js

@@ -1 +1,5 @@
-export { SmartRouter } from './router';
+// src/router/smart-router/index.ts
+import { SmartRouter } from "./router.js";
+export {
+  SmartRouter
+};

package/dist/router/smart-router/router.js

@@ -1,53 +1,55 @@
-import { UnsupportedPathError } from '../../router';
-export class SmartRouter {
-    constructor(init) {
-        this.routers = [];
-        this.routes = [];
-        Object.assign(this, init);
+// src/router/smart-router/router.ts
+import { UnsupportedPathError } from "../../router.js";
+var SmartRouter = class {
+  constructor(init) {
+    this.routers = [];
+    this.routes = [];
+    Object.assign(this, init);
+  }
+  add(method, path, handler) {
+    if (!this.routes) {
+      throw new Error("Can not add a route since the matcher is already built.");
     }
-    add(method, path, handler) {
-        if (!this.routes) {
-            throw new Error('Can not add a route since the matcher is already built.');
-        }
-        this.routes.push([method, path, handler]);
+    this.routes.push([method, path, handler]);
+  }
+  match(method, path) {
+    if (!this.routes) {
+      throw new Error("Fatal error");
     }
-    match(method, path) {
-        if (!this.routes) {
-            throw new Error('Fatal error');
-        }
-        const { routers, routes } = this;
-        const len = routers.length;
-        let i = 0;
-        let res;
-        for (; i < len; i++) {
-            const router = routers[i];
-            try {
-                routes.forEach((args) => {
-                    router.add(...args);
-                });
-                res = router.match(method, path);
-            }
-            catch (e) {
-                if (e instanceof UnsupportedPathError) {
-                    continue;
-                }
-                throw e;
-            }
-            this.match = router.match.bind(router);
-            this.routers = [router];
-            this.routes = undefined;
-            break;
-        }
-        if (i === len) {
-            // not found
-            throw new Error('Fatal error');
+    const { routers, routes } = this;
+    const len = routers.length;
+    let i = 0;
+    let res;
+    for (; i < len; i++) {
+      const router = routers[i];
+      try {
+        routes.forEach((args) => {
+          router.add(...args);
+        });
+        res = router.match(method, path);
+      } catch (e) {
+        if (e instanceof UnsupportedPathError) {
+          continue;
         }
-        return res || null;
+        throw e;
+      }
+      this.match = router.match.bind(router);
+      this.routers = [router];
+      this.routes = void 0;
+      break;
     }
-    get activeRouter() {
-        if (this.routes || this.routers.length !== 1) {
-            throw new Error('No active router has been determined yet.');
-        }
-        return this.routers[0];
+    if (i === len) {
+      throw new Error("Fatal error");
+    }
+    return res || null;
+  }
+  get activeRouter() {
+    if (this.routes || this.routers.length !== 1) {
+      throw new Error("No active router has been determined yet.");
     }
-}
+    return this.routers[0];
+  }
+};
+export {
+  SmartRouter
+};

package/dist/router/static-router/index.js

@@ -1 +1,5 @@
-export { StaticRouter } from './router';
+// src/router/static-router/index.ts
+import { StaticRouter } from "./router.js";
+export {
+  StaticRouter
+};

package/dist/router/static-router/router.js

@@ -1,68 +1,63 @@
-import { METHOD_NAME_ALL, METHODS, UnsupportedPathError } from '../../router';
-export class StaticRouter {
-    constructor() {
-        this.middleware = {};
-        this.routes = {};
-        [METHOD_NAME_ALL, ...METHODS].forEach((method) => {
-            this.routes[method.toUpperCase()] = {};
-        });
+// src/router/static-router/router.ts
+import { METHOD_NAME_ALL, METHODS, UnsupportedPathError } from "../../router.js";
+var StaticRouter = class {
+  constructor() {
+    this.middleware = {};
+    this.routes = {};
+    [METHOD_NAME_ALL, ...METHODS].forEach((method) => {
+      this.routes[method.toUpperCase()] = {};
+    });
+  }
+  add(method, path, handler) {
+    var _a, _b;
+    const { middleware, routes } = this;
+    if (path === "/*") {
+      path = "*";
     }
-    add(method, path, handler) {
-        var _a;
-        const { middleware, routes } = this;
-        if (path === '/*') {
-            path = '*';
-        }
-        if (path === '*') {
-            if (method === METHOD_NAME_ALL) {
-                middleware[METHOD_NAME_ALL] || (middleware[METHOD_NAME_ALL] = { handlers: [], params: {} });
-                Object.keys(middleware).forEach((m) => {
-                    middleware[m].handlers.push(handler);
-                });
-                Object.keys(routes).forEach((m) => {
-                    Object.values(routes[m]).forEach((matchRes) => matchRes.handlers.push(handler));
-                });
-            }
-            else {
-                middleware[method] || (middleware[method] = {
-                    handlers: [...(middleware[METHOD_NAME_ALL]?.handlers || [])],
-                    params: {},
-                });
-                middleware[method].handlers.push(handler);
-                if (routes[method]) {
-                    Object.values(routes[method]).forEach((matchRes) => matchRes.handlers.push(handler));
-                }
-            }
-            return;
-        }
-        if (/\*|\/:/.test(path)) {
-            throw new UnsupportedPathError(path);
-        }
-        (_a = routes[method])[path] || (_a[path] = {
-            handlers: [
-                ...(routes[METHOD_NAME_ALL][path]?.handlers ||
-                    middleware[method]?.handlers ||
-                    middleware[METHOD_NAME_ALL]?.handlers ||
-                    []),
-            ],
-            params: {},
+    if (path === "*") {
+      if (method === METHOD_NAME_ALL) {
+        middleware[_a = METHOD_NAME_ALL] || (middleware[_a] = { handlers: [], params: {} });
+        Object.keys(middleware).forEach((m) => {
+          middleware[m].handlers.push(handler);
         });
-        if (method === METHOD_NAME_ALL) {
-            Object.keys(routes).forEach((m) => {
-                routes[m][path]?.handlers?.push(handler);
-            });
-        }
-        else {
-            routes[method][path].handlers.push(handler);
+        Object.keys(routes).forEach((m) => {
+          Object.values(routes[m]).forEach((matchRes) => matchRes.handlers.push(handler));
+        });
+      } else {
+        middleware[method] || (middleware[method] = {
+          handlers: [...middleware[METHOD_NAME_ALL]?.handlers || []],
+          params: {}
+        });
+        middleware[method].handlers.push(handler);
+        if (routes[method]) {
+          Object.values(routes[method]).forEach((matchRes) => matchRes.handlers.push(handler));
         }
+      }
+      return;
+    }
+    if (/\*|\/:/.test(path)) {
+      throw new UnsupportedPathError(path);
     }
-    match(method, path) {
-        const { routes, middleware } = this;
-        this.match = (method, path) => routes[method][path] ||
-            routes[METHOD_NAME_ALL][path] ||
-            middleware[method] ||
-            middleware[METHOD_NAME_ALL] ||
-            null;
-        return this.match(method, path);
+    (_b = routes[method])[path] || (_b[path] = {
+      handlers: [
+        ...routes[METHOD_NAME_ALL][path]?.handlers || middleware[method]?.handlers || middleware[METHOD_NAME_ALL]?.handlers || []
+      ],
+      params: {}
+    });
+    if (method === METHOD_NAME_ALL) {
+      Object.keys(routes).forEach((m) => {
+        routes[m][path]?.handlers?.push(handler);
+      });
+    } else {
+      routes[method][path].handlers.push(handler);
     }
-}
+  }
+  match(method, path) {
+    const { routes, middleware } = this;
+    this.match = (method2, path2) => routes[method2][path2] || routes[METHOD_NAME_ALL][path2] || middleware[method2] || middleware[METHOD_NAME_ALL] || null;
+    return this.match(method, path);
+  }
+};
+export {
+  StaticRouter
+};

package/dist/router/trie-router/index.js

@@ -1 +1,5 @@
-export { TrieRouter } from './router';
+// src/router/trie-router/index.ts
+import { TrieRouter } from "./router.js";
+export {
+  TrieRouter
+};