hono 2.1.3 → 2.2.0

package/dist/cjs/middleware/html/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.html = exports.raw = void 0;
+const html_1 = require("../../utils/html");
+const raw = (value) => {
+    const escapedString = new String(value);
+    escapedString.isEscaped = true;
+    return escapedString;
+};
+exports.raw = raw;
+const html = (strings, ...values) => {
+    const buffer = [''];
+    for (let i = 0, len = strings.length - 1; i < len; i++) {
+        buffer[0] += strings[i];
+        const children = values[i] instanceof Array ? values[i].flat(Infinity) : [values[i]];
+        for (let i = 0, len = children.length; i < len; i++) {
+            const child = children[i];
+            if (typeof child === 'string') {
+                (0, html_1.escapeToBuffer)(child, buffer);
+            }
+            else if (typeof child === 'boolean' || child === null || child === undefined) {
+                continue;
+            }
+            else if ((typeof child === 'object' && child.isEscaped) ||
+                typeof child === 'number') {
+                buffer[0] += child;
+            }
+            else {
+                (0, html_1.escapeToBuffer)(child.toString(), buffer);
+            }
+        }
+    }
+    buffer[0] += strings[strings.length - 1];
+    return (0, exports.raw)(buffer[0]);
+};
+exports.html = html;

package/dist/cjs/middleware/jsx/index.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fragment = exports.memo = exports.jsx = exports.JSXNode = void 0;
+const html_1 = require("../../utils/html");
+const emptyTags = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'keygen',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+];
+const booleanAttributes = [
+    'allowfullscreen',
+    'async',
+    'autofocus',
+    'autoplay',
+    'checked',
+    'controls',
+    'default',
+    'defer',
+    'disabled',
+    'formnovalidate',
+    'hidden',
+    'inert',
+    'ismap',
+    'itemscope',
+    'loop',
+    'multiple',
+    'muted',
+    'nomodule',
+    'novalidate',
+    'open',
+    'playsinline',
+    'readonly',
+    'required',
+    'reversed',
+    'selected',
+];
+const childrenToStringToBuffer = (children, buffer) => {
+    for (let i = 0, len = children.length; i < len; i++) {
+        const child = children[i];
+        if (typeof child === 'string') {
+            (0, html_1.escapeToBuffer)(child, buffer);
+        }
+        else if (typeof child === 'boolean' || child === null || child === undefined) {
+            continue;
+        }
+        else if (child instanceof JSXNode) {
+            child.toStringToBuffer(buffer);
+        }
+        else if (typeof child === 'number' || child.isEscaped) {
+            buffer[0] += child;
+        }
+        else {
+            // `child` type is `Child[]`, so stringify recursively
+            childrenToStringToBuffer(child, buffer);
+        }
+    }
+};
+class JSXNode {
+    constructor(tag, props, children) {
+        this.isEscaped = true;
+        this.tag = tag;
+        this.props = props;
+        this.children = children;
+    }
+    toString() {
+        const buffer = [''];
+        this.toStringToBuffer(buffer);
+        return buffer[0];
+    }
+    toStringToBuffer(buffer) {
+        const tag = this.tag;
+        const props = this.props;
+        let { children } = this;
+        buffer[0] += `<${tag}`;
+        const propsKeys = Object.keys(props || {});
+        for (let i = 0, len = propsKeys.length; i < len; i++) {
+            const v = props[propsKeys[i]];
+            if (typeof v === 'string') {
+                buffer[0] += ` ${propsKeys[i]}="`;
+                (0, html_1.escapeToBuffer)(v, buffer);
+                buffer[0] += '"';
+            }
+            else if (typeof v === 'number') {
+                buffer[0] += ` ${propsKeys[i]}="${v}"`;
+            }
+            else if (v === null || v === undefined) {
+                // Do nothing
+            }
+            else if (typeof v === 'boolean' && booleanAttributes.includes(propsKeys[i])) {
+                if (v) {
+                    buffer[0] += ` ${propsKeys[i]}=""`;
+                }
+            }
+            else if (propsKeys[i] === 'dangerouslySetInnerHTML') {
+                if (children.length > 0) {
+                    throw 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.';
+                }
+                const escapedString = new String(v.__html);
+                escapedString.isEscaped = true;
+                children = [escapedString];
+            }
+            else {
+                buffer[0] += ` ${propsKeys[i]}="`;
+                (0, html_1.escapeToBuffer)(v.toString(), buffer);
+                buffer[0] += '"';
+            }
+        }
+        if (emptyTags.includes(tag)) {
+            buffer[0] += '/>';
+            return;
+        }
+        buffer[0] += '>';
+        childrenToStringToBuffer(children, buffer);
+        buffer[0] += `</${tag}>`;
+    }
+}
+exports.JSXNode = JSXNode;
+class JSXFunctionNode extends JSXNode {
+    toStringToBuffer(buffer) {
+        const { children } = this;
+        const res = this.tag.call(null, {
+            ...this.props,
+            children: children.length <= 1 ? children[0] : children,
+        });
+        if (res instanceof JSXNode) {
+            res.toStringToBuffer(buffer);
+        }
+        else if (typeof res === 'number' || res.isEscaped) {
+            buffer[0] += res;
+        }
+        else {
+            (0, html_1.escapeToBuffer)(res, buffer);
+        }
+    }
+}
+class JSXFragmentNode extends JSXNode {
+    toStringToBuffer(buffer) {
+        childrenToStringToBuffer(this.children, buffer);
+    }
+}
+const jsxFn = (tag, props, ...children) => {
+    if (typeof tag === 'function') {
+        return new JSXFunctionNode(tag, props, children);
+    }
+    else {
+        return new JSXNode(tag, props, children);
+    }
+};
+exports.jsx = jsxFn;
+const shallowEqual = (a, b) => {
+    if (a === b) {
+        return true;
+    }
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (let i = 0, len = aKeys.length; i < len; i++) {
+        if (a[aKeys[i]] !== b[aKeys[i]]) {
+            return false;
+        }
+    }
+    return true;
+};
+const memo = (component, propsAreEqual = shallowEqual) => {
+    let computed = undefined;
+    let prevProps = undefined;
+    return ((props) => {
+        if (prevProps && !propsAreEqual(prevProps, props)) {
+            computed = undefined;
+        }
+        prevProps = props;
+        return (computed || (computed = component(props)));
+    });
+};
+exports.memo = memo;
+const Fragment = (props) => {
+    return new JSXFragmentNode('', {}, props.children || []);
+};
+exports.Fragment = Fragment;

