hono 4.0.10 → 4.1.0

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

@@ -23,10 +23,8 @@ __export(router_exports, {
 module.exports = __toCommonJS(router_exports);
 var import_router = require("../../router");
 class PatternRouter {
-  constructor() {
-    this.name = "PatternRouter";
-    this.routes = [];
-  }
+  name = "PatternRouter";
+  routes = [];
   add(method, path, handler) {
     const endsWithWildcard = path[path.length - 1] === "*";
     if (endsWithWildcard) {

package/dist/cjs/router/reg-exp-router/node.js

@@ -46,9 +46,9 @@ function compareKey(a, b) {
   return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
 class Node {
-  constructor() {
-    this.children = {};
-  }
+  index;
+  varIndex;
+  children = {};
   insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
     if (tokens.length === 0) {
       if (this.index !== void 0) {

package/dist/cjs/router/reg-exp-router/router.js

@@ -29,9 +29,9 @@ const emptyParam = [];
 const nullMatcher = [/^$/, [], {}];
 let wildcardRegExpCache = {};
 function buildWildcardRegExp(path) {
-  return wildcardRegExpCache[path] ?? (wildcardRegExpCache[path] = new RegExp(
+  return wildcardRegExpCache[path] ??= new RegExp(
     path === "*" ? "" : `^${path.replace(/\/\*/, "(?:|/.*)")}$`
-  ));
+  );
 }
 function clearWildcardRegExpCache() {
   wildcardRegExpCache = {};
@@ -105,13 +105,14 @@ function findMiddleware(middleware, path) {
   return void 0;
 }
 class RegExpRouter {
+  name = "RegExpRouter";
+  middleware;
+  routes;
   constructor() {
-    this.name = "RegExpRouter";
     this.middleware = { [import_router.METHOD_NAME_ALL]: {} };
     this.routes = { [import_router.METHOD_NAME_ALL]: {} };
   }
   add(method, path, handler) {
-    var _a;
     const { middleware, routes } = this;
     if (!middleware || !routes) {
       throw new Error(import_router.MESSAGE_MATCHER_IS_ALREADY_BUILT);
@@ -133,11 +134,10 @@ class RegExpRouter {
       const re = buildWildcardRegExp(path);
       if (method === import_router.METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          var _a2;
-          (_a2 = middleware[m])[path] || (_a2[path] = findMiddleware(middleware[m], path) || findMiddleware(middleware[import_router.METHOD_NAME_ALL], path) || []);
+          middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[import_router.METHOD_NAME_ALL], path) || [];
         });
       } else {
-        (_a = middleware[method])[path] || (_a[path] = findMiddleware(middleware[method], path) || findMiddleware(middleware[import_router.METHOD_NAME_ALL], path) || []);
+        middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[import_router.METHOD_NAME_ALL], path) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === import_router.METHOD_NAME_ALL || method === m) {
@@ -159,11 +159,10 @@ class RegExpRouter {
     for (let i = 0, len = paths.length; i < len; i++) {
       const path2 = paths[i];
       Object.keys(routes).forEach((m) => {
-        var _a2;
         if (method === import_router.METHOD_NAME_ALL || method === m) {
-          (_a2 = routes[m])[path2] || (_a2[path2] = [
+          routes[m][path2] ||= [
             ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[import_router.METHOD_NAME_ALL], path2) || []
-          ]);
+          ];
           routes[m][path2].push([handler, paramCount - len + i + 1]);
         }
       });
@@ -190,7 +189,7 @@ class RegExpRouter {
   buildAllMatchers() {
     const matchers = {};
     [...Object.keys(this.routes), ...Object.keys(this.middleware)].forEach((method) => {
-      matchers[method] || (matchers[method] = this.buildMatcher(method));
+      matchers[method] ||= this.buildMatcher(method);
     });
     this.middleware = this.routes = void 0;
     return matchers;
@@ -201,7 +200,7 @@ class RegExpRouter {
     [this.middleware, this.routes].forEach((r) => {
       const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
       if (ownRoute.length !== 0) {
-        hasOwnRoute || (hasOwnRoute = true);
+        hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== import_router.METHOD_NAME_ALL) {
         routes.push(

package/dist/cjs/router/reg-exp-router/trie.js

@@ -23,10 +23,8 @@ __export(trie_exports, {
 module.exports = __toCommonJS(trie_exports);
 var import_node = require("./node");
 class Trie {
-  constructor() {
-    this.context = { varIndex: 0 };
-    this.root = new import_node.Node();
-  }
+  context = { varIndex: 0 };
+  root = new import_node.Node();
   insert(path, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];

package/dist/cjs/router/smart-router/router.js

@@ -23,10 +23,10 @@ __export(router_exports, {
 module.exports = __toCommonJS(router_exports);
 var import_router = require("../../router");
 class SmartRouter {
+  name = "SmartRouter";
+  routers = [];
+  routes = [];
   constructor(init) {
-    this.name = "SmartRouter";
-    this.routers = [];
-    this.routes = [];
     Object.assign(this, init);
   }
   add(method, path, handler) {

package/dist/cjs/router/trie-router/node.js

@@ -24,9 +24,13 @@ module.exports = __toCommonJS(node_exports);
 var import_router = require("../../router");
 var import_url = require("../../utils/url");
 class Node {
+  methods;
+  children;
+  patterns;
+  order = 0;
+  name;
+  params = {};
   constructor(method, handler, children) {
-    this.order = 0;
-    this.params = {};
     this.children = children || {};
     this.methods = [];
     this.name = "";

package/dist/cjs/router/trie-router/router.js

@@ -24,8 +24,9 @@ module.exports = __toCommonJS(router_exports);
 var import_url = require("../../utils/url");
 var import_node = require("./node");
 class TrieRouter {
+  name = "TrieRouter";
+  node;
   constructor() {
-    this.name = "TrieRouter";
     this.node = new import_node.Node();
   }
   add(method, path, handler) {

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

@@ -21,6 +21,8 @@ var import_node_crypto = __toESM(require("node:crypto"), 1);
 var import_vitest = require("vitest");
 import_vitest.vi.stubGlobal("crypto", import_node_crypto.default);
 class MockCache {
+  name;
+  store;
   constructor(name, store) {
     this.name = name;
     this.store = store;

package/dist/cjs/utils/color.js

@@ -0,0 +1,32 @@
+"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 color_exports = {};
+__export(color_exports, {
+  getColorEnabled: () => getColorEnabled
+});
+module.exports = __toCommonJS(color_exports);
+function getColorEnabled() {
+  const { process, Deno } = globalThis;
+  const isNoColor = typeof process !== "undefined" ? "NO_COLOR" in process?.env : typeof Deno?.noColor === "boolean" ? Deno.noColor : false;
+  return !isNoColor;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getColorEnabled
+});

package/dist/cjs/utils/concurrent.js

@@ -0,0 +1,62 @@
+"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 concurrent_exports = {};
+__export(concurrent_exports, {
+  createPool: () => createPool
+});
+module.exports = __toCommonJS(concurrent_exports);
+const DEFAULT_CONCURRENCY = 1024;
+const createPool = ({
+  concurrency,
+  interval
+} = {}) => {
+  concurrency ||= DEFAULT_CONCURRENCY;
+  if (concurrency === Infinity) {
+    return {
+      run: async (fn) => fn()
+    };
+  }
+  const pool = /* @__PURE__ */ new Set();
+  const run = async (fn, promise, resolve) => {
+    if (pool.size >= concurrency) {
+      promise ||= new Promise((r) => resolve = r);
+      setTimeout(() => run(fn, promise, resolve));
+      return promise;
+    }
+    const marker = {};
+    pool.add(marker);
+    const result = await fn();
+    if (interval) {
+      setTimeout(() => pool.delete(marker), interval);
+    } else {
+      pool.delete(marker);
+    }
+    if (resolve) {
+      resolve(result);
+      return promise;
+    } else {
+      return result;
+    }
+  };
+  return { run };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPool
+});

package/dist/cjs/utils/cookie.js

@@ -91,16 +91,40 @@ const parseSigned = async (cookie, secret, name) => {
 };
 const _serialize = (name, value, opt = {}) => {
   let cookie = `${name}=${value}`;
+  if (name.startsWith("__Secure-") && !opt.secure) {
+    throw new Error("__Secure- Cookie must have Secure attributes");
+  }
+  if (name.startsWith("__Host-")) {
+    if (!opt.secure) {
+      throw new Error("__Host- Cookie must have Secure attributes");
+    }
+    if (opt.path !== "/") {
+      throw new Error('__Host- Cookie must have Path attributes with "/"');
+    }
+    if (opt.domain) {
+      throw new Error("__Host- Cookie must not have Domain attributes");
+    }
+  }
   if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+    if (opt.maxAge > 3456e4) {
+      throw new Error(
+        "Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration."
+      );
+    }
     cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
   }
-  if (opt.domain) {
+  if (opt.domain && opt.prefix !== "host") {
     cookie += `; Domain=${opt.domain}`;
   }
   if (opt.path) {
     cookie += `; Path=${opt.path}`;
   }
   if (opt.expires) {
+    if (opt.expires.getTime() - Date.now() > 3456e7) {
+      throw new Error(
+        "Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future."
+      );
+    }
     cookie += `; Expires=${opt.expires.toUTCString()}`;
   }
   if (opt.httpOnly) {
@@ -113,6 +137,9 @@ const _serialize = (name, value, opt = {}) => {
     cookie += `; SameSite=${opt.sameSite}`;
   }
   if (opt.partitioned) {
+    if (!opt.secure) {
+      throw new Error("Partitioned Cookie must have Secure attributes");
+    }
     cookie += "; Partitioned";
   }
   return cookie;

package/dist/cjs/utils/stream.js

@@ -22,8 +22,12 @@ __export(stream_exports, {
 });
 module.exports = __toCommonJS(stream_exports);
 class StreamingApi {
+  writer;
+  encoder;
+  writable;
+  abortSubscribers = [];
+  responseReadable;
   constructor(writable, _readable) {
-    this.abortSubscribers = [];
     this.writable = writable;
     this.writer = writable.getWriter();
     this.encoder = new TextEncoder();

package/dist/cjs/utils/url.js

@@ -176,7 +176,7 @@ const _getQueryParam = (url, key, multiple) => {
     }
   }
   const results = {};
-  encoded ?? (encoded = /[%+]/.test(url));
+  encoded ??= /[%+]/.test(url);
   let keyIndex = url.indexOf("?", 8);
   while (keyIndex !== -1) {
     const nextKeyIndex = url.indexOf("&", keyIndex + 1);
@@ -211,7 +211,7 @@ const _getQueryParam = (url, key, multiple) => {
       ;
       results[name].push(value);
     } else {
-      results[name] ?? (results[name] = value);
+      results[name] ??= value;
     }
   }
   return key ? results[key] : results;

package/dist/client/client.js

@@ -20,76 +20,79 @@ var createProxy = (callback, path) => {
   return proxy;
 };
 var ClientRequestImpl = class {
+  url;
+  method;
+  queryParams = void 0;
+  pathParams = {};
+  rBody;
+  cType = void 0;
   constructor(url, method) {
-    this.queryParams = void 0;
-    this.pathParams = {};
-    this.cType = void 0;
-    this.fetch = (args, opt) => {
-      if (args) {
-        if (args.query) {
-          for (const [k, v] of Object.entries(args.query)) {
-            if (v === void 0) {
-              continue;
-            }
-            this.queryParams || (this.queryParams = new URLSearchParams());
-            if (Array.isArray(v)) {
-              for (const v2 of v) {
-                this.queryParams.append(k, v2);
-              }
-            } else {
-              this.queryParams.set(k, v);
-            }
+    this.url = url;
+    this.method = method;
+  }
+  fetch = (args, opt) => {
+    if (args) {
+      if (args.query) {
+        for (const [k, v] of Object.entries(args.query)) {
+          if (v === void 0) {
+            continue;
           }
-        }
-        if (args.form) {
-          const form = new FormData();
-          for (const [k, v] of Object.entries(args.form)) {
-            form.append(k, v);
+          this.queryParams ||= new URLSearchParams();
+          if (Array.isArray(v)) {
+            for (const v2 of v) {
+              this.queryParams.append(k, v2);
+            }
+          } else {
+            this.queryParams.set(k, v);
           }
-          this.rBody = form;
-        }
-        if (args.json) {
-          this.rBody = JSON.stringify(args.json);
-          this.cType = "application/json";
-        }
-        if (args.param) {
-          this.pathParams = args.param;
         }
       }
-      let methodUpperCase = this.method.toUpperCase();
-      let setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
-      const headerValues = {
-        ...args?.header ?? {},
-        ...opt?.headers ? opt.headers : {}
-      };
-      if (args?.cookie) {
-        const cookies = [];
-        for (const [key, value] of Object.entries(args.cookie)) {
-          cookies.push(serialize(key, value, { path: "/" }));
+      if (args.form) {
+        const form = new FormData();
+        for (const [k, v] of Object.entries(args.form)) {
+          form.append(k, v);
         }
-        headerValues["Cookie"] = cookies.join(",");
+        this.rBody = form;
       }
-      if (this.cType) {
-        headerValues["Content-Type"] = this.cType;
+      if (args.json) {
+        this.rBody = JSON.stringify(args.json);
+        this.cType = "application/json";
       }
-      const headers = new Headers(headerValues ?? void 0);
-      let url = this.url;
-      url = removeIndexString(url);
-      url = replaceUrlParam(url, this.pathParams);
-      if (this.queryParams) {
-        url = url + "?" + this.queryParams.toString();
+      if (args.param) {
+        this.pathParams = args.param;
       }
-      methodUpperCase = this.method.toUpperCase();
-      setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
-      return (opt?.fetch || fetch)(url, {
-        body: setBody ? this.rBody : void 0,
-        method: methodUpperCase,
-        headers
-      });
+    }
+    let methodUpperCase = this.method.toUpperCase();
+    let setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+    const headerValues = {
+      ...args?.header ?? {},
+      ...opt?.headers ? opt.headers : {}
     };
-    this.url = url;
-    this.method = method;
-  }
+    if (args?.cookie) {
+      const cookies = [];
+      for (const [key, value] of Object.entries(args.cookie)) {
+        cookies.push(serialize(key, value, { path: "/" }));
+      }
+      headerValues["Cookie"] = cookies.join(",");
+    }
+    if (this.cType) {
+      headerValues["Content-Type"] = this.cType;
+    }
+    const headers = new Headers(headerValues ?? void 0);
+    let url = this.url;
+    url = removeIndexString(url);
+    url = replaceUrlParam(url, this.pathParams);
+    if (this.queryParams) {
+      url = url + "?" + this.queryParams.toString();
+    }
+    methodUpperCase = this.method.toUpperCase();
+    setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+    return (opt?.fetch || fetch)(url, {
+      body: setBody ? this.rBody : void 0,
+      method: methodUpperCase,
+      headers
+    });
+  };
 };
 var hc = (baseUrl, options) => createProxy((opts) => {
   const parts = [...opts.path];
@@ -108,9 +111,13 @@ var hc = (baseUrl, options) => createProxy((opts) => {
     }
     return new URL(url);
   }
+  if (method === "ws") {
+    const targetUrl = opts.args[0] && opts.args[0].param ? replaceUrlParam(url, opts.args[0].param) : url;
+    return new WebSocket(targetUrl);
+  }
   const req = new ClientRequestImpl(url, method);
   if (method) {
-    options ?? (options = {});
+    options ??= {};
     const args = deepMerge(options, { ...opts.args[1] ?? {} });
     return req.fetch(opts.args[0], args);
   }