hono 4.6.8 → 4.6.10

package/dist/hono-base.js

@@ -36,12 +36,10 @@ var Hono = class {
         if (typeof args1 === "string") {
           this.#path = args1;
         } else {
-          this.addRoute(method, this.#path, args1);
+          this.#addRoute(method, this.#path, args1);
         }
         args.forEach((handler) => {
-          if (typeof handler !== "string") {
-            this.addRoute(method, this.#path, handler);
-          }
+          this.#addRoute(method, this.#path, handler);
         });
         return this;
       };
@@ -51,7 +49,7 @@ var Hono = class {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
-            this.addRoute(m.toUpperCase(), this.#path, handler);
+            this.#addRoute(m.toUpperCase(), this.#path, handler);
           });
         }
       }
@@ -65,7 +63,7 @@ var Hono = class {
         handlers.unshift(arg1);
       }
       handlers.forEach((handler) => {
-        this.addRoute(METHOD_NAME_ALL, this.#path, handler);
+        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
       });
       return this;
     };
@@ -74,7 +72,7 @@ var Hono = class {
     Object.assign(this, options);
     this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict;
   }
-  clone() {
+  #clone() {
     const clone = new Hono({
       router: this.router,
       getPath: this.getPath
@@ -82,33 +80,33 @@ var Hono = class {
     clone.routes = this.routes;
     return clone;
   }
-  notFoundHandler = notFoundHandler;
-  errorHandler = errorHandler;
+  #notFoundHandler = notFoundHandler;
+  #errorHandler = errorHandler;
   route(path, app) {
     const subApp = this.basePath(path);
     app.routes.map((r) => {
       let handler;
-      if (app.errorHandler === errorHandler) {
+      if (app.#errorHandler === errorHandler) {
         handler = r.handler;
       } else {
-        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        handler = async (c, next) => (await compose([], app.#errorHandler)(c, () => r.handler(c, next))).res;
         handler[COMPOSED_HANDLER] = r.handler;
       }
-      subApp.addRoute(r.method, r.path, handler);
+      subApp.#addRoute(r.method, r.path, handler);
     });
     return this;
   }
   basePath(path) {
-    const subApp = this.clone();
+    const subApp = this.#clone();
     subApp._basePath = mergePath(this._basePath, path);
     return subApp;
   }
   onError = (handler) => {
-    this.errorHandler = handler;
+    this.#errorHandler = handler;
     return this;
   };
   notFound = (handler) => {
-    this.notFoundHandler = handler;
+    this.#notFoundHandler = handler;
     return this;
   };
   mount(path, applicationHandler, options) {
@@ -149,52 +147,49 @@ var Hono = class {
       }
       await next();
     };
-    this.addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
     return this;
   }
-  addRoute(method, path, handler) {
+  #addRoute(method, path, handler) {
     method = method.toUpperCase();
     path = mergePath(this._basePath, path);
     const r = { path, method, handler };
     this.router.add(method, path, [handler, r]);
     this.routes.push(r);
   }
-  matchRoute(method, path) {
-    return this.router.match(method, path);
-  }
-  handleError(err, c) {
+  #handleError(err, c) {
     if (err instanceof Error) {
-      return this.errorHandler(err, c);
+      return this.#errorHandler(err, c);
     }
     throw err;
   }
-  dispatch(request, executionCtx, env, method) {
+  #dispatch(request, executionCtx, env, method) {
     if (method === "HEAD") {
-      return (async () => new Response(null, await this.dispatch(request, executionCtx, env, "GET")))();
+      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
     const path = this.getPath(request, { env });
-    const matchResult = this.matchRoute(method, path);
+    const matchResult = this.router.match(method, path);
     const c = new Context(request, {
       path,
       matchResult,
       env,
       executionCtx,
-      notFoundHandler: this.notFoundHandler
+      notFoundHandler: this.#notFoundHandler
     });
     if (matchResult[0].length === 1) {
       let res;
       try {
         res = matchResult[0][0][0][0](c, async () => {
-          c.res = await this.notFoundHandler(c);
+          c.res = await this.#notFoundHandler(c);
         });
       } catch (err) {
-        return this.handleError(err, c);
+        return this.#handleError(err, c);
       }
       return res instanceof Promise ? res.then(
-        (resolved) => resolved || (c.finalized ? c.res : this.notFoundHandler(c))
-      ).catch((err) => this.handleError(err, c)) : res ?? this.notFoundHandler(c);
+        (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
+      ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
     }
-    const composed = compose(matchResult[0], this.errorHandler, this.notFoundHandler);
+    const composed = compose(matchResult[0], this.#errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
         const context = await composed(c);
@@ -205,28 +200,30 @@ var Hono = class {
         }
         return context.res;
       } catch (err) {
-        return this.handleError(err, c);
+        return this.#handleError(err, c);
       }
     })();
   }
   fetch = (request, ...rest) => {
-    return this.dispatch(request, rest[1], rest[0], request.method);
+    return this.#dispatch(request, rest[1], rest[0], request.method);
   };
   request = (input, requestInit, Env, executionCtx) => {
     if (input instanceof Request) {
-      if (requestInit !== void 0) {
-        input = new Request(input, requestInit);
-      }
-      return this.fetch(input, Env, executionCtx);
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
     }
     input = input.toString();
-    const path = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
-    const req = new Request(path, requestInit);
-    return this.fetch(req, Env, executionCtx);
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    );
   };
   fire = () => {
     addEventListener("fetch", (event) => {
-      event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
+      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
     });
   };
 };

package/dist/jsx/base.js

@@ -1,7 +1,7 @@
 // src/jsx/base.ts
 import { raw } from "../helper/html/index.js";
 import { escapeToBuffer, resolveCallbackSync, stringBufferToString } from "../utils/html.js";
-import { DOM_RENDERER } from "./constants.js";
+import { DOM_RENDERER, DOM_MEMO } from "./constants.js";
 import { createContext, globalContexts, useContext } from "./context.js";
 import { domRenderers } from "./intrinsic-element/common.js";
 import * as intrinsicElementTags from "./intrinsic-element/components.js";
@@ -270,13 +270,16 @@ var shallowEqual = (a, b) => {
 var memo = (component, propsAreEqual = shallowEqual) => {
   let computed = null;
   let prevProps = void 0;
-  return (props) => {
+  const wrapper = (props) => {
     if (prevProps && !propsAreEqual(prevProps, props)) {
       computed = null;
     }
     prevProps = props;
     return computed ||= component(props);
   };
+  wrapper[DOM_MEMO] = propsAreEqual;
+  wrapper[DOM_RENDERER] = component;
+  return wrapper;
 };
 var Fragment = ({
   children
@@ -311,5 +314,6 @@ export {
   jsx,
   jsxFn,
   memo,
-  reactAPICompatVersion
+  reactAPICompatVersion,
+  shallowEqual
 };

package/dist/jsx/constants.js

@@ -3,10 +3,12 @@ var DOM_RENDERER = Symbol("RENDERER");
 var DOM_ERROR_HANDLER = Symbol("ERROR_HANDLER");
 var DOM_STASH = Symbol("STASH");
 var DOM_INTERNAL_TAG = Symbol("INTERNAL");
+var DOM_MEMO = Symbol("MEMO");
 var PERMALINK = Symbol("PERMALINK");
 export {
   DOM_ERROR_HANDLER,
   DOM_INTERNAL_TAG,
+  DOM_MEMO,
   DOM_RENDERER,
   DOM_STASH,
   PERMALINK

package/dist/jsx/dom/index.js

@@ -1,6 +1,7 @@
 // src/jsx/dom/index.ts
-import { isValidElement, memo, reactAPICompatVersion } from "../base.js";
+import { isValidElement, reactAPICompatVersion, shallowEqual } from "../base.js";
 import { Children } from "../children.js";
+import { DOM_MEMO } from "../constants.js";
 import { useContext } from "../context.js";
 import {
   createRef,
@@ -53,6 +54,11 @@ var cloneElement = (element, props, ...children) => {
     element.key
   );
 };
+var memo = (component, propsAreEqual = shallowEqual) => {
+  const wrapper = (props) => component(props);
+  wrapper[DOM_MEMO] = propsAreEqual;
+  return wrapper;
+};
 var dom_default = {
   version: reactAPICompatVersion,
   useState,

package/dist/jsx/dom/render.js

@@ -1,6 +1,12 @@
 // src/jsx/dom/render.ts
 import { toArray } from "../children.js";
-import { DOM_ERROR_HANDLER, DOM_INTERNAL_TAG, DOM_RENDERER, DOM_STASH } from "../constants.js";
+import {
+  DOM_ERROR_HANDLER,
+  DOM_INTERNAL_TAG,
+  DOM_MEMO,
+  DOM_RENDERER,
+  DOM_STASH
+} from "../constants.js";
 import { globalContexts as globalJSXContexts, useContext } from "../context.js";
 import { STASH_EFFECT } from "../hooks/index.js";
 import { normalizeIntrinsicElementKey, styleObjectForEach } from "../utils.js";
@@ -228,13 +234,19 @@ var applyNodeObject = (node, container, isNew) => {
   remove.forEach(removeNode);
   const childNodes = isNew ? void 0 : container.childNodes;
   let offset;
+  let insertBeforeNode = null;
   if (isNew) {
     offset = -1;
+  } else if (!childNodes.length) {
+    offset = 0;
   } else {
-    offset = (childNodes.length && (findChildNodeIndex(childNodes, findInsertBefore(node.nN)) ?? findChildNodeIndex(
-      childNodes,
-      next.find((n) => n.tag !== HONO_PORTAL_ELEMENT && n.e)?.e
-    ))) ?? -1;
+    const offsetByNextNode = findChildNodeIndex(childNodes, findInsertBefore(node.nN));
+    if (offsetByNextNode !== void 0) {
+      insertBeforeNode = childNodes[offsetByNextNode];
+      offset = offsetByNextNode;
+    } else {
+      offset = findChildNodeIndex(childNodes, next.find((n) => n.tag !== HONO_PORTAL_ELEMENT && n.e)?.e) ?? -1;
+    }
     if (offset === -1) {
       isNew = true;
     }
@@ -269,7 +281,7 @@ var applyNodeObject = (node, container, isNew) => {
       if (childNodes[offset + 1] === el) {
         container.appendChild(childNodes[offset]);
       } else {
-        container.insertBefore(el, childNodes[offset] || null);
+        container.insertBefore(el, insertBeforeNode || childNodes[offset] || null);
       }
     }
   }
@@ -351,12 +363,8 @@ var build = (context, node, children) => {
             if (typeof child.tag === "function") {
               oldChild[DOM_STASH][2] = child[DOM_STASH][2] || [];
               oldChild[DOM_STASH][3] = child[DOM_STASH][3];
-              if (!oldChild.f) {
-                const prevPropsKeys = Object.keys(pP);
-                const currentProps = oldChild.props;
-                if (prevPropsKeys.length === Object.keys(currentProps).length && prevPropsKeys.every((k) => k in currentProps && currentProps[k] === pP[k])) {
-                  oldChild.s = true;
-                }
+              if (!oldChild.f && ((oldChild.o || oldChild) === child.o || oldChild.tag[DOM_MEMO]?.(pP, oldChild.props))) {
+                oldChild.s = true;
               }
             }
             child = oldChild;
@@ -443,7 +451,8 @@ var buildNode = (node) => {
         key: node.key,
         f: node.f,
         type: node.tag,
-        ref: node.props.ref
+        ref: node.props.ref,
+        o: node.o || node
       };
     }
     if (typeof node.tag === "function") {

package/dist/middleware/combine/index.js

@@ -27,16 +27,22 @@ var some = (...middleware) => {
   };
 };
 var every = (...middleware) => {
-  const wrappedMiddleware = middleware.map((m) => async (c, next) => {
-    const res = await m(c, next);
-    if (res === false) {
-      throw new Error("Unmet condition");
-    }
-    return res;
-  });
-  const handler = async (c, next) => compose(wrappedMiddleware.map((m) => [[m, void 0], c.req.param()]))(c, next);
   return async function every2(c, next) {
-    await handler(c, next);
+    const currentRouteIndex = c.req.routeIndex;
+    await compose(
+      middleware.map((m) => [
+        [
+          async (c2, next2) => {
+            c2.req.routeIndex = currentRouteIndex;
+            const res = await m(c2, next2);
+            if (res === false) {
+              throw new Error("Unmet condition");
+            }
+            return res;
+          }
+        ]
+      ])
+    )(c, next);
   };
 };
 var except = (condition, ...middleware) => {

package/dist/middleware/etag/digest.js

@@ -0,0 +1,36 @@
+// src/middleware/etag/digest.ts
+var mergeBuffers = (buffer1, buffer2) => {
+  if (!buffer1) {
+    return buffer2;
+  }
+  const merged = new Uint8Array(buffer1.byteLength + buffer2.byteLength);
+  merged.set(new Uint8Array(buffer1), 0);
+  merged.set(buffer2, buffer1.byteLength);
+  return merged;
+};
+var generateDigest = async (stream) => {
+  if (!stream || !crypto || !crypto.subtle) {
+    return null;
+  }
+  let result = void 0;
+  const reader = stream.getReader();
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) {
+      break;
+    }
+    result = await crypto.subtle.digest(
+      {
+        name: "SHA-1"
+      },
+      mergeBuffers(result, value)
+    );
+  }
+  if (!result) {
+    return null;
+  }
+  return Array.prototype.map.call(new Uint8Array(result), (x) => x.toString(16).padStart(2, "0")).join("");
+};
+export {
+  generateDigest
+};

package/dist/middleware/etag/index.js

@@ -1,5 +1,5 @@
 // src/middleware/etag/index.ts
-import { sha1 } from "../../utils/crypto.js";
+import { generateDigest } from "./digest.js";
 var RETAINED_304_HEADERS = [
   "cache-control",
   "content-location",
@@ -20,7 +20,10 @@ var etag = (options) => {
     const res = c.res;
     let etag3 = res.headers.get("ETag");
     if (!etag3) {
-      const hash = await sha1(res.clone().body || "");
+      const hash = await generateDigest(res.clone().body);
+      if (hash === null) {
+        return;
+      }
       etag3 = weak ? `W/"${hash}"` : `"${hash}"`;
     }
     if (etagMatches(etag3, ifNoneMatch)) {

package/dist/middleware/ip-restriction/index.js

@@ -18,14 +18,14 @@ var buildMatcher = (rules) => {
       functionRules.push(rule);
     } else {
       if (IS_CIDR_NOTATION_REGEX.test(rule)) {
-        const splittedRule = rule.split("/");
-        const addrStr = splittedRule[0];
+        const separatedRule = rule.split("/");
+        const addrStr = separatedRule[0];
         const type2 = distinctRemoteAddr(addrStr);
         if (type2 === void 0) {
           throw new TypeError(`Invalid rule: ${rule}`);
         }
         const isIPv4 = type2 === "IPv4";
-        const prefix = parseInt(splittedRule[1]);
+        const prefix = parseInt(separatedRule[1]);
         if (isIPv4 ? prefix === 32 : prefix === 128) {
           rule = addrStr;
         } else {

package/dist/middleware/jsx-renderer/index.js

@@ -8,7 +8,8 @@ var createRenderer = (c, Layout, component, options) => (children, props) => {
   const currentLayout = component ? jsx(
     (props2) => component(props2, c),
     {
-      ...{ Layout, ...props }
+      Layout,
+      ...props
     },
     children
   ) : children;

package/dist/middleware/logger/index.js

@@ -12,17 +12,19 @@ var time = (start) => {
 };
 var colorStatus = (status) => {
   const colorEnabled = getColorEnabled();
-  const out = {
-    7: colorEnabled ? `\x1B[35m${status}\x1B[0m` : `${status}`,
-    5: colorEnabled ? `\x1B[31m${status}\x1B[0m` : `${status}`,
-    4: colorEnabled ? `\x1B[33m${status}\x1B[0m` : `${status}`,
-    3: colorEnabled ? `\x1B[36m${status}\x1B[0m` : `${status}`,
-    2: colorEnabled ? `\x1B[32m${status}\x1B[0m` : `${status}`,
-    1: colorEnabled ? `\x1B[32m${status}\x1B[0m` : `${status}`,
-    0: colorEnabled ? `\x1B[33m${status}\x1B[0m` : `${status}`
-  };
-  const calculateStatus = status / 100 | 0;
-  return out[calculateStatus];
+  if (colorEnabled) {
+    switch (status / 100 | 0) {
+      case 5:
+        return `\x1B[31m${status}\x1B[0m`;
+      case 4:
+        return `\x1B[33m${status}\x1B[0m`;
+      case 3:
+        return `\x1B[36m${status}\x1B[0m`;
+      case 2:
+        return `\x1B[32m${status}\x1B[0m`;
+    }
+  }
+  return `${status}`;
 };
 function log(fn, prefix, method, path, status = 0, elapsed) {
   const out = prefix === "<--" /* Incoming */ ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;

package/dist/middleware/timing/timing.js

@@ -9,13 +9,11 @@ var getTime = () => {
 };
 var timing = (config) => {
   const options = {
-    ...{
-      total: true,
-      enabled: true,
-      totalDescription: "Total Response Time",
-      autoEnd: true,
-      crossOrigin: false
-    },
+    total: true,
+    enabled: true,
+    totalDescription: "Total Response Time",
+    autoEnd: true,
+    crossOrigin: false,
     ...config
   };
   return async function timing2(c, next) {

package/dist/request.js

@@ -1,6 +1,7 @@
 // src/request.ts
 import { parseBody } from "./utils/body.js";
-import { decodeURIComponent_, getQueryParam, getQueryParams } from "./utils/url.js";
+import { decodeURIComponent_, getQueryParam, getQueryParams, tryDecode } from "./utils/url.js";
+var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
 var HonoRequest = class {
   raw;
   #validatedData;
@@ -15,25 +16,25 @@ var HonoRequest = class {
     this.#validatedData = {};
   }
   param(key) {
-    return key ? this.getDecodedParam(key) : this.getAllDecodedParams();
+    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
   }
-  getDecodedParam(key) {
+  #getDecodedParam(key) {
     const paramKey = this.#matchResult[0][this.routeIndex][1][key];
-    const param = this.getParamValue(paramKey);
-    return param ? /\%/.test(param) ? decodeURIComponent_(param) : param : void 0;
+    const param = this.#getParamValue(paramKey);
+    return param ? /\%/.test(param) ? tryDecodeURIComponent(param) : param : void 0;
   }
-  getAllDecodedParams() {
+  #getAllDecodedParams() {
     const decoded = {};
     const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
     for (const key of keys) {
-      const value = this.getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
       if (value && typeof value === "string") {
-        decoded[key] = /\%/.test(value) ? decodeURIComponent_(value) : value;
+        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
       }
     }
     return decoded;
   }
-  getParamValue(paramKey) {
+  #getParamValue(paramKey) {
     return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
   }
   query(key) {
@@ -55,7 +56,7 @@ var HonoRequest = class {
   async parseBody(options) {
     return this.bodyCache.parsedBody ??= await parseBody(this, options);
   }
-  cachedBody = (key) => {
+  #cachedBody = (key) => {
     const { bodyCache, raw } = this;
     const cachedBody = bodyCache[key];
     if (cachedBody) {
@@ -73,19 +74,19 @@ var HonoRequest = class {
     return bodyCache[key] = raw[key]();
   };
   json() {
-    return this.cachedBody("json");
+    return this.#cachedBody("json");
   }
   text() {
-    return this.cachedBody("text");
+    return this.#cachedBody("text");
   }
   arrayBuffer() {
-    return this.cachedBody("arrayBuffer");
+    return this.#cachedBody("arrayBuffer");
   }
   blob() {
-    return this.cachedBody("blob");
+    return this.#cachedBody("blob");
   }
   formData() {
-    return this.cachedBody("formData");
+    return this.#cachedBody("formData");
   }
   addValidatedData(target, data) {
     this.#validatedData[target] = data;

package/dist/router/linear-router/router.js

@@ -6,17 +6,17 @@ var splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
 var splitByStarRe = /\*/;
 var LinearRouter = class {
   name = "LinearRouter";
-  routes = [];
+  #routes = [];
   add(method, path, handler) {
     for (let i = 0, paths = checkOptionalParameter(path) || [path], len = paths.length; i < len; i++) {
-      this.routes.push([method, paths[i], handler]);
+      this.#routes.push([method, paths[i], handler]);
     }
   }
   match(method, path) {
     const handlers = [];
     ROUTES_LOOP:
-      for (let i = 0, len = this.routes.length; i < len; i++) {
-        const [routeMethod, routePath, handler] = this.routes[i];
+      for (let i = 0, len = this.#routes.length; i < len; i++) {
+        const [routeMethod, routePath, handler] = this.#routes[i];
         if (routeMethod === method || routeMethod === METHOD_NAME_ALL) {
           if (routePath === "*" || routePath === "/*") {
             handlers.push([handler, emptyParams]);

package/dist/router/pattern-router/router.js

@@ -2,7 +2,7 @@
 import { METHOD_NAME_ALL, UnsupportedPathError } from "../../router.js";
 var PatternRouter = class {
   name = "PatternRouter";
-  routes = [];
+  #routes = [];
   add(method, path, handler) {
     const endsWithWildcard = path[path.length - 1] === "*";
     if (endsWithWildcard) {
@@ -24,12 +24,12 @@ var PatternRouter = class {
     } catch {
       throw new UnsupportedPathError();
     }
-    this.routes.push([re, method, handler]);
+    this.#routes.push([re, method, handler]);
   }
   match(method, path) {
     const handlers = [];
-    for (let i = 0, len = this.routes.length; i < len; i++) {
-      const [pattern, routeMethod, handler] = this.routes[i];
+    for (let i = 0, len = this.#routes.length; i < len; i++) {
+      const [pattern, routeMethod, handler] = this.#routes[i];
       if (routeMethod === method || routeMethod === METHOD_NAME_ALL) {
         const match = pattern.exec(path);
         if (match) {