hono 2.0.5 → 2.0.8

package/dist/compose.js

@@ -4,6 +4,7 @@ exports.compose = void 0;
 const context_1 = require("./context");
 // Based on the code in the MIT licensed `koa-compose` package.
 const compose = (middleware, onError, onNotFound) => {
+    const middlewareLength = middleware.length;
     return (context, next) => {
         let index = -1;
         return dispatch(0);
@@ -13,7 +14,7 @@ const compose = (middleware, onError, onNotFound) => {
             }
             let handler = middleware[i];
             index = i;
-            if (i === middleware.length && next)
+            if (i === middlewareLength && next)
                 handler = next;
             if (!handler) {
                 if (context instanceof context_1.HonoContext && context.finalized === false && onNotFound) {

package/dist/context.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { NotFoundHandler } from './hono';
+import type { ContextVariableMap, NotFoundHandler } from './hono';
 import type { CookieOptions } from './utils/cookie';
 import type { StatusCode } from './utils/http-status';
 declare type Headers = Record<string, string>;
@@ -15,8 +15,14 @@ export interface Context<RequestParamKeyType extends string = string, E = Env> {
     set res(_res: Response);
     header: (name: string, value: string) => void;
     status: (status: StatusCode) => void;
-    set: (key: string, value: any) => void;
-    get: <T = any>(key: string) => T;
+    set: {
+        <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
+        (key: string, value: any): void;
+    };
+    get: {
+        <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
+        <T = any>(key: string): T;
+    };
     pretty: (prettyJSON: boolean, space?: number) => void;
     newResponse: (data: Data | null, status: StatusCode, headers: Headers) => Response;
     body: (data: Data | null, status?: StatusCode, headers?: Headers) => Response;

package/dist/context.js

@@ -39,7 +39,7 @@ class HonoContext {
     }
     header(name, value) {
         this._headers || (this._headers = {});
-        this._headers[name] = value;
+        this._headers[name.toLowerCase()] = value;
         if (this.finalized) {
             this.res.headers.set(name, value);
         }
@@ -62,7 +62,7 @@ class HonoContext {
         this._prettySpace = space;
     }
     newResponse(data, status, headers = {}) {
-        const _headers = { ...this._headers, ...headers };
+        const _headers = { ...this._headers };
         if (this._res) {
             this._res.headers.forEach((v, k) => {
                 _headers[k] = v;
@@ -70,25 +70,25 @@ class HonoContext {
         }
         return new Response(data, {
             status: status || this._status || 200,
-            headers: _headers,
+            headers: { ..._headers, ...headers },
         });
     }
     body(data, status = this._status, headers = {}) {
         return this.newResponse(data, status, headers);
     }
     text(text, status = this._status, headers = {}) {
-        headers['Content-Type'] || (headers['Content-Type'] = 'text/plain; charset=UTF-8');
+        headers['content-type'] = 'text/plain; charset=UTF-8';
         return this.body(text, status, headers);
     }
     json(object, status = this._status, headers = {}) {
         const body = this._pretty
             ? JSON.stringify(object, null, this._prettySpace)
             : JSON.stringify(object);
-        headers['Content-Type'] || (headers['Content-Type'] = 'application/json; charset=UTF-8');
+        headers['content-type'] = 'application/json; charset=UTF-8';
         return this.body(body, status, headers);
     }
     html(html, status = this._status, headers = {}) {
-        headers['Content-Type'] || (headers['Content-Type'] = 'text/html; charset=UTF-8');
+        headers['content-type'] = 'text/html; charset=UTF-8';
         return this.body(html, status, headers);
     }
     redirect(location, status = 302) {
@@ -103,7 +103,7 @@ class HonoContext {
     }
     cookie(name, value, opt) {
         const cookie = (0, cookie_1.serialize)(name, value, opt);
-        this.header('Set-Cookie', cookie);
+        this.header('set-cookie', cookie);
     }
     notFound() {
         return this.notFoundHandler(this);

package/dist/hono.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="@cloudflare/workers-types" />
 import type { Context } from './context';
 import type { Router } from './router';
+export interface ContextVariableMap {
+}
 declare type Env = Record<string, any>;
 export declare type Handler<RequestParamKeyType extends string = string, E = Env> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | Promise<void> | Promise<Response | undefined>;
 export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response | Promise<Response>;

package/dist/middleware/etag/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.etag = void 0;
-const body_1 = require("../../utils/body");
 const crypto_1 = require("../../utils/crypto");
 const etag = (options = { weak: false }) => {
     return async (c, next) => {
@@ -9,8 +8,7 @@ const etag = (options = { weak: false }) => {
         await next();
         const res = c.res;
         const clone = res.clone();
-        const body = await (0, body_1.parseBody)(res);
-        const hash = await (0, crypto_1.sha1)(body);
+        const hash = await (0, crypto_1.sha1)(res.body || '');
         const etag = options.weak ? `W/"${hash}"` : `"${hash}"`;
         if (ifNoneMatch && ifNoneMatch === etag) {
             await clone.blob(); // Force using body

package/dist/middleware/html/index.d.ts

@@ -1,5 +1,3 @@
-export declare type HtmlEscapedString = string & {
-    isEscaped: true;
-};
+import type { HtmlEscapedString } from '../../utils/html';
 export declare const raw: (value: any) => HtmlEscapedString;
 export declare const html: (strings: TemplateStringsArray, ...values: any[]) => HtmlEscapedString;

package/dist/middleware/html/index.js

@@ -9,24 +9,28 @@ const raw = (value) => {
 };
 exports.raw = raw;
 const html = (strings, ...values) => {
-    let result = '';
+    const buffer = [''];
     for (let i = 0, len = strings.length - 1; i < len; i++) {
-        result += strings[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 === 'boolean' || child === null || child === undefined) {
+            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) {
-                result += child;
+            else if ((typeof child === 'object' && child.isEscaped) ||
+                typeof child === 'number') {
+                buffer[0] += child;
             }
             else {
-                result += (0, html_1.escape)(child.toString());
+                (0, html_1.escapeToBuffer)(child.toString(), buffer);
             }
         }
     }
-    result += strings[strings.length - 1];
-    return (0, exports.raw)(result);
+    buffer[0] += strings[strings.length - 1];
+    return (0, exports.raw)(buffer[0]);
 };
 exports.html = html;

package/dist/middleware/jsx/index.d.ts

@@ -1,4 +1,4 @@
-import type { HtmlEscapedString } from '../../utils/html';
+import type { StringBuffer, HtmlEscaped, HtmlEscapedString } from '../../utils/html';
 declare global {
     namespace jsx.JSX {
         interface IntrinsicElements {
@@ -6,11 +6,21 @@ declare global {
         }
     }
 }
+declare type Child = string | number | JSXNode | Child[];
+export declare class JSXNode implements HtmlEscaped {
+    tag: string | Function;
+    props: Record<string, any>;
+    children: Child[];
+    isEscaped: true;
+    constructor(tag: string | Function, props: Record<string, any>, children: Child[]);
+    toString(): string;
+    toStringToBuffer(buffer: StringBuffer): void;
+}
 export { jsxFn as jsx };
-declare const jsxFn: (tag: string | Function, props: Record<string, any>, ...children: (string | HtmlEscapedString)[]) => HtmlEscapedString;
+declare const jsxFn: (tag: string | Function, props: Record<string, any>, ...children: (string | HtmlEscapedString)[]) => JSXNode;
 declare type FC<T = Record<string, any>> = (props: T) => HtmlEscapedString;
 export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
 export declare const Fragment: (props: {
     key?: string;
     children?: any;
-}) => HtmlEscapedString;
+}) => JSXNode;

package/dist/middleware/jsx/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Fragment = exports.memo = exports.jsx = void 0;
+exports.Fragment = exports.memo = exports.jsx = exports.JSXNode = void 0;
 const html_1 = require("../../utils/html");
 const emptyTags = [
     'area',
@@ -19,53 +19,144 @@ const emptyTags = [
     'track',
     'wbr',
 ];
-const jsxFn = (tag, props, ...children) => {
-    if (typeof tag === 'function') {
-        return tag.call(null, { ...props, children: children.length <= 1 ? children[0] : children });
-    }
-    let result = tag !== '' ? `<${tag}` : '';
-    const propsKeys = Object.keys(props || {});
-    for (let i = 0, len = propsKeys.length; i < len; i++) {
-        const v = props[propsKeys[i]];
-        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];
-            continue;
+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 (v === null || v === undefined) {
+        else if (typeof child === 'boolean' || child === null || child === undefined) {
             continue;
         }
-        result += ` ${propsKeys[i]}="${(0, html_1.escape)(v.toString())}"`;
+        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];
     }
-    if (tag !== '') {
+    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)) {
-            result += '/';
+            buffer[0] += '/>';
+            return;
         }
-        result += '>';
+        buffer[0] += '>';
+        childrenToStringToBuffer(children, buffer);
+        buffer[0] += `</${tag}>`;
     }
-    const flattenChildren = children.flat(Infinity);
-    for (let i = 0, len = flattenChildren.length; i < len; i++) {
-        const child = flattenChildren[i];
-        if (typeof child === 'boolean' || child === null || child === undefined) {
-            continue;
+}
+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 child === 'object' && child.isEscaped) {
-            result += child;
+        else if (typeof res === 'number' || res.isEscaped) {
+            buffer[0] += res;
         }
         else {
-            result += (0, html_1.escape)(child.toString());
+            (0, html_1.escapeToBuffer)(res, buffer);
         }
     }
-    if (tag !== '' && !emptyTags.includes(tag)) {
-        result += `</${tag}>`;
+}
+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);
     }
-    const escapedString = new String(result);
-    escapedString.isEscaped = true;
-    return escapedString;
 };
 exports.jsx = jsxFn;
 const shallowEqual = (a, b) => {
@@ -97,6 +188,6 @@ const memo = (component, propsAreEqual = shallowEqual) => {
 };
 exports.memo = memo;
 const Fragment = (props) => {
-    return jsxFn('', {}, ...(props.children || []));
+    return new JSXFragmentNode('', {}, props.children || []);
 };
 exports.Fragment = Fragment;

package/dist/middleware/jsx/jsx-dev-runtime.d.ts

@@ -1,2 +1,2 @@
-import type { HtmlEscapedString } from '../html';
-export declare function jsxDEV(tag: string | Function, props: Record<string, any>): HtmlEscapedString;
+import type { JSXNode } from '.';
+export declare function jsxDEV(tag: string | Function, props: Record<string, any>): JSXNode;

package/dist/middleware/jwt/index.d.ts

@@ -2,5 +2,6 @@ import type { Context } from '../../context';
 import type { Next } from '../../hono';
 export declare const jwt: (options: {
     secret: string;
+    cookie?: string;
     alg?: string;
 }) => (ctx: Context, next: Next) => Promise<void>;

package/dist/middleware/jwt/index.js

@@ -11,17 +11,26 @@ const jwt = (options) => {
     }
     return async (ctx, next) => {
         const credentials = ctx.req.headers.get('Authorization');
-        if (!credentials) {
-            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 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);
         }
-        const parts = credentials.split(/\s+/);
-        if (parts.length !== 2) {
+        if (!token) {
             ctx.res = new Response('Unauthorized', {
                 status: 401,
                 headers: {
@@ -33,7 +42,7 @@ const jwt = (options) => {
         let authorized = false;
         let msg = '';
         try {
-            authorized = await jwt_1.Jwt.verify(parts[1], options.secret, options.alg);
+            authorized = await jwt_1.Jwt.verify(token, options.secret, options.alg);
         }
         catch (e) {
             msg = `${e}`;

package/dist/request.d.ts

@@ -1,3 +1,4 @@
+import type { Body } from './utils/body';
 import type { Cookie } from './utils/cookie';
 declare global {
     interface Request<ParamKeyType extends string = string> {
@@ -22,9 +23,9 @@ declare global {
             (name: string): string;
             (): Cookie;
         };
-        parsedBody?: Promise<any>;
+        parsedBody?: Promise<Body>;
         parseBody: {
-            (): Promise<any>;
+            (): Promise<Body>;
         };
     }
 }

package/dist/utils/body.d.ts

@@ -1 +1,2 @@
-export declare const parseBody: (r: Request | Response) => Promise<string | object | Record<string, string | File>>;
+export declare type Body = string | object | Record<string, string | File> | ArrayBuffer;
+export declare const parseBody: (r: Request | Response) => Promise<Body>;

package/dist/utils/body.js

@@ -4,7 +4,12 @@ exports.parseBody = void 0;
 const parseBody = async (r) => {
     const contentType = r.headers.get('Content-Type') || '';
     if (contentType.includes('application/json')) {
-        return await r.json();
+        let body = {};
+        try {
+            body = await r.json();
+        }
+        catch { } // Do nothing
+        return body;
     }
     else if (contentType.includes('application/text')) {
         return await r.text();
@@ -20,6 +25,7 @@ const parseBody = async (r) => {
         }, form);
         return data;
     }
-    return r.arrayBuffer();
+    const arrayBuffer = await r.arrayBuffer();
+    return arrayBuffer;
 };
 exports.parseBody = parseBody;

package/dist/utils/crypto.d.ts

@@ -2,7 +2,7 @@ declare type Algorithm = {
     name: string;
     alias: string;
 };
-declare type Data = string | object | boolean;
+declare type Data = string | boolean | number | object | ArrayBufferView | ArrayBuffer | ReadableStream;
 export declare const sha256: (data: Data) => Promise<string | null>;
 export declare const sha1: (data: Data) => Promise<string | null>;
 export declare const md5: (data: Data) => Promise<string | null>;

package/dist/utils/crypto.js

@@ -20,10 +20,29 @@ const md5 = async (data) => {
 };
 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,
-        }, new TextEncoder().encode(String(data)));
+        }, sourceBuffer);
         const hash = Array.prototype.map
             .call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2))
             .join('');

package/dist/utils/html.d.ts

@@ -1,4 +1,6 @@
-export declare type HtmlEscapedString = string & {
+export declare type HtmlEscaped = {
     isEscaped: true;
 };
-export declare const escape: (str: string) => string;
+export declare type HtmlEscapedString = string & HtmlEscaped;
+export declare type StringBuffer = [string];
+export declare const escapeToBuffer: (str: string, buffer: StringBuffer) => void;

package/dist/utils/html.js

@@ -1,15 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.escape = void 0;
-const entityMap = {
-    '&': '&',
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
+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);
 };
-const escapeRe = new RegExp(`[${Object.keys(entityMap).join('')}]`, 'g');
-const replaceFn = (m) => entityMap[m];
-const escape = (str) => {
-    return str.replace(escapeRe, replaceFn);
-};
-exports.escape = escape;
+exports.escapeToBuffer = escapeToBuffer;

package/dist/utils/mime.js

@@ -34,7 +34,7 @@ const mimes = {
     gif: 'image/gif',
     htm: 'text/html',
     html: 'text/html',
-    ico: 'image/vnd.microsoft.icon',
+    ico: 'image/x-icon',
     ics: 'text/calendar',
     jar: 'application/java-archive',
     jpeg: 'image/jpeg',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "2.0.5",
+  "version": "2.0.8",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",