package/dist/cjs/middleware/jsx/jsx-dev-runtime.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsxDEV = void 0;
+const _1 = require(".");
+function jsxDEV(tag, props) {
+    const children = props.children ?? [];
+    delete props['children'];
+    return (0, _1.jsx)(tag, props, children);
+}
+exports.jsxDEV = jsxDEV;

package/dist/cjs/middleware/jsx/jsx-runtime.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsxs = exports.jsx = void 0;
+var jsx_dev_runtime_1 = require("./jsx-dev-runtime");
+Object.defineProperty(exports, "jsx", { enumerable: true, get: function () { return jsx_dev_runtime_1.jsxDEV; } });
+var jsx_dev_runtime_2 = require("./jsx-dev-runtime");
+Object.defineProperty(exports, "jsxs", { enumerable: true, get: function () { return jsx_dev_runtime_2.jsxDEV; } });

package/dist/cjs/middleware/jwt/index.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jwt = void 0;
+const jwt_1 = require("../../utils/jwt");
+const jwt = (options) => {
+    if (!options) {
+        throw new Error('JWT auth middleware requires options for "secret');
+    }
+    if (!crypto.subtle || !crypto.subtle.importKey) {
+        throw new Error('`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.');
+    }
+    return async (ctx, next) => {
+        const credentials = ctx.req.headers.get('Authorization');
+        let token;
+        if (credentials) {
+            const parts = credentials.split(/\s+/);
+            if (parts.length !== 2) {
+                ctx.res = new Response('Unauthorized', {
+                    status: 401,
+                    headers: {
+                        'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_request",error_description="invalid credentials structure"`,
+                    },
+                });
+                return;
+            }
+            else {
+                token = parts[1];
+            }
+        }
+        else if (options.cookie) {
+            token = ctx.req.cookie(options.cookie);
+        }
+        if (!token) {
+            ctx.res = new Response('Unauthorized', {
+                status: 401,
+                headers: {
+                    'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_request",error_description="no authorization included in request"`,
+                },
+            });
+            return;
+        }
+        let authorized = false;
+        let msg = '';
+        try {
+            authorized = await jwt_1.Jwt.verify(token, options.secret, options.alg);
+        }
+        catch (e) {
+            msg = `${e}`;
+        }
+        if (!authorized) {
+            ctx.res = new Response('Unauthorized', {
+                status: 401,
+                statusText: msg,
+                headers: {
+                    'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_token",error_description="token verification failure"`,
+                },
+            });
+            return;
+        }
+        await next();
+    };
+};
+exports.jwt = jwt;

