hono 0.3.8 → 0.4.2

package/dist/{node.js → router/trie-router/node.js}

@@ -1,15 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Node = exports.Result = void 0;
-const url_1 = require("./utils/url");
-const METHOD_NAME_OF_ALL = 'ALL';
-class Result {
-    constructor(handler, params) {
-        this.handler = handler;
-        this.params = params;
-    }
-}
-exports.Result = Result;
+exports.Node = void 0;
+const url_1 = require("../../utils/url");
+const router_1 = require("../../router");
 const noRoute = () => {
     return null;
 };
@@ -21,6 +14,7 @@ class Node {
             this.method[method] = handler;
         }
         this.middlewares = [];
+        this.patterns = [];
     }
     insert(method, path, handler) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -33,6 +27,10 @@ class Node {
                 continue;
             }
             curNode.children[p] = new Node();
+            const pattern = (0, url_1.getPattern)(p);
+            if (pattern) {
+                curNode.patterns.push(pattern);
+            }
             curNode = curNode.children[p];
         }
         curNode.method[method] = handler;
@@ -64,29 +62,24 @@ class Node {
             }
             let isWildcard = false;
             let isParamMatch = false;
-            const keys = Object.keys(curNode.children);
-            for (let j = 0, len = keys.length; j < len; j++) {
-                const key = keys[j];
+            for (let j = 0, len = curNode.patterns.length; j < len; j++) {
+                const pattern = curNode.patterns[j];
                 // Wildcard
                 // '/hello/*/foo' => match /hello/bar/foo
-                if (key === '*') {
+                if (pattern === '*') {
                     curNode = curNode.children['*'];
                     isWildcard = true;
                     break;
                 }
-                const pattern = (0, url_1.getPattern)(key);
                 // Named match
-                if (pattern) {
-                    const match = p.match(new RegExp(pattern[1]));
-                    if (match) {
-                        const k = pattern[0];
-                        params[k] = match[1];
-                        curNode = curNode.children[key];
-                        isParamMatch = true;
-                        break;
-                    }
-                    return noRoute();
+                const [key, name, matcher] = pattern;
+                if (p !== '' && (matcher === true || matcher.test(p))) {
+                    params[name] = p;
+                    curNode = curNode.children[key];
+                    isParamMatch = true;
+                    break;
                 }
+                return noRoute();
             }
             if (isWildcard && i === len - 1) {
                 break;
@@ -95,11 +88,11 @@ class Node {
                 return noRoute();
             }
         }
-        const handler = curNode.method[METHOD_NAME_OF_ALL] || curNode.method[method];
+        const handler = curNode.method[router_1.METHOD_NAME_OF_ALL] || curNode.method[method];
         if (!handler) {
             return noRoute();
         }
-        return new Result(handler, params);
+        return new router_1.Result(handler, params);
     }
 }
 exports.Node = Node;

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

@@ -0,0 +1,9 @@
+import { Router } from '../../router';
+import type { Result } from '../../router';
+import { Node } from './node';
+export declare class TrieRouter<T> extends Router<T> {
+    node: Node<T>;
+    constructor();
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T> | null;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrieRouter = void 0;
+const router_1 = require("../../router");
+const node_1 = require("./node");
+class TrieRouter extends router_1.Router {
+    constructor() {
+        super();
+        this.node = new node_1.Node();
+    }
+    add(method, path, handler) {
+        this.node.insert(method, path, handler);
+    }
+    match(method, path) {
+        return this.node.search(method, path);
+    }
+}
+exports.TrieRouter = TrieRouter;

package/dist/router.d.ts

@@ -0,0 +1,10 @@
+export declare const METHOD_NAME_OF_ALL = "ALL";
+export declare abstract class Router<T> {
+    abstract add(method: string, path: string, handler: T): void;
+    abstract match(method: string, path: string): Result<T> | null;
+}
+export declare class Result<T> {
+    handler: T;
+    params: Record<string, string>;
+    constructor(handler: T, params: Record<string, string>);
+}

package/dist/router.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Result = exports.Router = exports.METHOD_NAME_OF_ALL = void 0;
+exports.METHOD_NAME_OF_ALL = 'ALL';
+class Router {
+}
+exports.Router = Router;
+class Result {
+    constructor(handler, params) {
+        this.handler = handler;
+        this.params = params;
+    }
+}
+exports.Result = Result;

package/dist/utils/buffer.js

@@ -46,7 +46,9 @@ const sha256 = async (a) => {
         const buffer = await crypto.subtle.digest({
             name: 'SHA-256',
         }, new TextEncoder().encode(String(a)));
-        const hash = Array.prototype.map.call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2)).join('');
+        const hash = Array.prototype.map
+            .call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2))
+            .join('');
         return hash;
     }
     try {

package/dist/utils/url.d.ts

@@ -1,4 +1,10 @@
+export declare type Pattern = readonly [string, string, RegExp | true] | '*';
 export declare const splitPath: (path: string) => string[];
-export declare const getPattern: (label: string) => string[] | null;
-export declare const getPathFromURL: (url: string) => string;
+export declare const getPattern: (label: string) => Pattern | null;
+declare type Params = {
+    strict: boolean;
+};
+export declare const getPathFromURL: (url: string, params?: Params) => string;
 export declare const isAbsoluteURL: (url: string) => boolean;
+export declare const mergePath: (...paths: string[]) => string;
+export {};

package/dist/utils/url.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
+exports.mergePath = exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
 const URL_REGEXP = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
 const splitPath = (path) => {
     const paths = path.split(/\//); // faster than path.split('/')
@@ -10,23 +10,36 @@ const splitPath = (path) => {
     return paths;
 };
 exports.splitPath = splitPath;
+const patternCache = {};
 const getPattern = (label) => {
+    // *            => wildcard
     // :id{[0-9]+}  => ([0-9]+)
     // :id          => (.+)
     //const name = ''
+    if (label === '*') {
+        return '*';
+    }
     const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
     if (match) {
-        if (match[2]) {
-            return [match[1], '(' + match[2] + ')'];
-        }
-        else {
-            return [match[1], '(.+)'];
+        if (!patternCache[label]) {
+            if (match[2]) {
+                patternCache[label] = [label, match[1], new RegExp('^' + match[2] + '$')];
+            }
+            else {
+                patternCache[label] = [label, match[1], true];
+            }
         }
+        return patternCache[label];
     }
     return null;
 };
 exports.getPattern = getPattern;
-const getPathFromURL = (url) => {
+const getPathFromURL = (url, params = { strict: true }) => {
+    // if strict routing is false => `/hello/hey/` and `/hello/hey` are treated the same
+    // default is true
+    if (!params.strict && url.endsWith('/')) {
+        url = url.slice(0, -1);
+    }
     const match = url.match(URL_REGEXP);
     if (match) {
         return match[5];
@@ -42,3 +55,27 @@ const isAbsoluteURL = (url) => {
     return false;
 };
 exports.isAbsoluteURL = isAbsoluteURL;
+const mergePath = (...paths) => {
+    let p = '';
+    let endsWithSlash = false;
+    for (let path of paths) {
+        /* ['/hey/','/say'] => ['/hey', '/say'] */
+        if (p.endsWith('/')) {
+            p = p.slice(0, -1);
+            endsWithSlash = true;
+        }
+        /* ['/hey','say'] => ['/hey', '/say'] */
+        if (!path.startsWith('/')) {
+            path = `/${path}`;
+        }
+        /* ['/hey/', '/'] => `/hey/` */
+        if (path === '/' && endsWithSlash) {
+            p = `${p}/`;
+        }
+        else if (path !== '/') {
+            p = `${p}${path}`;
+        }
+    }
+    return p;
+};
+exports.mergePath = mergePath;

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "hono",
-  "version": "0.3.8",
+  "version": "0.4.2",
   "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint --ext js,ts src .eslintrc.js && prettier --check src",
+    "build": "rimraf dist && tsc",
+    "watch": "tsc -w",
+    "prepublishOnly": "yarn build"
+  },
   "exports": {
     ".": "./dist/index.js",
     "./basic-auth": "./dist/middleware/basic-auth/basic-auth.js",
@@ -17,8 +24,7 @@
     "./mustache": "./dist/middleware/mustache/mustache.js",
     "./powered-by": "./dist/middleware/powered-by/powered-by.js",
     "./serve-static": "./dist/middleware/serve-static/serve-static.js",
-    "./utils/buffer": "./dist/utils/buffer.js",
-    "./package.json": "./package.json"
+    "./router/reg-exp-router": "./dist/router/reg-exp-router/index.js"
   },
   "typesVersions": {
     "*": {
@@ -45,16 +51,12 @@
       ],
       "serve-static": [
         "./dist/middleware/serve-static/serve-static.d.ts"
+      ],
+      "router/reg-exp-router": [
+        "./dist/router/reg-exp-router/router.d.ts"
       ]
     }
   },
-  "scripts": {
-    "test": "jest",
-    "lint": "eslint --ext js,ts src .eslintrc.js test",
-    "build": "rimraf dist && tsc",
-    "watch": "tsc -w",
-    "prepublishOnly": "yarn build"
-  },
   "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
   "license": "MIT",
   "repository": {
@@ -82,18 +84,18 @@
     "@typescript-eslint/eslint-plugin": "^5.9.0",
     "@typescript-eslint/parser": "^5.9.0",
     "eslint": "^7.26.0",
-    "eslint-config-prettier": "^8.1.0",
+    "eslint-config-prettier": "^8.3.0",
     "eslint-define-config": "^1.2.1",
     "eslint-import-resolver-typescript": "^2.0.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-flowtype": "^5.7.2",
     "eslint-plugin-import": "^2.20.2",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^4.0.0",
     "form-data": "^4.0.0",
     "jest": "^27.4.5",
     "jest-environment-miniflare": "^2.0.0",
     "mustache": "^4.2.0",
+    "prettier": "^2.5.1",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.1.2",
     "typescript": "^4.5.5"

package/dist/node.d.ts

@@ -1,24 +0,0 @@
-export declare class Result<T> {
-    handler: T;
-    params: {
-        [key: string]: string;
-    };
-    constructor(handler: T, params: {
-        [key: string]: string;
-    });
-}
-export declare class Node<T> {
-    method: {
-        [key: string]: T;
-    };
-    handler: T;
-    children: {
-        [key: string]: Node<T>;
-    };
-    middlewares: [];
-    constructor(method?: string, handler?: T, children?: {
-        [key: string]: Node<T>;
-    });
-    insert(method: string, path: string, handler: T): Node<T>;
-    search(method: string, path: string): Result<T>;
-}