hono 4.3.11 → 4.4.0

package/dist/cjs/utils/body.js

@@ -22,11 +22,12 @@ __export(body_exports, {
 });
 module.exports = __toCommonJS(body_exports);
 var import_request = require("../request");
-const parseBody = async (request, options = { all: false }) => {
+const parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+  const { all = false, dot = false } = options;
   const headers = request instanceof import_request.HonoRequest ? request.raw.headers : request.headers;
   const contentType = headers.get("Content-Type");
   if (contentType !== null && contentType.startsWith("multipart/form-data") || contentType !== null && contentType.startsWith("application/x-www-form-urlencoded")) {
-    return parseFormData(request, options);
+    return parseFormData(request, { all, dot });
   }
   return {};
 };
@@ -38,7 +39,7 @@ async function parseFormData(request, options) {
   return {};
 }
 function convertFormDataToBodyData(formData, options) {
-  const form = {};
+  const form = /* @__PURE__ */ Object.create(null);
   formData.forEach((value, key) => {
     const shouldParseAllValues = options.all || key.endsWith("[]");
     if (!shouldParseAllValues) {
@@ -47,19 +48,43 @@ function convertFormDataToBodyData(formData, options) {
       handleParsingAllValues(form, key, value);
     }
   });
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes(".");
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value);
+        delete form[key];
+      }
+    });
+  }
   return form;
 }
 const handleParsingAllValues = (form, key, value) => {
-  const formKey = form[key];
-  if (formKey && Array.isArray(formKey)) {
-    ;
-    form[key].push(value);
-  } else if (formKey) {
-    form[key] = [formKey, value];
+  if (form[key] !== void 0) {
+    if (Array.isArray(form[key])) {
+      ;
+      form[key].push(value);
+    } else {
+      form[key] = [form[key], value];
+    }
   } else {
     form[key] = value;
   }
 };
+const handleParsingNestedValues = (form, key, value) => {
+  let nestedForm = form;
+  const keys = key.split(".");
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key2] = value;
+    } else {
+      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+      }
+      nestedForm = nestedForm[key2];
+    }
+  });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   parseBody

package/dist/cjs/utils/jwt/jws.js

@@ -25,7 +25,6 @@ module.exports = __toCommonJS(jws_exports);
 var import_adapter = require("../../helper/adapter");
 var import_encode = require("../encode");
 var import_types = require("./types");
-var import_types2 = require("./types");
 var import_utf8 = require("./utf8");
 async function signing(privateKey, alg, data) {
   const algorithm = getKeyAlgorithm(alg);
@@ -50,7 +49,7 @@ async function importPrivateKey(key, alg) {
     }
     return key;
   }
-  const usages = [import_types2.CryptoKeyUsage.Sign];
+  const usages = [import_types.CryptoKeyUsage.Sign];
   if (typeof key === "object") {
     return await crypto.subtle.importKey("jwk", key, alg, false, usages);
   }
@@ -71,11 +70,11 @@ async function importPublicKey(key, alg) {
   }
   if (typeof key === "string" && key.includes("PRIVATE")) {
     const privateKey = await crypto.subtle.importKey("pkcs8", pemToBinary(key), alg, true, [
-      import_types2.CryptoKeyUsage.Sign
+      import_types.CryptoKeyUsage.Sign
     ]);
     key = await exportPublicJwkFrom(privateKey);
   }
-  const usages = [import_types2.CryptoKeyUsage.Verify];
+  const usages = [import_types.CryptoKeyUsage.Verify];
   if (typeof key === "object") {
     return await crypto.subtle.importKey("jwk", key, alg, false, usages);
   }