package/dist/cjs/middleware/logger/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const url_1 = require("../../utils/url");
+var LogPrefix;
+(function (LogPrefix) {
+    LogPrefix["Outgoing"] = "-->";
+    LogPrefix["Incoming"] = "<--";
+    LogPrefix["Error"] = "xxx";
+})(LogPrefix || (LogPrefix = {}));
+const humanize = (times) => {
+    const [delimiter, separator] = [',', '.'];
+    const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1' + delimiter));
+    return orderTimes.join(separator);
+};
+const time = (start) => {
+    const delta = Date.now() - start;
+    return humanize([delta < 1000 ? delta + 'ms' : Math.round(delta / 1000) + 's']);
+};
+const colorStatus = (status) => {
+    const out = {
+        7: `\x1b[35m${status}\x1b[0m`,
+        5: `\x1b[31m${status}\x1b[0m`,
+        4: `\x1b[33m${status}\x1b[0m`,
+        3: `\x1b[36m${status}\x1b[0m`,
+        2: `\x1b[32m${status}\x1b[0m`,
+        1: `\x1b[32m${status}\x1b[0m`,
+        0: `\x1b[33m${status}\x1b[0m`,
+    };
+    const calculateStatus = (status / 100) | 0;
+    return out[calculateStatus];
+};
+function log(fn, prefix, method, path, status = 0, elapsed) {
+    const out = prefix === LogPrefix.Incoming
+        ? `  ${prefix} ${method} ${path}`
+        : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
+    fn(out);
+}
+const logger = (fn = console.log) => {
+    return async (c, next) => {
+        const { method } = c.req;
+        const path = (0, url_1.getPathFromURL)(c.req.url);
+        log(fn, LogPrefix.Incoming, method, path);
+        const start = Date.now();
+        await next();
+        log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start));
+    };
+};
+exports.logger = logger;

package/dist/cjs/middleware/powered-by/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.poweredBy = void 0;
+const poweredBy = () => {
+    return async (c, next) => {
+        await next();
+        c.res.headers.append('X-Powered-By', 'Hono');
+    };
+};
+exports.poweredBy = poweredBy;

package/dist/cjs/middleware/pretty-json/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyJSON = void 0;
+const prettyJSON = (options = { space: 2 }) => {
+    return async (c, next) => {
+        const pretty = c.req.query('pretty') || c.req.query('pretty') === '' ? true : false;
+        c.pretty(pretty, options.space);
+        await next();
+    };
+};
+exports.prettyJSON = prettyJSON;

package/dist/cjs/middleware/serve-static/bun.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = void 0;
+// @denoify-ignore
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const fs_1 = require("fs");
+const filepath_1 = require("../../utils/filepath");
+const mime_1 = require("../../utils/mime");
+// @ts-ignore
+const { file } = Bun;
+const DEFAULT_DOCUMENT = 'index.html';
+const serveStatic = (options = { root: '' }) => {
+    return async (c, next) => {
+        // Do nothing if Response is already set
+        if (c.res && c.finalized) {
+            await next();
+        }
+        const url = new URL(c.req.url);
+        let path = (0, filepath_1.getFilePath)({
+            filename: options.path ?? url.pathname,
+            root: options.root,
+            defaultDocument: DEFAULT_DOCUMENT,
+        });
+        path = `./${path}`;
+        if ((0, fs_1.existsSync)(path)) {
+            const content = file(path);
+            if (content) {
+                const mimeType = (0, mime_1.getMimeType)(path);
+                if (mimeType) {
+                    c.header('Content-Type', mimeType);
+                }
+                // Return Response object
+                return c.body(content);
+            }
+        }
+        console.warn(`Static file: ${path} is not found`);
+        await next();
+        return;
+    };
+};
+exports.serveStatic = serveStatic;

package/dist/cjs/middleware/serve-static/index.js

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

package/dist/cjs/middleware/serve-static/serve-static.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = void 0;
+const cloudflare_1 = require("../../utils/cloudflare");
+const filepath_1 = require("../../utils/filepath");
+const mime_1 = require("../../utils/mime");
+const DEFAULT_DOCUMENT = 'index.html';
+// This middleware is available only on Cloudflare Workers.
+const serveStatic = (options = { root: '' }) => {
+    return async (c, next) => {
+        // Do nothing if Response is already set
+        if (c.finalized) {
+            await next();
+        }
+        const url = new URL(c.req.url);
+        const path = (0, filepath_1.getFilePath)({
+            filename: options.path ?? url.pathname,
+            root: options.root,
+            defaultDocument: DEFAULT_DOCUMENT,
+        });
+        const content = await (0, cloudflare_1.getContentFromKVAsset)(path, {
+            manifest: options.manifest,
+            namespace: options.namespace ? options.namespace : c.env ? c.env.__STATIC_CONTENT : undefined,
+        });
+        if (content) {
+            const mimeType = (0, mime_1.getMimeType)(path);
+            if (mimeType) {
+                c.header('Content-Type', mimeType);
+            }
+            // Return Response object
+            return c.body(content);
+        }
+        else {
+            console.warn(`Static file: ${path} is not found`);
+            await next();
+        }
+        return;
+    };
+};
+exports.serveStatic = serveStatic;

