hono 3.12.0 → 4.0.0-rc.0

package/dist/adapter/cloudflare-pages/handler.js

@@ -1,7 +1,5 @@
 // src/adapter/cloudflare-pages/handler.ts
-import { Hono } from "../../hono.js";
-var handle = (subApp, path) => (eventContext) => {
-  const app = path ? new Hono().route(path, subApp) : subApp;
+var handle = (app) => (eventContext) => {
   return app.fetch(
     eventContext.request,
     { ...eventContext.env, eventContext },

package/dist/cjs/adapter/cloudflare-pages/handler.js

@@ -22,9 +22,7 @@ __export(handler_exports, {
   serveStatic: () => serveStatic
 });
 module.exports = __toCommonJS(handler_exports);
-var import_hono = require("../../hono");
-const handle = (subApp, path) => (eventContext) => {
-  const app = path ? new import_hono.Hono().route(path, subApp) : subApp;
+const handle = (app) => (eventContext) => {
   return app.fetch(
     eventContext.request,
     { ...eventContext.env, eventContext },

package/dist/cjs/client/client.js

@@ -27,7 +27,7 @@ const createProxy = (callback, path) => {
   const proxy = new Proxy(() => {
   }, {
     get(_obj, key) {
-      if (typeof key !== "string")
+      if (typeof key !== "string" || key === "then")
         return void 0;
       return createProxy(callback, [...path, key]);
     },
@@ -62,14 +62,6 @@ class ClientRequestImpl {
             }
           }
         }
-        if (args.queries) {
-          for (const [k, v] of Object.entries(args.queries)) {
-            for (const v2 of v) {
-              this.queryParams || (this.queryParams = new URLSearchParams());
-              this.queryParams.append(k, v2);
-            }
-          }
-        }
         if (args.form) {
           const form = new FormData();
           for (const [k, v] of Object.entries(args.form)) {

package/dist/cjs/context.js

@@ -40,9 +40,7 @@ __export(context_exports, {
   TEXT_PLAIN: () => TEXT_PLAIN
 });
 module.exports = __toCommonJS(context_exports);
-var import_cookie = require("./utils/cookie");
 var import_html = require("./utils/html");
-var import_stream = require("./utils/stream");
 var _status, _executionCtx, _headers, _preparedHeaders, _res, _isFresh;
 const TEXT_PLAIN = "text/plain; charset=UTF-8";
 class Context {
@@ -167,9 +165,6 @@ class Context {
       __privateGet(this, _preparedHeaders)["content-type"] = "application/json; charset=UTF-8";
       return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
     };
-    this.jsonT = (object, arg, headers) => {
-      return this.json(object, arg, headers);
-    };
     this.html = (html, arg, headers) => {
       __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
       __privateGet(this, _preparedHeaders)["content-type"] = "text/html; charset=UTF-8";
@@ -190,23 +185,6 @@ class Context {
       __privateGet(this, _headers).set("Location", location);
       return this.newResponse(null, status);
     };
-    this.streamText = (cb, arg, headers) => {
-      headers ?? (headers = {});
-      this.header("content-type", TEXT_PLAIN);
-      this.header("x-content-type-options", "nosniff");
-      this.header("transfer-encoding", "chunked");
-      return this.stream(cb, arg, headers);
-    };
-    this.stream = (cb, arg, headers) => {
-      const { readable, writable } = new TransformStream();
-      const stream = new import_stream.StreamingApi(writable, readable);
-      cb(stream).finally(() => stream.close());
-      return typeof arg === "number" ? this.newResponse(stream.responseReadable, arg, headers) : this.newResponse(stream.responseReadable, arg);
-    };
-    this.cookie = (name, value, opt) => {
-      const cookie = (0, import_cookie.serialize)(name, value, opt);
-      this.header("set-cookie", cookie, { append: true });
-    };
     this.notFound = () => {
       return this.notFoundHandler(this);
     };
@@ -251,31 +229,6 @@ class Context {
   get var() {
     return { ...this._var };
   }
-  get runtime() {
-    const global = globalThis;
-    if (global?.Deno !== void 0) {
-      return "deno";
-    }
-    if (global?.Bun !== void 0) {
-      return "bun";
-    }
-    if (typeof global?.WebSocketPair === "function") {
-      return "workerd";
-    }
-    if (typeof global?.EdgeRuntime === "string") {
-      return "edge-light";
-    }
-    if (global?.fastly !== void 0) {
-      return "fastly";
-    }
-    if (global?.__lagon__ !== void 0) {
-      return "lagon";
-    }
-    if (global?.process?.release?.name === "node") {
-      return "node";
-    }
-    return "other";
-  }
 }
 _status = new WeakMap();
 _executionCtx = new WeakMap();

package/dist/cjs/helper/css/index.js

@@ -27,6 +27,7 @@ __export(css_exports, {
 });
 module.exports = __toCommonJS(css_exports);
 var import_html = require("../../helper/html");
+var import_html2 = require("../../utils/html");
 const IS_CSS_CLASS_NAME = Symbol("IS_CSS_CLASS_NAME");
 const STYLE_STRING = Symbol("STYLE_STRING");
 const SELECTORS = Symbol("SELECTORS");
@@ -141,7 +142,20 @@ const createCssContext = ({ id }) => {
       }
       return Promise.resolve(appendStyleScript);
     };
-    const addClassNameToContext = ({ context }) => {
+    const addClassNameToContext = ({ context, phase }) => {
+      if (phase === import_html2.HtmlEscapedCallbackPhase.BeforeDom) {
+        const styleSheets = document.styleSheets;
+        for (let i = 0; i < styleSheets.length; i++) {
+          const sheet = styleSheets[i];
+          if (sheet.ownerNode?.id === id) {
+            if (!sheet.cssRules?.[0]?.cssText?.includes(thisSelector)) {
+              sheet.insertRule(`.${thisSelector}{${thisStyleString}}`);
+              break;
+            }
+          }
+        }
+        return;
+      }
       if (!contextMap.get(context)) {
         contextMap.set(context, [{}, {}]);
       }

package/dist/cjs/helper/streaming/sse.js

@@ -23,7 +23,6 @@ __export(sse_exports, {
 });
 module.exports = __toCommonJS(sse_exports);
 var import_stream = require("../../utils/stream");
-var import__ = require(".");
 class SSEStreamingApi extends import_stream.StreamingApi {
   constructor(writable, readable) {
     super(writable, readable);
@@ -43,22 +42,11 @@ const setSSEHeaders = (context) => {
   context.header("Connection", "keep-alive");
 };
 const streamSSE = (c, cb) => {
-  return (0, import__.stream)(c, async (originalStream) => {
-    const { readable, writable } = new TransformStream();
-    const stream2 = new SSEStreamingApi(writable, readable);
-    originalStream.pipe(stream2.responseReadable).catch((err) => {
-      console.error("Error in stream piping: ", err);
-      stream2.close();
-    });
-    setSSEHeaders(c);
-    try {
-      await cb(stream2);
-    } catch (err) {
-      console.error("Error during streaming: ", err);
-    } finally {
-      await stream2.close();
-    }
-  });
+  const { readable, writable } = new TransformStream();
+  const stream = new SSEStreamingApi(writable, readable);
+  cb(stream).finally(() => stream.close());
+  setSSEHeaders(c);
+  return c.newResponse(stream.responseReadable);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/hono-base.js

@@ -79,13 +79,6 @@ const _Hono = class extends defineDynamicClass() {
       this.notFoundHandler = handler;
       return this;
     };
-    this.head = () => {
-      console.warn("`app.head()` is no longer used. `app.get()` implicitly handles the HEAD method.");
-      return this;
-    };
-    this.handleEvent = (event) => {
-      return this.dispatch(event.request, event, void 0, event.request.method);
-    };
     this.fetch = (request, Env, executionCtx) => {
       return this.dispatch(request, executionCtx, Env, request.method);
     };
@@ -125,11 +118,13 @@ const _Hono = class extends defineDynamicClass() {
     this.on = (method, path, ...handlers) => {
       if (!method)
         return this;
-      __privateSet(this, _path, path);
-      for (const m of [method].flat()) {
-        handlers.map((handler) => {
-          this.addRoute(m.toUpperCase(), __privateGet(this, _path), handler);
-        });
+      for (const p of [path].flat()) {
+        __privateSet(this, _path, p);
+        for (const m of [method].flat()) {
+          handlers.map((handler) => {
+            this.addRoute(m.toUpperCase(), __privateGet(this, _path), handler);
+          });
+        }
       }
       return this;
     };
@@ -137,6 +132,7 @@ const _Hono = class extends defineDynamicClass() {
       if (typeof arg1 === "string") {
         __privateSet(this, _path, arg1);
       } else {
+        __privateSet(this, _path, "*");
         handlers.unshift(arg1);
       }
       handlers.map((handler) => {
@@ -179,14 +175,6 @@ const _Hono = class extends defineDynamicClass() {
     subApp._basePath = (0, import_url.mergePath)(this._basePath, path);
     return subApp;
   }
-  showRoutes() {
-    const length = 8;
-    this.routes.map((route) => {
-      console.log(
-        `\x1B[32m${route.method}\x1B[0m ${" ".repeat(length - route.method.length)} ${route.path}`
-      );
-    });
-  }
   mount(path, applicationHandler, optionHandler) {
     const mergedPath = (0, import_url.mergePath)(this._basePath, path);
     const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
@@ -213,10 +201,6 @@ const _Hono = class extends defineDynamicClass() {
     this.addRoute(import_router.METHOD_NAME_ALL, (0, import_url.mergePath)(path, "*"), handler);
     return this;
   }
-  get routerName() {
-    this.matchRoute("GET", "/");
-    return this.router.name;
-  }
   addRoute(method, path, handler) {
     method = method.toUpperCase();
     path = (0, import_url.mergePath)(this._basePath, path);

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

@@ -0,0 +1,355 @@
+"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 dom_exports = {};
+__export(dom_exports, {
+  UpdatePhase: () => UpdatePhase,
+  invokeUpdate: () => invokeUpdate,
+  nodeMap: () => nodeMap,
+  render: () => render,
+  unloadCallbacks: () => unloadCallbacks,
+  updateCallbacks: () => updateCallbacks,
+  updateStack: () => updateStack
+});
+module.exports = __toCommonJS(dom_exports);
+var import__ = require("..");
+var import_html = require("../../utils/html");
+const nodeMap = /* @__PURE__ */ new WeakMap();
+const updateCallbacks = /* @__PURE__ */ new WeakMap();
+const unloadCallbacks = /* @__PURE__ */ new WeakMap();
+const UpdatePhase = {
+  Updating: 1,
+  UpdateAgain: 2,
+  Done: 3
+};
+const updateStack = [];
+const getContextNode = (container, node, nth) => {
+  const nodes = nodeMap.get(container);
+  if (!nodes) {
+    return;
+  }
+  return (node.key ? nodes.find(([n]) => n.key === node.key) : nodes.find(([n]) => n === node)) || nodes.filter(([n]) => n.tag === node.tag)[nth];
+};
+const removeElement = (element) => {
+  if (!element) {
+    return;
+  }
+  for (const callback of unloadCallbacks.get(element) || []) {
+    callback();
+  }
+  element.remove();
+};
+const invokeUpdate = (updateData) => {
+  const [update, , , getContextNode2] = updateData;
+  updateData[2] = UpdatePhase.Updating;
+  updateStack.push(updateData);
+  do {
+    updateData[1] = 0;
+    update();
+  } while (updateData[2] === UpdatePhase.UpdateAgain);
+  updateData[2] = UpdatePhase.Done;
+  const callbacks = updateCallbacks.get(update);
+  if (callbacks) {
+    updateCallbacks.set(update, []);
+    for (const callback of callbacks) {
+      const unload = callback();
+      if (unload) {
+        const el = getContextNode2()?.[2];
+        if (el) {
+          unloadCallbacks.set(el, [...unloadCallbacks.get(el) || [], unload]);
+        }
+      }
+    }
+  }
+  updateStack.pop();
+};
+const mount = (node, container, nth = 0, replaceElement) => {
+  if (typeof node === "boolean" || node === null || node === void 0) {
+    removeElement(replaceElement);
+    return;
+  }
+  if (Array.isArray(node)) {
+    const tagCounter2 = /* @__PURE__ */ new Map();
+    node.forEach((child) => {
+      const nth2 = tagCounter2.get(child.tag) || 0;
+      tagCounter2.set(child.tag, nth2 + 1);
+      mount(child, container, nth2);
+    });
+    return;
+  }
+  const { tag, props, children } = node;
+  let nodes = nodeMap.get(container);
+  if (typeof tag === "function") {
+    let contextNode = getContextNode(container, node, nth);
+    const update = () => {
+      const res = tag.call(null, {
+        ...props,
+        children: children.length <= 1 ? children[0] : children
+      });
+      if (res instanceof import__.JSXNode) {
+        if (contextNode) {
+          patch(contextNode[1], res, contextNode[2], nth);
+          contextNode[1] = res;
+        } else {
+          contextNode = [node, res, void 0];
+          if (!nodes) {
+            nodes = [];
+            nodeMap.set(container, nodes);
+          }
+          nodes.push(contextNode);
+          mount(res, container, nth, replaceElement);
+        }
+        return;
+      } else if (typeof res === "string") {
+        const el2 = document.createTextNode(res);
+        container.appendChild(el2);
+        return;
+      } else {
+        const wrap = document.createElement("div");
+        wrap.innerHTML = res;
+        wrap.childNodes.forEach((child) => {
+          container.appendChild(child);
+        });
+      }
+    };
+    const updateData = [update, 0, UpdatePhase.Updating, () => contextNode];
+    invokeUpdate(updateData);
+    return;
+  }
+  const el = document.createElement(tag);
+  for (const [key, value] of Object.entries(node.props)) {
+    if (key === "ref") {
+      if (typeof value === "function") {
+        value(el);
+      } else {
+        value.current = el;
+      }
+    } else if (key.startsWith("on")) {
+      const eventName = key.slice(2).toLowerCase();
+      el.addEventListener(eventName, value);
+    } else if (value instanceof Promise) {
+      value.then((v) => {
+        const callbacks = v.callbacks;
+        if (callbacks) {
+          callbacks.forEach(
+            (c) => c({
+              phase: import_html.HtmlEscapedCallbackPhase.BeforeDom,
+              context: {}
+            })
+          );
+        }
+        container.setAttribute(key, v);
+      });
+    } else {
+      el.setAttribute(key, value);
+    }
+  }
+  const tagCounter = /* @__PURE__ */ new Map();
+  for (const child of node.children) {
+    if (typeof child === "string" || typeof child === "number") {
+      el.appendChild(document.createTextNode(child.toString()));
+    } else if (child instanceof import__.JSXNode) {
+      const nth2 = tagCounter.get(child.tag) || 0;
+      tagCounter.set(child.tag, nth2 + 1);
+      mount(child, el, nth2);
+    } else {
+      mount(child, el, nth);
+    }
+  }
+  if (nodes) {
+    for (const node2 of nodes) {
+      node2[2] || (node2[2] = el);
+    }
+  }
+  if (replaceElement) {
+    if (nodes) {
+      nodes = nodes.filter(([, , oldReplaceElement]) => oldReplaceElement !== replaceElement);
+      nodeMap.set(container, nodes);
+    }
+    container.replaceChild(el, replaceElement);
+  } else {
+    container.appendChild(el);
+  }
+};
+const patchChildren = (oldChildren, newChildren, container) => {
+  oldChildren = oldChildren.flat();
+  newChildren = newChildren.flat();
+  if (newChildren.some((child) => child && child.key !== void 0)) {
+    newChildren.forEach((newChild, i) => {
+      const oldChild = oldChildren[i];
+      if (oldChild === void 0) {
+        return;
+      }
+      if (newChild instanceof import__.JSXNode) {
+        if (!newChild.key) {
+          return;
+        }
+        if (oldChild instanceof import__.JSXNode) {
+          if (!oldChild.key || newChild.key === oldChild.key) {
+            return;
+          }
+          const oldChildIndex = oldChildren.findIndex(
+            (child) => child.key === newChild.key
+          );
+          if (oldChildIndex !== -1) {
+            const oldChild2 = oldChildren[oldChildIndex];
+            oldChildren[oldChildIndex] = oldChildren[i];
+            oldChildren[i] = oldChild2;
+            const oldChildNode = container.childNodes[oldChildIndex];
+            container.insertBefore(oldChildNode, container.childNodes[i]);
+            return;
+          }
+        }
+      }
+    });
+  }
+  const length = Math.max(oldChildren.length, newChildren.length);
+  const tagCounter = /* @__PURE__ */ new Map();
+  for (let i = 0, j = 0; i < length; i++, j++) {
+    const newChild = newChildren[i];
+    if (typeof newChild === "boolean" || newChild === null || newChild === void 0) {
+      removeElement(container.childNodes[j]);
+      j--;
+      continue;
+    }
+    let nth = 0;
+    if (newChild instanceof import__.JSXNode) {
+      nth = tagCounter.get(newChild.tag) || 0;
+      tagCounter.set(newChild.tag, nth + 1);
+    }
+    if (oldChildren[i] === void 0) {
+      if (typeof newChildren[i] === "string" || typeof newChildren[i] === "number") {
+        container.appendChild(document.createTextNode(newChildren[i].toString()));
+      } else {
+        mount(newChildren[i], container, nth);
+      }
+    } else {
+      if (typeof newChildren[i] === "string" || typeof newChildren[i] === "number") {
+        container.replaceChild(
+          document.createTextNode(newChildren[i].toString()),
+          container.childNodes[i]
+        );
+      } else {
+        if (Array.isArray(oldChildren[i]) && Array.isArray(newChildren[i])) {
+          patchChildren(oldChildren[i], newChildren[i], container);
+        } else {
+          patch(
+            oldChildren[i],
+            newChildren[i],
+            container.childNodes[j],
+            nth
+          );
+        }
+      }
+    }
+  }
+};
+const patch = (oldNode, newNode, container, nth) => {
+  if (typeof oldNode.tag === "function") {
+    const contextNode = nodeMap.get(container.parentElement)?.find(([n]) => n === oldNode);
+    const replaceElement = contextNode?.[2];
+    if (typeof newNode.tag === "function") {
+      if (oldNode.tag !== newNode.tag) {
+        mount(newNode, container.parentElement, nth, replaceElement);
+        return;
+      }
+      if (contextNode) {
+        const { tag, props, children } = newNode;
+        const res = tag.call(null, {
+          ...props,
+          children: children.length <= 1 ? children[0] : children
+        });
+        patch(contextNode[1], res, contextNode[2], 0);
+        contextNode[1] = res;
+      } else {
+        mount(newNode, container.parentElement, nth, replaceElement);
+      }
+      return;
+    } else {
+      mount(newNode, container.parentElement, nth, replaceElement);
+      return;
+    }
+  }
+  if (oldNode.tag !== newNode.tag) {
+    mount(newNode, container.parentElement, nth, container);
+    return;
+  }
+  for (const [key, value] of Object.entries(newNode.props)) {
+    if (oldNode.props[key] !== value) {
+      if (key === "ref") {
+        if (typeof value === "function") {
+          value(container);
+        } else {
+          value.current = container;
+        }
+      } else if (key.startsWith("on")) {
+        const eventName = key.slice(2).toLowerCase();
+        container.removeEventListener(eventName, oldNode.props[key]);
+        container.addEventListener(eventName, value);
+      } else if (value instanceof Promise) {
+        value.then((v) => {
+          const callbacks = v.callbacks;
+          if (callbacks) {
+            callbacks.forEach(
+              (c) => c({
+                phase: import_html.HtmlEscapedCallbackPhase.BeforeDom,
+                context: {}
+              })
+            );
+          }
+          container.setAttribute(key, v);
+        });
+      } else {
+        container.setAttribute(key, value);
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(oldNode.props)) {
+    if (!(key in newNode.props)) {
+      if (key === "ref") {
+        if (typeof value === "function") {
+          value(null);
+        } else {
+          value.current = null;
+        }
+      } else if (key.startsWith("on")) {
+        const eventName = key.slice(2).toLowerCase();
+        container.removeEventListener(eventName, value);
+      } else {
+        container.removeAttribute(key);
+      }
+    }
+  }
+  patchChildren(oldNode.children, newNode.children, container);
+};
+const render = (node, container) => {
+  if (!(node instanceof import__.JSXNode)) {
+    throw new Error("Invalid node");
+  }
+  mount(node, container);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UpdatePhase,
+  invokeUpdate,
+  nodeMap,
+  render,
+  unloadCallbacks,
+  updateCallbacks,
+  updateStack
+});