@@ -95,7 +94,7 @@ async function exportPublicJwkFrom(privateKey) {
   const { kty } = jwk;
   const { alg, e, n } = jwk;
   const { crv, x, y } = jwk;
-  return { kty, alg, e, n, crv, x, y, key_ops: [import_types2.CryptoKeyUsage.Verify] };
+  return { kty, alg, e, n, crv, x, y, key_ops: [import_types.CryptoKeyUsage.Verify] };
 }
 function getKeyAlgorithm(name) {
   switch (name) {

package/dist/cjs/utils/jwt/jwt.js

@@ -28,7 +28,6 @@ var import_encode = require("../../utils/encode");
 var import_jwa = require("./jwa");
 var import_jws = require("./jws");
 var import_types = require("./types");
-var import_types2 = require("./types");
 var import_utf8 = require("./utf8");
 const encodeJwtPart = (part) => (0, import_encode.encodeBase64Url)(import_utf8.utf8Encoder.encode(JSON.stringify(part))).replace(/=/g, "");
 const encodeSignaturePart = (buf) => (0, import_encode.encodeBase64Url)(buf).replace(/=/g, "");
@@ -51,7 +50,7 @@ const sign = async (payload, privateKey, alg = "HS256") => {
 const verify = async (token, publicKey, alg = "HS256") => {
   const tokenParts = token.split(".");
   if (tokenParts.length !== 3) {
-    throw new import_types2.JwtTokenInvalid(token);
+    throw new import_types.JwtTokenInvalid(token);
   }
   const { header, payload } = decode(token);
   if (!isTokenHeader(header)) {
@@ -59,13 +58,13 @@ const verify = async (token, publicKey, alg = "HS256") => {
   }
   const now = Math.floor(Date.now() / 1e3);
   if (payload.nbf && payload.nbf > now) {
-    throw new import_types2.JwtTokenNotBefore(token);
+    throw new import_types.JwtTokenNotBefore(token);
   }
   if (payload.exp && payload.exp <= now) {
-    throw new import_types2.JwtTokenExpired(token);
+    throw new import_types.JwtTokenExpired(token);
   }
   if (payload.iat && now < payload.iat) {
-    throw new import_types2.JwtTokenIssuedAt(now, payload.iat);
+    throw new import_types.JwtTokenIssuedAt(now, payload.iat);
   }
   const headerPayload = token.substring(0, token.lastIndexOf("."));
   const verified = await (0, import_jws.verifying)(
@@ -75,7 +74,7 @@ const verify = async (token, publicKey, alg = "HS256") => {
     import_utf8.utf8Encoder.encode(headerPayload)
   );
   if (!verified) {
-    throw new import_types2.JwtTokenSignatureMismatched(token);
+    throw new import_types.JwtTokenSignatureMismatched(token);
   }
   return payload;
 };
@@ -89,7 +88,7 @@ const decode = (token) => {
       payload
     };
   } catch (e) {
-    throw new import_types2.JwtTokenInvalid(token);
+    throw new import_types.JwtTokenInvalid(token);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/utils/url.js

@@ -82,10 +82,34 @@ const getPattern = (label) => {
   }
   return null;
 };
+const tryDecodeURI = (str) => {
+  try {
+    return decodeURI(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decodeURI(match);
+      } catch {
+        return match;
+      }
+    });
+  }
+};
 const getPath = (request) => {
   const url = request.url;
-  const queryIndex = url.indexOf("?", 8);
-  return url.slice(url.indexOf("/", 8), queryIndex === -1 ? void 0 : queryIndex);
+  const start = url.indexOf("/", 8);
+  let i = start;
+  for (; i < url.length; i++) {
+    const charCode = url.charCodeAt(i);
+    if (charCode === 37) {
+      const queryIndex = url.indexOf("?", i);
+      const path = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+      return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
+    } else if (charCode === 63) {
+      break;
+    }
+  }
+  return url.slice(start, i);
 };
 const getQueryStrings = (url) => {
   const queryIndex = url.indexOf("?", 8);

package/dist/helper/css/index.js

@@ -3,12 +3,12 @@ import { raw } from "../../helper/html/index.js";
 import { DOM_RENDERER } from "../../jsx/constants.js";
 import { createCssJsxDomObjects } from "../../jsx/dom/css.js";
 import {
-  SELECTOR,
   CLASS_NAME,
-  STYLE_STRING,
-  SELECTORS,
-  PSEUDO_GLOBAL_SELECTOR,
   DEFAULT_STYLE_ID,
+  PSEUDO_GLOBAL_SELECTOR,
+  SELECTOR,
+  SELECTORS,
+  STYLE_STRING,
   cssCommon,
   cxCommon,
   keyframesCommon,

package/dist/helper/html/index.js

@@ -1,5 +1,5 @@
 // src/helper/html/index.ts
-import { escapeToBuffer, stringBufferToString, raw } from "../../utils/html.js";
+import { escapeToBuffer, raw, stringBufferToString } from "../../utils/html.js";
 var html = (strings, ...values) => {
   const buffer = [""];
   for (let i = 0, len = strings.length - 1; i < len; i++) {

package/dist/helper/ssg/ssg.js

@@ -2,8 +2,8 @@
 import { replaceUrlParam } from "../../client/utils.js";
 import { createPool } from "../../utils/concurrent.js";
 import { getExtension } from "../../utils/mime.js";
-import { X_HONO_DISABLE_SSG_HEADER_KEY, SSG_CONTEXT } from "./middleware.js";
-import { joinPaths, dirname, filterStaticGenerateRoutes } from "./utils.js";
+import { SSG_CONTEXT, X_HONO_DISABLE_SSG_HEADER_KEY } from "./middleware.js";
+import { dirname, filterStaticGenerateRoutes, joinPaths } from "./utils.js";
 var DEFAULT_CONCURRENCY = 2;
 var DEFAULT_CONTENT_TYPE = "text/plain";
 var generateFilePath = (routePath, outDir, mimeType, extensionMap) => {
@@ -46,6 +46,52 @@ var determineExtension = (mimeType, userExtensionMap) => {
   }
   return getExtension(mimeType) || "html";
 };
+var combineBeforeRequestHooks = (hooks) => {
+  if (!Array.isArray(hooks)) {
+    return hooks;
+  }
+  return async (req) => {
+    let currentReq = req;
+    for (const hook of hooks) {
+      const result = await hook(currentReq);
+      if (result === false) {
+        return false;
+      }
+      if (result instanceof Request) {
+        currentReq = result;
+      }
+    }
+    return currentReq;
+  };
+};
+var combineAfterResponseHooks = (hooks) => {
+  if (!Array.isArray(hooks)) {
+    return hooks;
+  }
+  return async (res) => {
+    let currentRes = res;
+    for (const hook of hooks) {
+      const result = await hook(currentRes);
+      if (result === false) {
+        return false;
+      }
+      if (result instanceof Response) {
+        currentRes = result;
+      }
+    }
+    return currentRes;
+  };
+};
+var combineAfterGenerateHooks = (hooks) => {
+  if (!Array.isArray(hooks)) {
+    return hooks;
+  }
+  return async (result) => {
+    for (const hook of hooks) {
+      await hook(result);
+    }
+  };
+};
 var fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook, concurrency) {
   const baseURL = "http://localhost";
   const pool = createPool({ concurrency });
@@ -147,10 +193,16 @@ var toSSG = async (app, fs, options) => {
   try {
     const outputDir = options?.dir ?? "./static";
     const concurrency = options?.concurrency ?? DEFAULT_CONCURRENCY;
+    const combinedBeforeRequestHook = combineBeforeRequestHooks(
+      options?.beforeRequestHook || ((req) => req)
+    );
+    const combinedAfterResponseHook = combineAfterResponseHooks(
+      options?.afterResponseHook || ((req) => req)
+    );
     const getInfoGen = fetchRoutesContent(
       app,
-      options?.beforeRequestHook,
-      options?.afterResponseHook,
+      combinedBeforeRequestHook,
+      combinedAfterResponseHook,
       concurrency
     );
     for (const getInfo of getInfoGen) {
@@ -180,10 +232,16 @@ var toSSG = async (app, fs, options) => {
     const errorObj = error instanceof Error ? error : new Error(String(error));
     result = { success: false, files: [], error: errorObj };
   }
-  await options?.afterGenerateHook?.(result);
+  if (options?.afterGenerateHook) {
+    const conbinedAfterGenerateHooks = combineAfterGenerateHooks(options?.afterGenerateHook);
+    await conbinedAfterGenerateHooks(result);
+  }
   return result;
 };
 export {
+  combineAfterGenerateHooks,
+  combineAfterResponseHooks,
+  combineBeforeRequestHooks,
   defaultExtensionMap,
   fetchRoutesContent,
   saveContentToFile,

package/dist/helper/streaming/text.js

@@ -1,6 +1,6 @@
 // src/helper/streaming/text.ts
 import { TEXT_PLAIN } from "../../context.js";
-import { stream } from "./index.js";
+import { stream } from ".//index.js";
 var streamText = (c, cb, onError) => {
   c.header("Content-Type", TEXT_PLAIN);
   c.header("X-Content-Type-Options", "nosniff");

package/dist/hono-base.js

@@ -3,13 +3,9 @@ import { compose } from "./compose.js";
 import { Context } from "./context.js";
 import { HTTPException } from "./http-exception.js";
 import { HonoRequest } from "./request.js";
-import { METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE, METHODS } from "./router.js";
+import { METHODS, METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE } from "./router.js";
 import { getPath, getPathNoStrict, getQueryStrings, mergePath } from "./utils/url.js";
 var COMPOSED_HANDLER = Symbol("composedHandler");
-function defineDynamicClass() {
-  return class {
-  };
-}
 var notFoundHandler = (c) => {
   return c.text("404 Not Found", 404);
 };
@@ -20,14 +16,22 @@ var errorHandler = (err, c) => {
   console.error(err);
   return c.text("Internal Server Error", 500);
 };
-var Hono = class extends defineDynamicClass() {
+var Hono = class {
+  get;
+  post;
+  put;
+  delete;
+  options;
+  patch;
+  all;
+  on;
+  use;
   router;
   getPath;
   _basePath = "/";
   #path = "/";
   routes = [];
   constructor(options = {}) {
-    super();
     const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
     allMethods.forEach((method) => {
       this[method] = (args1, ...args) => {

package/dist/jsx/base.js

@@ -261,6 +261,7 @@ var cloneElement = (element, props, ...children) => {
     ...children
   );
 };
+var reactAPICompatVersion = "18.0.0-hono-jsx";
 export {
   Fragment,
   JSXFragmentNode,
@@ -269,5 +270,6 @@ export {
   isValidElement,
   jsx,
   jsxFn,
-  memo
+  memo,
+  reactAPICompatVersion
 };

package/dist/jsx/dom/client.js

@@ -0,0 +1,44 @@
+// src/jsx/dom/client.ts
+import { useState } from "../hooks/index.js";
+import { buildNode, renderNode } from "./render.js";
+var createRoot = (element, options = {}) => {
+  let setJsxNode = void 0;
+  if (Object.keys(options).length > 0) {
+    console.warn("createRoot options are not supported yet");
+  }
+  return {
+    render(jsxNode) {
+      if (setJsxNode === null) {
+        throw new Error("Cannot update an unmounted root");
+      }
+      if (setJsxNode) {
+        setJsxNode(jsxNode);
+      } else {
+        renderNode(
+          buildNode({
+            tag: () => {
+              const [_jsxNode, _setJsxNode] = useState(jsxNode);
+              setJsxNode = _setJsxNode;
+              return _jsxNode;
+            },
+            props: {}
+          }),
+          element
+        );
+      }
+    },
+    unmount() {
+      setJsxNode?.(null);
+      setJsxNode = null;
+    }
+  };
+};
+var hydrateRoot = (element, reactNode, options = {}) => {
+  const root = createRoot(element, options);
+  root.render(reactNode);
+  return root;
+};
+export {
+  createRoot,
+  hydrateRoot
+};

package/dist/jsx/dom/css.js

@@ -1,11 +1,11 @@
 // src/jsx/dom/css.ts
 import {
-  SELECTOR,
   CLASS_NAME,
-  STYLE_STRING,
-  SELECTORS,
-  PSEUDO_GLOBAL_SELECTOR,
   DEFAULT_STYLE_ID,
+  PSEUDO_GLOBAL_SELECTOR,
+  SELECTOR,
+  SELECTORS,
+  STYLE_STRING,
   cssCommon,
   cxCommon,
   keyframesCommon,

package/dist/jsx/dom/index.js

@@ -1,34 +1,34 @@
 // src/jsx/dom/index.ts
-import { memo, isValidElement } from "../base.js";
+import { isValidElement, memo, reactAPICompatVersion } from "../base.js";
 import { Children } from "../children.js";
 import { useContext } from "../context.js";
 import {
-  useState,
-  useEffect,
-  useRef,
-  useCallback,
-  use,
+  createRef,
+  forwardRef,
   startTransition,
-  useTransition,
-  useDeferredValue,
   startViewTransition,
-  useViewTransition,
-  useMemo,
-  useLayoutEffect,
-  useReducer,
-  useId,
+  use,
+  useCallback,
   useDebugValue,
-  createRef,
-  forwardRef,
+  useDeferredValue,
+  useEffect,
+  useId,
   useImperativeHandle,
-  useSyncExternalStore
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  useViewTransition
 } from "../hooks/index.js";
-import { Suspense, ErrorBoundary } from "./components.js";
+import { ErrorBoundary, Suspense } from "./components.js";
 import { createContext } from "./context.js";
-import { jsx, Fragment } from "./jsx-runtime.js";
-import { flushSync, createPortal } from "./render.js";
+import { Fragment, jsx } from "./jsx-runtime.js";
+import { createPortal, flushSync } from "./render.js";
 import { render } from "./render.js";
-export * from "../types.js";
 var createElement = (tag, props, ...children) => {
   const jsxProps = props ? { ...props } : {};
   if (children.length) {
@@ -53,6 +53,7 @@ var cloneElement = (element, props, ...children) => {
   );
 };
 var dom_default = {
+  version: reactAPICompatVersion,
   useState,
   useEffect,
   useRef,
@@ -65,6 +66,7 @@ var dom_default = {
   useViewTransition,
   useMemo,
   useLayoutEffect,
+  useInsertionEffect,
   useReducer,
   useId,
   useDebugValue,
@@ -112,6 +114,7 @@ export {
   useEffect,
   useId,
   useImperativeHandle,
+  useInsertionEffect,
   useLayoutEffect,
   useMemo,
   useReducer,
@@ -119,5 +122,6 @@ export {
   useState,
   useSyncExternalStore,
   useTransition,
-  useViewTransition
+  useViewTransition,
+  reactAPICompatVersion as version
 };

package/dist/jsx/dom/jsx-dev-runtime.js

@@ -1,29 +1,15 @@
 // src/jsx/dom/jsx-dev-runtime.ts
 import { normalizeIntrinsicElementProps } from "../utils.js";
-var JSXNodeCompatPrototype = {
-  type: {
-    get() {
-      return this.tag;
-    }
-  },
-  ref: {
-    get() {
-      return this.props?.ref;
-    }
-  }
-};
+import { newJSXNode } from "./utils.js";
 var jsxDEV = (tag, props, key) => {
   if (typeof tag === "string") {
     normalizeIntrinsicElementProps(props);
   }
-  return Object.defineProperties(
-    {
-      tag,
-      props,
-      key
-    },
-    JSXNodeCompatPrototype
-  );
+  return newJSXNode({
+    tag,
+    props,
+    key
+  });
 };
 var Fragment = (props) => jsxDEV("", props, void 0);
 export {