hono 4.0.10 → 4.1.0

package/dist/helper/ssg/middleware.js

@@ -0,0 +1,29 @@
+// src/helper/ssg/middleware.ts
+var SSG_CONTEXT = "HONO_SSG_CONTEXT";
+var SSG_DISABLED_RESPONSE = new Response("SSG is disabled", { status: 404 });
+var ssgParams = (params) => async (c, next) => {
+  ;
+  c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
+  await next();
+};
+var isSSGContext = (c) => !!c.env?.[SSG_CONTEXT];
+var disableSSG = () => async function disableSSG2(c, next) {
+  if (isSSGContext(c)) {
+    return SSG_DISABLED_RESPONSE;
+  }
+  await next();
+};
+var onlySSG = () => async function onlySSG2(c, next) {
+  if (!isSSGContext(c)) {
+    return c.notFound();
+  }
+  await next();
+};
+export {
+  SSG_CONTEXT,
+  SSG_DISABLED_RESPONSE,
+  disableSSG,
+  isSSGContext,
+  onlySSG,
+  ssgParams
+};

package/dist/helper/ssg/ssg.js

@@ -0,0 +1,187 @@
+// src/helper/ssg/ssg.ts
+import { replaceUrlParam } from "../../client/utils.js";
+import { createPool } from "../../utils/concurrent.js";
+import { getExtension } from "../../utils/mime.js";
+import { SSG_DISABLED_RESPONSE, SSG_CONTEXT } from "./middleware.js";
+import { joinPaths, dirname, filterStaticGenerateRoutes } from "./utils.js";
+var DEFAULT_CONCURRENCY = 2;
+var generateFilePath = (routePath, outDir, mimeType) => {
+  const extension = determineExtension(mimeType);
+  if (routePath.endsWith(`.${extension}`)) {
+    return joinPaths(outDir, routePath);
+  }
+  if (routePath === "/") {
+    return joinPaths(outDir, `index.${extension}`);
+  }
+  if (routePath.endsWith("/")) {
+    return joinPaths(outDir, routePath, `index.${extension}`);
+  }
+  return joinPaths(outDir, `${routePath}.${extension}`);
+};
+var parseResponseContent = async (response) => {
+  const contentType = response.headers.get("Content-Type");
+  try {
+    if (contentType?.includes("text") || contentType?.includes("json")) {
+      return await response.text();
+    } else {
+      return await response.arrayBuffer();
+    }
+  } catch (error) {
+    throw new Error(
+      `Error processing response: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+};
+var determineExtension = (mimeType) => {
+  switch (mimeType) {
+    case "text/html":
+      return "html";
+    case "text/xml":
+    case "application/xml":
+      return "xml";
+    default: {
+      return getExtension(mimeType) || "html";
+    }
+  }
+};
+var fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook, concurrency) {
+  const baseURL = "http://localhost";
+  const pool = createPool({ concurrency });
+  for (const route of filterStaticGenerateRoutes(app)) {
+    const thisRouteBaseURL = new URL(route.path, baseURL).toString();
+    let forGetInfoURLRequest = new Request(thisRouteBaseURL);
+    if (beforeRequestHook) {
+      const maybeRequest = beforeRequestHook(forGetInfoURLRequest);
+      if (!maybeRequest) {
+        continue;
+      }
+      forGetInfoURLRequest = maybeRequest;
+    }
+    yield new Promise(async (resolveGetInfo, rejectGetInfo) => {
+      try {
+        await pool.run(() => app.fetch(forGetInfoURLRequest));
+        if (!forGetInfoURLRequest.ssgParams) {
+          if (isDynamicRoute(route.path)) {
+            resolveGetInfo(void 0);
+            return;
+          }
+          forGetInfoURLRequest.ssgParams = [{}];
+        }
+        const requestInit = {
+          method: forGetInfoURLRequest.method,
+          headers: forGetInfoURLRequest.headers
+        };
+        resolveGetInfo(
+          function* () {
+            for (const param of forGetInfoURLRequest.ssgParams) {
+              yield new Promise(async (resolveReq, rejectReq) => {
+                try {
+                  const replacedUrlParam = replaceUrlParam(route.path, param);
+                  let response = await pool.run(
+                    () => app.request(replacedUrlParam, requestInit, {
+                      [SSG_CONTEXT]: true
+                    })
+                  );
+                  if (response === SSG_DISABLED_RESPONSE) {
+                    resolveReq(void 0);
+                    return;
+                  }
+                  if (afterResponseHook) {
+                    const maybeResponse = afterResponseHook(response);
+                    if (!maybeResponse) {
+                      resolveReq(void 0);
+                      return;
+                    }
+                    response = maybeResponse;
+                  }
+                  const mimeType = response.headers.get("Content-Type")?.split(";")[0] || "text/plain";
+                  const content = await parseResponseContent(response);
+                  resolveReq({
+                    routePath: replacedUrlParam,
+                    mimeType,
+                    content
+                  });
+                } catch (error) {
+                  rejectReq(error);
+                }
+              });
+            }
+          }()
+        );
+      } catch (error) {
+        rejectGetInfo(error);
+      }
+    });
+  }
+};
+var isDynamicRoute = (path) => {
+  return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
+};
+var createdDirs = /* @__PURE__ */ new Set();
+var saveContentToFile = async (data, fsModule, outDir) => {
+  const awaitedData = await data;
+  if (!awaitedData) {
+    return;
+  }
+  const { routePath, content, mimeType } = awaitedData;
+  const filePath = generateFilePath(routePath, outDir, mimeType);
+  const dirPath = dirname(filePath);
+  if (!createdDirs.has(dirPath)) {
+    await fsModule.mkdir(dirPath, { recursive: true });
+    createdDirs.add(dirPath);
+  }
+  if (typeof content === "string") {
+    await fsModule.writeFile(filePath, content);
+  } else if (content instanceof ArrayBuffer) {
+    await fsModule.writeFile(filePath, new Uint8Array(content));
+  }
+  return filePath;
+};
+var toSSG = async (app, fs, options) => {
+  let result = void 0;
+  const getInfoPromises = [];
+  const savePromises = [];
+  try {
+    const outputDir = options?.dir ?? "./static";
+    const concurrency = options?.concurrency ?? DEFAULT_CONCURRENCY;
+    const getInfoGen = fetchRoutesContent(
+      app,
+      options?.beforeRequestHook,
+      options?.afterResponseHook,
+      concurrency
+    );
+    for (const getInfo of getInfoGen) {
+      getInfoPromises.push(
+        getInfo.then((getContentGen) => {
+          if (!getContentGen) {
+            return;
+          }
+          for (const content of getContentGen) {
+            savePromises.push(saveContentToFile(content, fs, outputDir).catch((e) => e));
+          }
+        })
+      );
+    }
+    await Promise.all(getInfoPromises);
+    const files = [];
+    for (const savePromise of savePromises) {
+      const fileOrError = await savePromise;
+      if (typeof fileOrError === "string") {
+        files.push(fileOrError);
+      } else if (fileOrError) {
+        throw fileOrError;
+      }
+    }
+    result = { success: true, files };
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    result = { success: false, files: [], error: errorObj };
+  }
+  await options?.afterGenerateHook?.(result);
+  return result;
+};
+export {
+  fetchRoutesContent,
+  saveContentToFile,
+  toSSG
+};

package/dist/helper/websocket/index.js

@@ -0,0 +1,9 @@
+// src/helper/websocket/index.ts
+var createWSMessageEvent = (source) => {
+  return new MessageEvent("message", {
+    data: source
+  });
+};
+export {
+  createWSMessageEvent
+};

package/dist/helper.js

@@ -9,3 +9,4 @@ export * from "./helper/streaming/index.js";
 export * from "./helper/testing/index.js";
 export * from "./helper/dev/index.js";
 export * from "./adapter/deno/ssg.js";
+export * from "./adapter/deno/websocket.js";

package/dist/hono-base.js

@@ -1,22 +1,3 @@
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-
 // src/hono-base.ts
 import { compose } from "./compose.js";
 import { Context } from "./context.js";
@@ -39,54 +20,25 @@ var errorHandler = (err, c) => {
   console.error(err);
   return c.text("Internal Server Error", 500);
 };
-var _path;
-var _Hono = class extends defineDynamicClass() {
+var Hono = class extends defineDynamicClass() {
+  router;
+  getPath;
+  _basePath = "/";
+  #path = "/";
+  routes = [];
   constructor(options = {}) {
     super();
-    this._basePath = "/";
-    __privateAdd(this, _path, "/");
-    this.routes = [];
-    this.notFoundHandler = notFoundHandler;
-    this.errorHandler = errorHandler;
-    this.onError = (handler) => {
-      this.errorHandler = handler;
-      return this;
-    };
-    this.notFound = (handler) => {
-      this.notFoundHandler = handler;
-      return this;
-    };
-    this.fetch = (request, Env, executionCtx) => {
-      return this.dispatch(request, executionCtx, Env, request.method);
-    };
-    this.request = (input, requestInit, Env, executionCtx) => {
-      if (input instanceof Request) {
-        if (requestInit !== void 0) {
-          input = new Request(input, requestInit);
-        }
-        return this.fetch(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);
-    };
-    this.fire = () => {
-      addEventListener("fetch", (event) => {
-        event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
-      });
-    };
     const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
     allMethods.map((method) => {
       this[method] = (args1, ...args) => {
         if (typeof args1 === "string") {
-          __privateSet(this, _path, args1);
+          this.#path = args1;
         } else {
-          this.addRoute(method, __privateGet(this, _path), args1);
+          this.addRoute(method, this.#path, args1);
         }
         args.map((handler) => {
           if (typeof handler !== "string") {
-            this.addRoute(method, __privateGet(this, _path), handler);
+            this.addRoute(method, this.#path, handler);
           }
         });
         return this;
@@ -97,10 +49,10 @@ var _Hono = class extends defineDynamicClass() {
         return this;
       }
       for (const p of [path].flat()) {
-        __privateSet(this, _path, p);
+        this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
-            this.addRoute(m.toUpperCase(), __privateGet(this, _path), handler);
+            this.addRoute(m.toUpperCase(), this.#path, handler);
           });
         }
       }
@@ -108,13 +60,13 @@ var _Hono = class extends defineDynamicClass() {
     };
     this.use = (arg1, ...handlers) => {
       if (typeof arg1 === "string") {
-        __privateSet(this, _path, arg1);
+        this.#path = arg1;
       } else {
-        __privateSet(this, _path, "*");
+        this.#path = "*";
         handlers.unshift(arg1);
       }
       handlers.map((handler) => {
-        this.addRoute(METHOD_NAME_ALL, __privateGet(this, _path), handler);
+        this.addRoute(METHOD_NAME_ALL, this.#path, handler);
       });
       return this;
     };
@@ -124,13 +76,15 @@ var _Hono = class extends defineDynamicClass() {
     this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict;
   }
   clone() {
-    const clone = new _Hono({
+    const clone = new Hono({
       router: this.router,
       getPath: this.getPath
     });
     clone.routes = this.routes;
     return clone;
   }
+  notFoundHandler = notFoundHandler;
+  errorHandler = errorHandler;
   route(path, app) {
     const subApp = this.basePath(path);
     if (!app) {
@@ -153,6 +107,14 @@ var _Hono = class extends defineDynamicClass() {
     subApp._basePath = mergePath(this._basePath, path);
     return subApp;
   }
+  onError = (handler) => {
+    this.errorHandler = handler;
+    return this;
+  };
+  notFound = (handler) => {
+    this.notFoundHandler = handler;
+    return this;
+  };
   mount(path, applicationHandler, optionHandler) {
     const mergedPath = mergePath(this._basePath, path);
     const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
@@ -235,9 +197,27 @@ var _Hono = class extends defineDynamicClass() {
       }
     })();
   }
+  fetch = (request, Env, executionCtx) => {
+    return this.dispatch(request, executionCtx, Env, 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);
+    }
+    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);
+  };
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
+    });
+  };
 };
-var Hono = _Hono;
-_path = new WeakMap();
 export {
   COMPOSED_HANDLER,
   Hono as HonoBase

package/dist/http-exception.js

@@ -1,7 +1,9 @@
 // src/http-exception.ts
 var HTTPException = class extends Error {
+  res;
+  status;
   constructor(status = 500, options) {
-    super(options?.message);
+    super(options?.message, { cause: options?.cause });
     this.res = options?.res;
     this.status = status;
   }

package/dist/jsx/base.js

@@ -67,8 +67,13 @@ var childrenToStringToBuffer = (children, buffer) => {
   }
 };
 var JSXNode = class {
+  tag;
+  props;
+  key;
+  children;
+  isEscaped = true;
+  localContexts;
   constructor(tag, props, children) {
-    this.isEscaped = true;
     this.tag = tag;
     this.props = props;
     this.children = children;
@@ -220,7 +225,7 @@ var memo = (component, propsAreEqual = shallowEqual) => {
       computed = void 0;
     }
     prevProps = props;
-    return computed || (computed = component(props));
+    return computed ||= component(props);
   };
 };
 var Fragment = ({

package/dist/jsx/components.js

@@ -42,7 +42,7 @@ var ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
     }
   }
   if (resArray.some((res) => res instanceof Promise)) {
-    fallbackStr || (fallbackStr = await fallback?.toString());
+    fallbackStr ||= await fallback?.toString();
     const index = errorBoundaryCounter++;
     const replaceRe = RegExp(`(<template id="E:${index}"></template>.*?)(.*?)(<!--E:${index}-->)`);
     const caught = false;

package/dist/jsx/dom/index.js

@@ -1,4 +1,6 @@
 // src/jsx/dom/index.ts
+import { memo, isValidElement } from "../base.js";
+import { useContext } from "../context.js";
 import {
   useState,
   useEffect,
@@ -11,14 +13,23 @@ import {
   startViewTransition,
   useViewTransition,
   useMemo,
-  useLayoutEffect
+  useLayoutEffect,
+  useReducer,
+  useDebugValue
 } from "../hooks/index.js";
-import { render } from "./render.js";
 import { Suspense, ErrorBoundary } from "./components.js";
-import { useContext } from "../context.js";
 import { createContext } from "./context.js";
-import { memo, isValidElement } from "../base.js";
 import { jsx } from "./jsx-runtime.js";
+import { render } from "./render.js";
+var createElement = (tag, props, ...children) => {
+  const jsxProps = { ...props, children };
+  let key = void 0;
+  if ("key" in jsxProps) {
+    key = jsxProps.key;
+    delete jsxProps.key;
+  }
+  return jsx(tag, jsxProps, key);
+};
 var cloneElement = (element, props, ...children) => {
   return jsx(
     element.tag,
@@ -30,12 +41,39 @@ var cloneElement = (element, props, ...children) => {
     element.key
   );
 };
+var dom_default = {
+  useState,
+  useEffect,
+  useRef,
+  useCallback,
+  use,
+  startTransition,
+  useTransition,
+  useDeferredValue,
+  startViewTransition,
+  useViewTransition,
+  useMemo,
+  useLayoutEffect,
+  useReducer,
+  useDebugValue,
+  Suspense,
+  ErrorBoundary,
+  createContext,
+  useContext,
+  memo,
+  isValidElement,
+  createElement,
+  cloneElement
+};
 export {
   ErrorBoundary,
   Suspense,
   cloneElement,
   createContext,
+  createElement,
+  dom_default as default,
   isValidElement,
+  createElement as jsx,
   memo,
   render,
   startTransition,
@@ -43,10 +81,12 @@ export {
   use,
   useCallback,
   useContext,
+  useDebugValue,
   useDeferredValue,
   useEffect,
   useLayoutEffect,
   useMemo,
+  useReducer,
   useRef,
   useState,
   useTransition,

package/dist/jsx/dom/render.js

@@ -23,7 +23,7 @@ var getEventSpec = (key) => {
   return void 0;
 };
 var applyProps = (container, attributes, oldAttributes) => {
-  attributes || (attributes = {});
+  attributes ||= {};
   for (const [key, value] of Object.entries(attributes)) {
     if (!oldAttributes || oldAttributes[key] !== value) {
       const eventSpec = getEventSpec(key);
@@ -205,9 +205,9 @@ var applyNodeObject = (node, container) => {
         child.e.textContent = child[0];
       }
       child[1] = false;
-      el = child.e || (child.e = document.createTextNode(child[0]));
+      el = child.e ||= document.createTextNode(child[0]);
     } else {
-      el = child.e || (child.e = child.n ? document.createElementNS(child.n, child.tag) : document.createElement(child.tag));
+      el = child.e ||= child.n ? document.createElementNS(child.n, child.tag) : document.createElement(child.tag);
       applyProps(el, child.props, child.pP);
       applyNode(child, el);
     }
@@ -226,10 +226,10 @@ var build = (context, node, topLevelErrorHandlerNode, children) => {
     return;
   }
   let errorHandler;
-  children || (children = typeof node.tag == "function" ? invokeTag(context, node) : node.children);
+  children ||= typeof node.tag == "function" ? invokeTag(context, node) : node.children;
   if (children[0]?.tag === "") {
     errorHandler = children[0][DOM_ERROR_HANDLER];
-    topLevelErrorHandlerNode || (topLevelErrorHandlerNode = node);
+    topLevelErrorHandlerNode ||= node;
   }
   const oldVChildren = node.vC ? [...node.vC] : [];
   const vChildren = [];
@@ -318,7 +318,7 @@ var buildNode = (node) => {
       if (ns) {
         ;
         node.n = ns;
-        nameSpaceContext || (nameSpaceContext = createContext(""));
+        nameSpaceContext ||= createContext("");
         node.children = [
           {
             tag: nameSpaceContext.Provider,