hono 4.1.7 → 4.2.0

package/dist/cjs/helper/ssg/ssg.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ssg_exports = {};
 __export(ssg_exports, {
+  defaultExtensionMap: () => defaultExtensionMap,
   fetchRoutesContent: () => fetchRoutesContent,
   saveContentToFile: () => saveContentToFile,
   toSSG: () => toSSG
@@ -29,8 +30,8 @@ var import_mime = require("../../utils/mime");
 var import_middleware = require("./middleware");
 var import_utils2 = require("./utils");
 const DEFAULT_CONCURRENCY = 2;
-const generateFilePath = (routePath, outDir, mimeType) => {
-  const extension = determineExtension(mimeType);
+const generateFilePath = (routePath, outDir, mimeType, extensionMap) => {
+  const extension = determineExtension(mimeType, extensionMap);
   if (routePath.endsWith(`.${extension}`)) {
     return (0, import_utils2.joinPaths)(outDir, routePath);
   }
@@ -56,17 +57,18 @@ const parseResponseContent = async (response) => {
     );
   }
 };
-const determineExtension = (mimeType) => {
-  switch (mimeType) {
-    case "text/html":
-      return "html";
-    case "text/xml":
-    case "application/xml":
-      return "xml";
-    default: {
-      return (0, import_mime.getExtension)(mimeType) || "html";
-    }
+const defaultExtensionMap = {
+  "text/html": "html",
+  "text/xml": "xml",
+  "application/xml": "xml",
+  "application/yaml": "yaml"
+};
+const determineExtension = (mimeType, userExtensionMap) => {
+  const extensionMap = userExtensionMap || defaultExtensionMap;
+  if (mimeType in extensionMap) {
+    return extensionMap[mimeType];
   }
+  return (0, import_mime.getExtension)(mimeType) || "html";
 };
 const fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook, concurrency) {
   const baseURL = "http://localhost";
@@ -143,13 +145,13 @@ const isDynamicRoute = (path) => {
   return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
 };
 const createdDirs = /* @__PURE__ */ new Set();
-const saveContentToFile = async (data, fsModule, outDir) => {
+const saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
   const awaitedData = await data;
   if (!awaitedData) {
     return;
   }
   const { routePath, content, mimeType } = awaitedData;
-  const filePath = generateFilePath(routePath, outDir, mimeType);
+  const filePath = generateFilePath(routePath, outDir, mimeType, extensionMap);
   const dirPath = (0, import_utils2.dirname)(filePath);
   if (!createdDirs.has(dirPath)) {
     await fsModule.mkdir(dirPath, { recursive: true });
@@ -207,6 +209,7 @@ const toSSG = async (app, fs, options) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  defaultExtensionMap,
   fetchRoutesContent,
   saveContentToFile,
   toSSG

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

@@ -36,6 +36,7 @@ __export(dom_exports, {
   useDebugValue: () => import_hooks.useDebugValue,
   useDeferredValue: () => import_hooks.useDeferredValue,
   useEffect: () => import_hooks.useEffect,
+  useId: () => import_hooks.useId,
   useLayoutEffect: () => import_hooks.useLayoutEffect,
   useMemo: () => import_hooks.useMemo,
   useReducer: () => import_hooks.useReducer,
@@ -86,6 +87,7 @@ var dom_default = {
   useMemo: import_hooks.useMemo,
   useLayoutEffect: import_hooks.useLayoutEffect,
   useReducer: import_hooks.useReducer,
+  useId: import_hooks.useId,
   useDebugValue: import_hooks.useDebugValue,
   Suspense: import_components.Suspense,
   ErrorBoundary: import_components.ErrorBoundary,
@@ -115,6 +117,7 @@ var dom_default = {
   useDebugValue,
   useDeferredValue,
   useEffect,
+  useId,
   useLayoutEffect,
   useMemo,
   useReducer,

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

@@ -26,6 +26,7 @@ __export(hooks_exports, {
   useDebugValue: () => useDebugValue,
   useDeferredValue: () => useDeferredValue,
   useEffect: () => useEffect,
+  useId: () => useId,
   useLayoutEffect: () => useLayoutEffect,
   useMemo: () => useMemo,
   useReducer: () => useReducer,
@@ -294,6 +295,8 @@ const useMemo = (factory, deps) => {
   }
   return memoArray[hookIndex][0];
 };
+let idCounter = 0;
+const useId = () => useMemo(() => `:r${(idCounter++).toString(32)}:`, []);
 const useDebugValue = (_value, _formatter) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -306,6 +309,7 @@ const useDebugValue = (_value, _formatter) => {
   useDebugValue,
   useDeferredValue,
   useEffect,
+  useId,
   useLayoutEffect,
   useMemo,
   useReducer,

package/dist/cjs/jsx/index.js

@@ -37,6 +37,7 @@ __export(jsx_exports, {
   useDebugValue: () => import_hooks.useDebugValue,
   useDeferredValue: () => import_hooks.useDeferredValue,
   useEffect: () => import_hooks.useEffect,
+  useId: () => import_hooks.useId,
   useLayoutEffect: () => import_hooks.useLayoutEffect,
   useMemo: () => import_hooks.useMemo,
   useReducer: () => import_hooks.useReducer,
@@ -66,6 +67,7 @@ var jsx_default = {
   useRef: import_hooks.useRef,
   useCallback: import_hooks.useCallback,
   useReducer: import_hooks.useReducer,
+  useId: import_hooks.useId,
   useDebugValue: import_hooks.useDebugValue,
   use: import_hooks.use,
   startTransition: import_hooks.startTransition,
@@ -96,6 +98,7 @@ var jsx_default = {
   useDebugValue,
   useDeferredValue,
   useEffect,
+  useId,
   useLayoutEffect,
   useMemo,
   useReducer,

package/dist/cjs/middleware/basic-auth/index.js

@@ -43,25 +43,38 @@ const auth = (req) => {
   return { username: userPass[1], password: userPass[2] };
 };
 const basicAuth = (options, ...users) => {
-  if (!options) {
-    throw new Error('basic auth middleware requires options for "username and password"');
+  const usernamePasswordInOptions = "username" in options && "password" in options;
+  const verifyUserInOptions = "verifyUser" in options;
+  if (!(usernamePasswordInOptions || verifyUserInOptions)) {
+    throw new Error(
+      'basic auth middleware requires options for "username and password" or "verifyUser"'
+    );
   }
   if (!options.realm) {
     options.realm = "Secure Area";
   }
-  users.unshift({ username: options.username, password: options.password });
+  if (usernamePasswordInOptions) {
+    users.unshift({ username: options.username, password: options.password });
+  }
   return async function basicAuth2(ctx, next) {
     const requestUser = auth(ctx.req);
     if (requestUser) {
-      for (const user of users) {
-        const [usernameEqual, passwordEqual] = await Promise.all([
-          (0, import_buffer.timingSafeEqual)(user.username, requestUser.username, options.hashFunction),
-          (0, import_buffer.timingSafeEqual)(user.password, requestUser.password, options.hashFunction)
-        ]);
-        if (usernameEqual && passwordEqual) {
+      if (verifyUserInOptions) {
+        if (await options.verifyUser(requestUser.username, requestUser.password, ctx)) {
           await next();
           return;
         }
+      } else {
+        for (const user of users) {
+          const [usernameEqual, passwordEqual] = await Promise.all([
+            (0, import_buffer.timingSafeEqual)(user.username, requestUser.username, options.hashFunction),
+            (0, import_buffer.timingSafeEqual)(user.password, requestUser.password, options.hashFunction)
+          ]);
+          if (usernameEqual && passwordEqual) {
+            await next();
+            return;
+          }
+        }
       }
     }
     const res = new Response("Unauthorized", {

package/dist/cjs/middleware/bearer-auth/index.js

@@ -26,7 +26,7 @@ var import_buffer = require("../../utils/buffer");
 const TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
 const PREFIX = "Bearer";
 const bearerAuth = (options) => {
-  if (!options.token) {
+  if (!("token" in options || "verifyToken" in options)) {
     throw new Error('bearer auth middleware requires options for "token"');
   }
   if (!options.realm) {
@@ -59,7 +59,9 @@ const bearerAuth = (options) => {
         throw new import_http_exception.HTTPException(400, { res });
       } else {
         let equal = false;
-        if (typeof options.token === "string") {
+        if ("verifyToken" in options) {
+          equal = await options.verifyToken(match[1], c);
+        } else if (typeof options.token === "string") {
           equal = await (0, import_buffer.timingSafeEqual)(options.token, match[1], options.hashFunction);
         } else if (Array.isArray(options.token) && options.token.length > 0) {
           for (const token of options.token) {

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

@@ -29,11 +29,17 @@ const cache = (options) => {
   if (options.wait === void 0) {
     options.wait = false;
   }
-  const directives = options.cacheControl?.split(",").map((directive) => directive.toLowerCase());
+  const cacheControlDirectives = options.cacheControl?.split(",").map((directive) => directive.toLowerCase());
+  const varyDirectives = Array.isArray(options.vary) ? options.vary : options.vary?.split(",").map((directive) => directive.trim());
+  if (options.vary?.includes("*")) {
+    throw new Error(
+      'Middleware vary configuration cannot include "*", as it disallows effective caching.'
+    );
+  }
   const addHeader = (c) => {
-    if (directives) {
+    if (cacheControlDirectives) {
       const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0]) ?? [];
-      for (const directive of directives) {
+      for (const directive of cacheControlDirectives) {
         let [name, value] = directive.trim().split("=", 2);
         name = name.toLowerCase();
         if (!existingDirectives.includes(name)) {
@@ -41,6 +47,19 @@ const cache = (options) => {
         }
       }
     }
+    if (varyDirectives) {
+      const existingDirectives = c.res.headers.get("Vary")?.split(",").map((d) => d.trim()) ?? [];
+      const vary = Array.from(
+        new Set(
+          [...existingDirectives, ...varyDirectives].map((directive) => directive.toLowerCase())
+        )
+      ).sort();
+      if (vary.includes("*")) {
+        c.header("Vary", "*");
+      } else {
+        c.header("Vary", vary.join(", "));
+      }
+    }
   };
   return async function cache2(c, next) {
     const key = c.req.url;

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

@@ -45,7 +45,7 @@ const cors = (options) => {
     function set(key, value) {
       c.res.headers.set(key, value);
     }
-    const allowOrigin = findAllowOrigin(c.req.header("origin") || "");
+    const allowOrigin = findAllowOrigin(c.req.header("origin") || "", c);
     if (allowOrigin) {
       set("Access-Control-Allow-Origin", allowOrigin);
     }

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

@@ -41,11 +41,13 @@ const jwt = (options) => {
     if (credentials) {
       const parts = credentials.split(/\s+/);
       if (parts.length !== 2) {
+        const errDescription = "invalid credentials structure";
         throw new import_http_exception.HTTPException(401, {
+          message: errDescription,
           res: unauthorizedResponse({
             ctx,
             error: "invalid_request",
-            errDescription: "invalid credentials structure"
+            errDescription
           })
         });
       } else {
@@ -55,29 +57,33 @@ const jwt = (options) => {
       token = (0, import_cookie.getCookie)(ctx)[options.cookie];
     }
     if (!token) {
+      const errDescription = "no authorization included in request";
       throw new import_http_exception.HTTPException(401, {
+        message: errDescription,
         res: unauthorizedResponse({
           ctx,
           error: "invalid_request",
-          errDescription: "no authorization included in request"
+          errDescription
         })
       });
     }
     let payload;
-    let msg = "";
+    let cause;
     try {
       payload = await import_jwt.Jwt.verify(token, options.secret, options.alg);
     } catch (e) {
-      msg = `${e}`;
+      cause = e;
     }
     if (!payload) {
       throw new import_http_exception.HTTPException(401, {
+        message: "Unauthorized",
         res: unauthorizedResponse({
           ctx,
           error: "invalid_token",
-          statusText: msg,
+          statusText: "Unauthorized",
           errDescription: "token verification failure"
-        })
+        }),
+        cause
       });
     }
     ctx.set("jwtPayload", payload);

package/dist/cjs/middleware/method-override/index.js

@@ -0,0 +1,106 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var method_override_exports = {};
+__export(method_override_exports, {
+  methodOverride: () => methodOverride
+});
+module.exports = __toCommonJS(method_override_exports);
+var import_url = require("url");
+var import_body = require("../../utils/body");
+const DEFAULT_METHOD_FORM_NAME = "_method";
+const methodOverride = (options) => async function methodOverride2(c, next) {
+  if (c.req.method === "GET") {
+    return await next();
+  }
+  const app = options.app;
+  if (!(options.header || options.query)) {
+    const contentType = c.req.header("content-type");
+    const methodFormName = options.form || DEFAULT_METHOD_FORM_NAME;
+    const clonedRequest = c.req.raw.clone();
+    const newRequest = clonedRequest.clone();
+    if (contentType?.startsWith("multipart/form-data")) {
+      const form = await clonedRequest.formData();
+      const method = form.get(methodFormName);
+      if (method) {
+        const newForm = await newRequest.formData();
+        newForm.delete(methodFormName);
+        const newHeaders = new Headers(clonedRequest.headers);
+        newHeaders.delete("content-type");
+        newHeaders.delete("content-length");
+        const request = new Request(c.req.url, {
+          body: newForm,
+          headers: newHeaders,
+          method
+        });
+        return app.fetch(request, c.env, getExecutionCtx(c));
+      }
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      const params = await (0, import_body.parseBody)(clonedRequest);
+      const method = params[methodFormName];
+      if (method) {
+        delete params[methodFormName];
+        const newParams = new import_url.URLSearchParams(params);
+        const request = new Request(newRequest, {
+          body: newParams,
+          method
+        });
+        return app.fetch(request, c.env, getExecutionCtx(c));
+      }
+    }
+  } else if (options.header) {
+    const headerName = options.header;
+    const method = c.req.header(headerName);
+    if (method) {
+      const newHeaders = new Headers(c.req.raw.headers);
+      newHeaders.delete(headerName);
+      const request = new Request(c.req.raw, {
+        headers: newHeaders,
+        method
+      });
+      return app.fetch(request, c.env, getExecutionCtx(c));
+    }
+  } else if (options.query) {
+    const queryName = options.query;
+    const method = c.req.query(queryName);
+    if (method) {
+      const url = new URL(c.req.url);
+      url.searchParams.delete(queryName);
+      const request = new Request(url.toString(), {
+        body: c.req.raw.body,
+        headers: c.req.raw.headers,
+        method
+      });
+      return app.fetch(request, c.env, getExecutionCtx(c));
+    }
+  }
+  await next();
+};
+const getExecutionCtx = (c) => {
+  let executionCtx;
+  try {
+    executionCtx = c.executionCtx;
+  } catch {
+  }
+  return executionCtx;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  methodOverride
+});

package/dist/cjs/middleware/trailing-slash/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trailing_slash_exports = {};
+__export(trailing_slash_exports, {
+  appendTrailingSlash: () => appendTrailingSlash,
+  trimTrailingSlash: () => trimTrailingSlash
+});
+module.exports = __toCommonJS(trailing_slash_exports);
+const trimTrailingSlash = () => {
+  return async function trimTrailingSlash2(c, next) {
+    await next();
+    if (c.res.status === 404 && c.req.method === "GET" && c.req.path !== "/" && c.req.path[c.req.path.length - 1] === "/") {
+      const url = new URL(c.req.url);
+      url.pathname = url.pathname.substring(0, url.pathname.length - 1);
+      c.res = c.redirect(url.toString(), 301);
+    }
+  };
+};
+const appendTrailingSlash = () => {
+  return async function appendTrailingSlash2(c, next) {
+    await next();
+    if (c.res.status === 404 && c.req.method === "GET" && c.req.path[c.req.path.length - 1] !== "/") {
+      const url = new URL(c.req.url);
+      url.pathname += "/";
+      c.res = c.redirect(url.toString(), 301);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendTrailingSlash,
+  trimTrailingSlash
+});

package/dist/cjs/request.js

@@ -88,10 +88,19 @@ class HonoRequest {
     if (cachedBody) {
       return cachedBody;
     }
-    if (bodyCache.arrayBuffer) {
-      return (async () => {
-        return await new Response(bodyCache.arrayBuffer)[key]();
-      })();
+    if (!bodyCache[key]) {
+      for (const keyOfBodyCache of Object.keys(bodyCache)) {
+        if (keyOfBodyCache === "parsedBody") {
+          continue;
+        }
+        return (async () => {
+          let body = await bodyCache[keyOfBodyCache];
+          if (keyOfBodyCache === "json") {
+            body = JSON.stringify(body);
+          }
+          return await new Response(body)[key]();
+        })();
+      }
     }
     return bodyCache[key] = raw[key]();
   };

package/dist/cjs/test-utils/setup-vitest.js

@@ -17,9 +17,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var import_node_crypto = __toESM(require("node:crypto"), 1);
+var nodeCrypto = __toESM(require("node:crypto"), 1);
 var import_vitest = require("vitest");
-import_vitest.vi.stubGlobal("crypto", import_node_crypto.default);
+if (!globalThis.crypto) {
+  import_vitest.vi.stubGlobal("crypto", nodeCrypto);
+  import_vitest.vi.stubGlobal("CryptoKey", nodeCrypto.webcrypto.CryptoKey);
+}
 class MockCache {
   name;
   store;

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

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,17 +15,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var jwt_exports = {};
 __export(jwt_exports, {
   Jwt: () => Jwt
 });
 module.exports = __toCommonJS(jwt_exports);
-var Jwt = __toESM(require("./jwt"), 1);
+var import_jwt = require("./jwt");
+const Jwt = { sign: import_jwt.sign, verify: import_jwt.verify, decode: import_jwt.decode };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Jwt

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

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jwa_exports = {};
+__export(jwa_exports, {
+  AlgorithmTypes: () => AlgorithmTypes
+});
+module.exports = __toCommonJS(jwa_exports);
+var AlgorithmTypes = /* @__PURE__ */ ((AlgorithmTypes2) => {
+  AlgorithmTypes2["HS256"] = "HS256";
+  AlgorithmTypes2["HS384"] = "HS384";
+  AlgorithmTypes2["HS512"] = "HS512";
+  AlgorithmTypes2["RS256"] = "RS256";
+  AlgorithmTypes2["RS384"] = "RS384";
+  AlgorithmTypes2["RS512"] = "RS512";
+  AlgorithmTypes2["PS256"] = "PS256";
+  AlgorithmTypes2["PS384"] = "PS384";
+  AlgorithmTypes2["PS512"] = "PS512";
+  AlgorithmTypes2["ES256"] = "ES256";
+  AlgorithmTypes2["ES384"] = "ES384";
+  AlgorithmTypes2["ES512"] = "ES512";
+  AlgorithmTypes2["EdDSA"] = "EdDSA";
+  return AlgorithmTypes2;
+})(AlgorithmTypes || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlgorithmTypes
+});