hono 2.1.3 → 2.2.0

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRouter = void 0;
+var router_1 = require("./router");
+Object.defineProperty(exports, "StaticRouter", { enumerable: true, get: function () { return router_1.StaticRouter; } });

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRouter = void 0;
+const router_1 = require("../../router");
+class StaticRouter {
+    constructor() {
+        this.middleware = {};
+        this.routes = {};
+        [router_1.METHOD_NAME_ALL, ...router_1.METHODS].forEach((method) => {
+            this.routes[method.toUpperCase()] = {};
+        });
+    }
+    add(method, path, handler) {
+        var _a;
+        const { middleware, routes } = this;
+        if (path === '/*') {
+            path = '*';
+        }
+        if (path === '*') {
+            if (method === router_1.METHOD_NAME_ALL) {
+                middleware[router_1.METHOD_NAME_ALL] || (middleware[router_1.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[router_1.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 router_1.UnsupportedPathError(path);
+        }
+        (_a = routes[method])[path] || (_a[path] = {
+            handlers: [
+                ...(routes[router_1.METHOD_NAME_ALL][path]?.handlers ||
+                    middleware[method]?.handlers ||
+                    middleware[router_1.METHOD_NAME_ALL]?.handlers ||
+                    []),
+            ],
+            params: {},
+        });
+        if (method === router_1.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 = (method, path) => routes[method][path] ||
+            routes[router_1.METHOD_NAME_ALL][path] ||
+            middleware[method] ||
+            middleware[router_1.METHOD_NAME_ALL] ||
+            null;
+        return this.match(method, path);
+    }
+}
+exports.StaticRouter = StaticRouter;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrieRouter = void 0;
+var router_1 = require("./router");
+Object.defineProperty(exports, "TrieRouter", { enumerable: true, get: function () { return router_1.TrieRouter; } });

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

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = void 0;
+const router_1 = require("../../router");
+const url_1 = require("../../utils/url");
+function findParam(node, name) {
+    for (let i = 0, len = node.patterns.length; i < len; i++) {
+        if (typeof node.patterns[i] === 'object' && node.patterns[i][1] === name) {
+            return true;
+        }
+    }
+    const nodes = Object.values(node.children);
+    for (let i = 0, len = nodes.length; i < len; i++) {
+        if (findParam(nodes[i], name)) {
+            return true;
+        }
+    }
+    return false;
+}
+class Node {
+    constructor(method, handler, children) {
+        this.order = 0;
+        this.children = children || {};
+        this.methods = [];
+        this.name = '';
+        if (method && handler) {
+            const m = {};
+            m[method] = { handler: handler, score: 0, name: this.name };
+            this.methods = [m];
+        }
+        this.patterns = [];
+        this.handlerSetCache = {};
+    }
+    insert(method, path, handler) {
+        this.name = `${method} ${path}`;
+        this.order = ++this.order;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let curNode = this;
+        const parts = (0, url_1.splitPath)(path);
+        const parentPatterns = [];
+        const errorMessage = (name) => {
+            return `Duplicate param name, use another name instead of '${name}' - ${method} ${path} <--- '${name}'`;
+        };
+        for (let i = 0, len = parts.length; i < len; i++) {
+            const p = parts[i];
+            if (Object.keys(curNode.children).includes(p)) {
+                parentPatterns.push(...curNode.patterns);
+                curNode = curNode.children[p];
+                continue;
+            }
+            curNode.children[p] = new Node();
+            const pattern = (0, url_1.getPattern)(p);
+            if (pattern) {
+                if (typeof pattern === 'object') {
+                    for (let j = 0, len = parentPatterns.length; j < len; j++) {
+                        if (typeof parentPatterns[j] === 'object' && parentPatterns[j][1] === pattern[1]) {
+                            throw new Error(errorMessage(pattern[1]));
+                        }
+                    }
+                    if (Object.values(curNode.children).some((n) => findParam(n, pattern[1]))) {
+                        throw new Error(errorMessage(pattern[1]));
+                    }
+                }
+                curNode.patterns.push(pattern);
+                parentPatterns.push(...curNode.patterns);
+            }
+            parentPatterns.push(...curNode.patterns);
+            curNode = curNode.children[p];
+        }
+        if (!curNode.methods.length) {
+            curNode.methods = [];
+        }
+        const m = {};
+        const handlerSet = { handler: handler, name: this.name, score: this.order };
+        m[method] = handlerSet;
+        curNode.methods.push(m);
+        return curNode;
+    }
+    getHandlerSets(node, method, wildcard) {
+        var _a, _b;
+        return ((_a = node.handlerSetCache)[_b = `${method}:${wildcard ? '1' : '0'}`] || (_a[_b] = (() => {
+            const handlerSets = [];
+            for (let i = 0, len = node.methods.length; i < len; i++) {
+                const m = node.methods[i];
+                const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
+                if (handlerSet !== undefined) {
+                    handlerSets.push(handlerSet);
+                }
+            }
+            return handlerSets;
+        })()));
+    }
+    search(method, path) {
+        const handlerSets = [];
+        const params = {};
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const curNode = this;
+        let curNodes = [curNode];
+        const parts = (0, url_1.splitPath)(path);
+        for (let i = 0, len = parts.length; i < len; i++) {
+            const part = parts[i];
+            const isLast = i === len - 1;
+            const tempNodes = [];
+            let matched = false;
+            for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+                const node = curNodes[j];
+                const nextNode = node.children[part];
+                if (nextNode) {
+                    if (isLast === true) {
+                        // '/hello/*' => match '/hello'
+                        if (nextNode.children['*']) {
+                            handlerSets.push(...this.getHandlerSets(nextNode.children['*'], method, true));
+                        }
+                        handlerSets.push(...this.getHandlerSets(nextNode, method));
+                        matched = true;
+                    }
+                    else {
+                        tempNodes.push(nextNode);
+                    }
+                }
+                for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
+                    const pattern = node.patterns[k];
+                    // Wildcard
+                    // '/hello/*/foo' => match /hello/bar/foo
+                    if (pattern === '*') {
+                        const astNode = node.children['*'];
+                        if (astNode) {
+                            handlerSets.push(...this.getHandlerSets(astNode, method));
+                            tempNodes.push(astNode);
+                        }
+                        continue;
+                    }
+                    if (part === '')
+                        continue;
+                    // Named match
+                    // `/posts/:id` => match /posts/123
+                    const [key, name, matcher] = pattern;
+                    if (matcher === true || (matcher instanceof RegExp && matcher.test(part))) {
+                        if (typeof key === 'string') {
+                            if (isLast === true) {
+                                handlerSets.push(...this.getHandlerSets(node.children[key], method));
+                            }
+                            else {
+                                tempNodes.push(node.children[key]);
+                            }
+                        }
+                        // '/book/a'     => not-slug
+                        // '/book/:slug' => slug
+                        // GET /book/a   ~> no-slug, param['slug'] => undefined
+                        // GET /book/foo ~> slug, param['slug'] => foo
+                        if (typeof name === 'string' && !matched) {
+                            params[name] = part;
+                        }
+                        break;
+                    }
+                }
+            }
+            curNodes = tempNodes;
+        }
+        const len = handlerSets.length;
+        if (len === 0)
+            return null;
+        if (len === 1)
+            return { handlers: [handlerSets[0].handler], params };
+        const handlers = handlerSets
+            .sort((a, b) => {
+            return a.score - b.score;
+        })
+            .map((s) => {
+            return s.handler;
+        });
+        return { handlers, params };
+    }
+}
+exports.Node = Node;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrieRouter = void 0;
+const url_1 = require("../../utils/url");
+const node_1 = require("./node");
+class TrieRouter {
+    constructor() {
+        this.node = new node_1.Node();
+    }
+    add(method, path, handler) {
+        const results = (0, url_1.checkOptionalParameter)(path);
+        if (results) {
+            for (const p of results) {
+                this.node.insert(method, p, handler);
+            }
+            return;
+        }
+        this.node.insert(method, path, handler);
+    }
+    match(method, path) {
+        return this.node.search(method, path);
+    }
+}
+exports.TrieRouter = TrieRouter;

package/dist/cjs/router.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedPathError = exports.METHODS = exports.METHOD_NAME_ALL_LOWERCASE = exports.METHOD_NAME_ALL = void 0;
+exports.METHOD_NAME_ALL = 'ALL';
+exports.METHOD_NAME_ALL_LOWERCASE = 'all';
+exports.METHODS = ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'];
+class UnsupportedPathError extends Error {
+}
+exports.UnsupportedPathError = UnsupportedPathError;

package/dist/cjs/utils/body.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBody = void 0;
+async function parseBody(r) {
+    let body = {};
+    const contentType = r.headers.get('Content-Type');
+    if (contentType &&
+        (contentType.startsWith('multipart/form-data') ||
+            contentType === 'application/x-www-form-urlencoded')) {
+        const form = {};
+        body = [...(await r.formData())].reduce((acc, cur) => {
+            acc[cur[0]] = cur[1];
+            return acc;
+        }, form);
+    }
+    return body;
+}
+exports.parseBody = parseBody;

package/dist/cjs/utils/buffer.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferToString = exports.timingSafeEqual = exports.equal = void 0;
+const crypto_1 = require("./crypto");
+const equal = (a, b) => {
+    if (a === b) {
+        return true;
+    }
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    const va = new DataView(a);
+    const vb = new DataView(b);
+    let i = va.byteLength;
+    while (i--) {
+        if (va.getUint8(i) !== vb.getUint8(i)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.equal = equal;
+const timingSafeEqual = async (a, b, hashFunction) => {
+    if (!hashFunction) {
+        hashFunction = crypto_1.sha256;
+    }
+    const sa = await hashFunction(a);
+    const sb = await hashFunction(b);
+    return sa === sb && a === b;
+};
+exports.timingSafeEqual = timingSafeEqual;
+const bufferToString = (buffer) => {
+    if (buffer instanceof ArrayBuffer) {
+        const enc = new TextDecoder('utf-8');
+        return enc.decode(buffer);
+    }
+    return buffer;
+};
+exports.bufferToString = bufferToString;

package/dist/cjs/utils/cloudflare.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContentFromKVAsset = void 0;
+const getContentFromKVAsset = async (path, options) => {
+    let ASSET_MANIFEST = {};
+    if (options && options.manifest) {
+        if (typeof options.manifest === 'string') {
+            ASSET_MANIFEST = JSON.parse(options.manifest);
+        }
+        else {
+            ASSET_MANIFEST = options.manifest;
+        }
+    }
+    else {
+        if (typeof __STATIC_CONTENT_MANIFEST === 'string') {
+            ASSET_MANIFEST = JSON.parse(__STATIC_CONTENT_MANIFEST);
+        }
+        else {
+            ASSET_MANIFEST = __STATIC_CONTENT_MANIFEST;
+        }
+    }
+    let ASSET_NAMESPACE;
+    if (options && options.namespace) {
+        ASSET_NAMESPACE = options.namespace;
+    }
+    else {
+        ASSET_NAMESPACE = __STATIC_CONTENT;
+    }
+    const key = ASSET_MANIFEST[path] || path;
+    if (!key) {
+        return null;
+    }
+    let content = await ASSET_NAMESPACE.get(key, { type: 'arrayBuffer' });
+    if (content) {
+        content = content;
+    }
+    return content;
+};
+exports.getContentFromKVAsset = getContentFromKVAsset;

package/dist/cjs/utils/cookie.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialize = exports.parse = void 0;
+const parse = (cookie) => {
+    const pairs = cookie.split(/;\s*/g);
+    const parsedCookie = {};
+    for (let i = 0, len = pairs.length; i < len; i++) {
+        const pair = pairs[i].split(/\s*=\s*([^\s]+)/);
+        parsedCookie[pair[0]] = decodeURIComponent(pair[1]);
+    }
+    return parsedCookie;
+};
+exports.parse = parse;
+const serialize = (name, value, opt = {}) => {
+    value = encodeURIComponent(value);
+    let cookie = `${name}=${value}`;
+    if (opt.maxAge) {
+        cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
+    }
+    if (opt.domain) {
+        cookie += '; Domain=' + opt.domain;
+    }
+    if (opt.path) {
+        cookie += '; Path=' + opt.path;
+    }
+    if (opt.expires) {
+        cookie += '; Expires=' + opt.expires.toUTCString();
+    }
+    if (opt.httpOnly) {
+        cookie += '; HttpOnly';
+    }
+    if (opt.secure) {
+        cookie += '; Secure';
+    }
+    if (opt.sameSite) {
+        cookie += `; SameSite=${opt.sameSite}`;
+    }
+    return cookie;
+};
+exports.serialize = serialize;

package/dist/cjs/utils/crypto.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHash = exports.md5 = exports.sha1 = exports.sha256 = void 0;
+const sha256 = async (data) => {
+    const algorithm = { name: 'SHA-256', alias: 'sha256' };
+    const hash = await (0, exports.createHash)(data, algorithm);
+    return hash;
+};
+exports.sha256 = sha256;
+const sha1 = async (data) => {
+    const algorithm = { name: 'SHA-1', alias: 'sha1' };
+    const hash = await (0, exports.createHash)(data, algorithm);
+    return hash;
+};
+exports.sha1 = sha1;
+const md5 = async (data) => {
+    const algorithm = { name: 'MD5', alias: 'md5' };
+    const hash = await (0, exports.createHash)(data, algorithm);
+    return hash;
+};
+exports.md5 = md5;
+const createHash = async (data, algorithm) => {
+    let sourceBuffer;
+    if (data instanceof ReadableStream) {
+        let body = '';
+        const reader = data.getReader();
+        await reader?.read().then(async (chuck) => {
+            const value = await (0, exports.createHash)(chuck.value || '', algorithm);
+            body += value;
+        });
+        return body;
+    }
+    if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) {
+        sourceBuffer = data;
+    }
+    else {
+        if (typeof data === 'object') {
+            data = JSON.stringify(data);
+        }
+        sourceBuffer = new TextEncoder().encode(String(data));
+    }
+    if (crypto && crypto.subtle) {
+        const buffer = await crypto.subtle.digest({
+            name: algorithm.name,
+        }, sourceBuffer);
+        const hash = Array.prototype.map
+            .call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2))
+            .join('');
+        return hash;
+    }
+    return null;
+};
+exports.createHash = createHash;

package/dist/cjs/utils/encode.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayBufferToBase64URL = exports.arrayBufferToBase64 = exports.utf8ToUint8Array = exports.decodeBase64URL = exports.encodeBase64URL = exports.decodeBase64 = exports.encodeBase64 = void 0;
+const encodeBase64 = (str) => {
+    if (str === null) {
+        throw new TypeError('1st argument of "encodeBase64" should not be null.');
+    }
+    try {
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(str);
+        return btoa(String.fromCharCode(...bytes));
+    }
+    catch { }
+    try {
+        return Buffer.from(str).toString('base64');
+    }
+    catch (e) {
+        console.error('If you want to do "encodeBase64", polyfill "buffer" module.');
+        throw e;
+    }
+};
+exports.encodeBase64 = encodeBase64;
+const decodeBase64 = (str) => {
+    if (str === null) {
+        throw new TypeError('1st argument of "decodeBase64" should not be null.');
+    }
+    try {
+        const text = atob(str);
+        const bytes = new Uint8Array(text.split('').map((c) => c.charCodeAt(0)));
+        const decoder = new TextDecoder();
+        return decoder.decode(bytes);
+    }
+    catch { }
+    try {
+        return Buffer.from(str, 'base64').toString();
+    }
+    catch (e) {
+        console.error('If you want to do "decodeBase64", polyfill "buffer" module.');
+        throw e;
+    }
+};
+exports.decodeBase64 = decodeBase64;
+const encodeBase64URL = (str) => {
+    return (0, exports.encodeBase64)(str).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+};
+exports.encodeBase64URL = encodeBase64URL;
+const decodeBase64URL = (str) => {
+    const pad = (s) => {
+        const diff = s.length % 4;
+        if (diff === 2) {
+            return `${s}==`;
+        }
+        if (diff === 3) {
+            return `${s}=`;
+        }
+        return s;
+    };
+    return (0, exports.decodeBase64)(pad(str).replace(/-/g, '+').replace('_', '/'));
+};
+exports.decodeBase64URL = decodeBase64URL;
+const utf8ToUint8Array = (str) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(str);
+};
+exports.utf8ToUint8Array = utf8ToUint8Array;
+const arrayBufferToBase64 = async (buf) => {
+    if (typeof btoa === 'function') {
+        return btoa(String.fromCharCode(...new Uint8Array(buf)));
+    }
+    try {
+        return Buffer.from(String.fromCharCode(...new Uint8Array(buf))).toString('base64');
+    }
+    catch (e) { }
+    return '';
+};
+exports.arrayBufferToBase64 = arrayBufferToBase64;
+const arrayBufferToBase64URL = async (buf) => {
+    return (await (0, exports.arrayBufferToBase64)(buf)).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+};
+exports.arrayBufferToBase64URL = arrayBufferToBase64URL;

package/dist/cjs/utils/filepath.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilePath = void 0;
+const getFilePath = (options) => {
+    let filename = options.filename;
+    let root = options.root || '';
+    const defaultDocument = options.defaultDocument || 'index.html';
+    if (filename.endsWith('/')) {
+        // /top/ => /top/index.html
+        filename = filename.concat(defaultDocument);
+    }
+    else if (!filename.match(/\.[a-zA-Z0-9]+$/)) {
+        // /top => /top/index.html
+        filename = filename.concat('/' + defaultDocument);
+    }
+    // /foo.html => foo.html
+    filename = filename.replace(/^\.?\//, '');
+    // assets/ => assets
+    root = root.replace(/\/$/, '');
+    // ./assets/foo.html => assets/foo.html
+    let path = root ? root + '/' + filename : filename;
+    path = path.replace(/^\.?\//, '');
+    return path;
+};
+exports.getFilePath = getFilePath;

package/dist/cjs/utils/html.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeToBuffer = void 0;
+// The `escapeToBuffer` implementation is based on code from the MIT licensed `react-dom` package.
+// https://github.com/facebook/react/blob/main/packages/react-dom/src/server/escapeTextForBrowser.js
+const escapeRe = /[&<>"]/;
+const escapeToBuffer = (str, buffer) => {
+    const match = str.search(escapeRe);
+    if (match === -1) {
+        buffer[0] += str;
+        return;
+    }
+    let escape;
+    let index;
+    let lastIndex = 0;
+    for (index = match; index < str.length; index++) {
+        switch (str.charCodeAt(index)) {
+            case 34: // "
+                escape = '&quot;';
+                break;
+            case 38: // &
+                escape = '&amp;';
+                break;
+            case 60: // <
+                escape = '&lt;';
+                break;
+            case 62: // >
+                escape = '&gt;';
+                break;
+            default:
+                continue;
+        }
+        buffer[0] += str.substring(lastIndex, index) + escape;
+        lastIndex = index + 1;
+    }
+    buffer[0] += str.substring(lastIndex, index);
+};
+exports.escapeToBuffer = escapeToBuffer;