package/dist/cjs/middleware/validator/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validator = void 0;
+const middleware_1 = require("./middleware");
+Object.defineProperty(exports, "validator", { enumerable: true, get: function () { return middleware_1.validatorMiddleware; } });

package/dist/cjs/middleware/validator/middleware.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatorMiddleware = void 0;
+const validator_1 = require("./validator");
+function getValidatorList(schema) {
+    const map = [];
+    for (const [key, value] of Object.entries(schema)) {
+        if (value instanceof validator_1.VBase) {
+            map.push([[key], value]);
+        }
+        else {
+            const children = getValidatorList(value);
+            for (const [keys, validator] of children) {
+                map.push([[key, ...keys], validator]);
+            }
+        }
+    }
+    return map;
+}
+const validatorMiddleware = (validationFunction, options) => {
+    const v = new validator_1.Validator();
+    const handler = async (c, next) => {
+        const resultSet = {
+            hasError: false,
+            messages: [],
+            results: [],
+        };
+        const validatorList = getValidatorList(validationFunction(v, c));
+        for (const [keys, validator] of validatorList) {
+            const result = await validator.validate(c.req);
+            if (result.isValid) {
+                // Set data on request object
+                c.req.valid(keys, result.value);
+            }
+            else {
+                resultSet.hasError = true;
+                if (result.message !== undefined) {
+                    resultSet.messages.push(result.message);
+                }
+            }
+            resultSet.results.push(result);
+        }
+        if (options && options.done) {
+            const res = options.done(resultSet, c);
+            if (res) {
+                return res;
+            }
+        }
+        if (resultSet.hasError) {
+            return c.text(resultSet.messages.join('\n'), 400);
+        }
+        await next();
+    };
+    return handler;
+};
+exports.validatorMiddleware = validatorMiddleware;

package/dist/cjs/middleware/validator/rule.js

@@ -0,0 +1,66 @@
+"use strict";
+// Some validation rules is are based on Validator.js
+// Validator.js
+// License (MIT)
+// Copyright (c) 2018 Chris O'Hara <cohara87@gmail.com>
+// https://github.com/validatorjs/validator.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+exports.rule = {
+    // string
+    isEmpty(value, options = { ignore_whitespace: false }) {
+        return (options.ignore_whitespace ? value.trim().length : value.length) === 0;
+    },
+    isLength: (value, options, arg2) => {
+        let min;
+        let max;
+        if (typeof options === 'object') {
+            min = options.min || 0;
+            max = options.max;
+        }
+        else {
+            // backwards compatibility: isLength(str, min [, max])
+            min = options || 0;
+            max = arg2;
+        }
+        const presentationSequences = value.match(/(\uFE0F|\uFE0E)/g) || [];
+        const surrogatePairs = value.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g) || [];
+        const len = value.length - presentationSequences.length - surrogatePairs.length;
+        return len >= min && (typeof max === 'undefined' || len <= max);
+    },
+    isAlpha: (value) => {
+        return /^[A-Z]+$/i.test(value);
+    },
+    isNumeric: (value) => {
+        return /^[0-9]+$/.test(value);
+    },
+    contains: (value, elem, options = {
+        ignoreCase: false,
+        minOccurrences: 1,
+    }) => {
+        options.ignoreCase || (options.ignoreCase = false);
+        options.minOccurrences || (options.minOccurrences = 1);
+        if (options.ignoreCase) {
+            return value.toLowerCase().split(elem.toLowerCase()).length > options.minOccurrences;
+        }
+        return value.split(elem).length > options.minOccurrences;
+    },
+    isIn: (value, options) => {
+        if (typeof options === 'object') {
+            for (const elem of options) {
+                if (elem === value)
+                    return true;
+            }
+        }
+        return false;
+    },
+    match: (value, regExp) => {
+        return regExp.test(value);
+    },
+    // number
+    isGte: (value, min) => min <= value,
+    isLte: (value, max) => value <= max,
+    // boolean
+    isTrue: (value) => value === true,
+    isFalse: (value) => value === false,
+};

package/dist/cjs/middleware/validator/sanitizer.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizer = void 0;
+exports.sanitizer = {
+    trim: (value) => value.trim(),
+};