@hono/node-server 1.6.0 → 1.8.0

package/dist/response.js

@@ -22,7 +22,8 @@ var response_exports = {};
 __export(response_exports, {
   GlobalResponse: () => GlobalResponse,
   Response: () => Response,
-  cacheKey: () => cacheKey
+  cacheKey: () => cacheKey,
+  getInternalBody: () => getInternalBody
 });
 module.exports = __toCommonJS(response_exports);
 
@@ -40,18 +41,19 @@ var buildOutgoingHttpHeaders = (headers) => {
   if (cookies.length > 0) {
     res["set-cookie"] = cookies;
   }
-  res["content-type"] ??= "text/plain;charset=UTF-8";
+  res["content-type"] ??= "text/plain; charset=UTF-8";
   return res;
 };
 
 // src/response.ts
 var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
 var cacheKey = Symbol("cache");
 var GlobalResponse = global.Response;
 var Response = class _Response {
   #body;
   #init;
-  get cache() {
+  [getResponseCache]() {
     delete this[cacheKey];
     return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
   }
@@ -61,7 +63,7 @@ var Response = class _Response {
       const cachedGlobalResponse = init[responseCache];
       if (cachedGlobalResponse) {
         this.#init = cachedGlobalResponse;
-        this.cache;
+        this[getResponseCache]();
         return;
       } else {
         this.#init = init.#init;
@@ -70,7 +72,7 @@ var Response = class _Response {
       this.#init = init;
     }
     if (typeof body === "string" || body instanceof ReadableStream) {
-      let headers = init?.headers || { "content-type": "text/plain;charset=UTF-8" };
+      let headers = init?.headers || { "content-type": "text/plain; charset=UTF-8" };
       if (headers instanceof Headers) {
         headers = buildOutgoingHttpHeaders(headers);
       }
@@ -93,14 +95,14 @@ var Response = class _Response {
 ].forEach((k) => {
   Object.defineProperty(Response.prototype, k, {
     get() {
-      return this.cache[k];
+      return this[getResponseCache]()[k];
     }
   });
 });
 ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
   Object.defineProperty(Response.prototype, k, {
     value: function() {
-      return this.cache[k]();
+      return this[getResponseCache]()[k]();
     }
   });
 });
@@ -109,9 +111,26 @@ Object.setPrototypeOf(Response.prototype, GlobalResponse.prototype);
 Object.defineProperty(global, "Response", {
   value: Response
 });
+var stateKey = Reflect.ownKeys(new GlobalResponse()).find(
+  (k) => typeof k === "symbol" && k.toString() === "Symbol(state)"
+);
+if (!stateKey) {
+  console.warn("Failed to find Response internal state key");
+}
+function getInternalBody(response) {
+  if (!stateKey) {
+    return;
+  }
+  if (response instanceof Response) {
+    response = response[getResponseCache]();
+  }
+  const state = response[stateKey];
+  return state && state.body || void 0;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GlobalResponse,
   Response,
-  cacheKey
+  cacheKey,
+  getInternalBody
 });

package/dist/response.mjs

@@ -12,18 +12,19 @@ var buildOutgoingHttpHeaders = (headers) => {
   if (cookies.length > 0) {
     res["set-cookie"] = cookies;
   }
-  res["content-type"] ??= "text/plain;charset=UTF-8";
+  res["content-type"] ??= "text/plain; charset=UTF-8";
   return res;
 };
 
 // src/response.ts
 var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
 var cacheKey = Symbol("cache");
 var GlobalResponse = global.Response;
 var Response = class _Response {
   #body;
   #init;
-  get cache() {
+  [getResponseCache]() {
     delete this[cacheKey];
     return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
   }
@@ -33,7 +34,7 @@ var Response = class _Response {
       const cachedGlobalResponse = init[responseCache];
       if (cachedGlobalResponse) {
         this.#init = cachedGlobalResponse;
-        this.cache;
+        this[getResponseCache]();
         return;
       } else {
         this.#init = init.#init;
@@ -42,7 +43,7 @@ var Response = class _Response {
       this.#init = init;
     }
     if (typeof body === "string" || body instanceof ReadableStream) {
-      let headers = init?.headers || { "content-type": "text/plain;charset=UTF-8" };
+      let headers = init?.headers || { "content-type": "text/plain; charset=UTF-8" };
       if (headers instanceof Headers) {
         headers = buildOutgoingHttpHeaders(headers);
       }
@@ -65,14 +66,14 @@ var Response = class _Response {
 ].forEach((k) => {
   Object.defineProperty(Response.prototype, k, {
     get() {
-      return this.cache[k];
+      return this[getResponseCache]()[k];
     }
   });
 });
 ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
   Object.defineProperty(Response.prototype, k, {
     value: function() {
-      return this.cache[k]();
+      return this[getResponseCache]()[k]();
     }
   });
 });
@@ -81,8 +82,25 @@ Object.setPrototypeOf(Response.prototype, GlobalResponse.prototype);
 Object.defineProperty(global, "Response", {
   value: Response
 });
+var stateKey = Reflect.ownKeys(new GlobalResponse()).find(
+  (k) => typeof k === "symbol" && k.toString() === "Symbol(state)"
+);
+if (!stateKey) {
+  console.warn("Failed to find Response internal state key");
+}
+function getInternalBody(response) {
+  if (!stateKey) {
+    return;
+  }
+  if (response instanceof Response) {
+    response = response[getResponseCache]();
+  }
+  const state = response[stateKey];
+  return state && state.body || void 0;
+}
 export {
   GlobalResponse,
   Response,
-  cacheKey
+  cacheKey,
+  getInternalBody
 };

package/dist/serve-static.js

@@ -28,8 +28,9 @@ var import_fs = require("fs");
 // node_modules/hono/dist/utils/filepath.js
 var getFilePath = (options) => {
   let filename = options.filename;
-  if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename))
+  if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) {
     return;
+  }
   let root = options.root || "";
   const defaultDocument = options.defaultDocument || "index.html";
   if (filename.endsWith("/")) {
@@ -46,34 +47,27 @@ var getFilePath = (options) => {
 };
 
 // node_modules/hono/dist/utils/mime.js
-var getMimeType = (filename) => {
+var getMimeType = (filename, mimes = baseMimes) => {
   const regexp = /\.([a-zA-Z0-9]+?)$/;
   const match = filename.match(regexp);
-  if (!match)
+  if (!match) {
     return;
+  }
   let mimeType = mimes[match[1]];
   if (mimeType && mimeType.startsWith("text") || mimeType === "application/json") {
     mimeType += "; charset=utf-8";
   }
   return mimeType;
 };
-var mimes = {
+var baseMimes = {
   aac: "audio/aac",
-  abw: "application/x-abiword",
-  arc: "application/x-freearc",
   avi: "video/x-msvideo",
   avif: "image/avif",
   av1: "video/av1",
-  azw: "application/vnd.amazon.ebook",
   bin: "application/octet-stream",
   bmp: "image/bmp",
-  bz: "application/x-bzip",
-  bz2: "application/x-bzip2",
-  csh: "application/x-csh",
   css: "text/css",
   csv: "text/csv",
-  doc: "application/msword",
-  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
   eot: "application/vnd.ms-fontobject",
   epub: "application/epub+zip",
   gif: "image/gif",
@@ -82,7 +76,6 @@ var mimes = {
   html: "text/html",
   ico: "image/x-icon",
   ics: "text/calendar",
-  jar: "application/java-archive",
   jpeg: "image/jpeg",
   jpg: "image/jpeg",
   js: "text/javascript",
@@ -95,31 +88,20 @@ var mimes = {
   mp3: "audio/mpeg",
   mp4: "video/mp4",
   mpeg: "video/mpeg",
-  mpkg: "application/vnd.apple.installer+xml",
-  odp: "application/vnd.oasis.opendocument.presentation",
-  ods: "application/vnd.oasis.opendocument.spreadsheet",
-  odt: "application/vnd.oasis.opendocument.text",
   oga: "audio/ogg",
   ogv: "video/ogg",
   ogx: "application/ogg",
   opus: "audio/opus",
   otf: "font/otf",
   pdf: "application/pdf",
-  php: "application/php",
   png: "image/png",
-  ppt: "application/vnd.ms-powerpoint",
-  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
   rtf: "application/rtf",
-  sh: "application/x-sh",
   svg: "image/svg+xml",
-  swf: "application/x-shockwave-flash",
-  tar: "application/x-tar",
   tif: "image/tiff",
   tiff: "image/tiff",
   ts: "video/mp2t",
   ttf: "font/ttf",
   txt: "text/plain",
-  vsd: "application/vnd.visio",
   wasm: "application/wasm",
   webm: "video/webm",
   weba: "audio/webm",
@@ -127,14 +109,10 @@ var mimes = {
   woff: "font/woff",
   woff2: "font/woff2",
   xhtml: "application/xhtml+xml",
-  xls: "application/vnd.ms-excel",
-  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
   xml: "application/xml",
-  xul: "application/vnd.mozilla.xul+xml",
   zip: "application/zip",
   "3gp": "video/3gpp",
   "3g2": "video/3gpp2",
-  "7z": "application/x-7z-compressed",
   gltf: "model/gltf+json",
   glb: "model/gltf-binary"
 };

package/dist/serve-static.mjs

@@ -4,8 +4,9 @@ import { createReadStream, existsSync, lstatSync } from "fs";
 // node_modules/hono/dist/utils/filepath.js
 var getFilePath = (options) => {
   let filename = options.filename;
-  if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename))
+  if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) {
     return;
+  }
   let root = options.root || "";
   const defaultDocument = options.defaultDocument || "index.html";
   if (filename.endsWith("/")) {
@@ -22,34 +23,27 @@ var getFilePath = (options) => {
 };
 
 // node_modules/hono/dist/utils/mime.js
-var getMimeType = (filename) => {
+var getMimeType = (filename, mimes = baseMimes) => {
   const regexp = /\.([a-zA-Z0-9]+?)$/;
   const match = filename.match(regexp);
-  if (!match)
+  if (!match) {
     return;
+  }
   let mimeType = mimes[match[1]];
   if (mimeType && mimeType.startsWith("text") || mimeType === "application/json") {
     mimeType += "; charset=utf-8";
   }
   return mimeType;
 };
-var mimes = {
+var baseMimes = {
   aac: "audio/aac",
-  abw: "application/x-abiword",
-  arc: "application/x-freearc",
   avi: "video/x-msvideo",
   avif: "image/avif",
   av1: "video/av1",
-  azw: "application/vnd.amazon.ebook",
   bin: "application/octet-stream",
   bmp: "image/bmp",
-  bz: "application/x-bzip",
-  bz2: "application/x-bzip2",
-  csh: "application/x-csh",
   css: "text/css",
   csv: "text/csv",
-  doc: "application/msword",
-  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
   eot: "application/vnd.ms-fontobject",
   epub: "application/epub+zip",
   gif: "image/gif",
@@ -58,7 +52,6 @@ var mimes = {
   html: "text/html",
   ico: "image/x-icon",
   ics: "text/calendar",
-  jar: "application/java-archive",
   jpeg: "image/jpeg",
   jpg: "image/jpeg",
   js: "text/javascript",
@@ -71,31 +64,20 @@ var mimes = {
   mp3: "audio/mpeg",
   mp4: "video/mp4",
   mpeg: "video/mpeg",
-  mpkg: "application/vnd.apple.installer+xml",
-  odp: "application/vnd.oasis.opendocument.presentation",
-  ods: "application/vnd.oasis.opendocument.spreadsheet",
-  odt: "application/vnd.oasis.opendocument.text",
   oga: "audio/ogg",
   ogv: "video/ogg",
   ogx: "application/ogg",
   opus: "audio/opus",
   otf: "font/otf",
   pdf: "application/pdf",
-  php: "application/php",
   png: "image/png",
-  ppt: "application/vnd.ms-powerpoint",
-  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
   rtf: "application/rtf",
-  sh: "application/x-sh",
   svg: "image/svg+xml",
-  swf: "application/x-shockwave-flash",
-  tar: "application/x-tar",
   tif: "image/tiff",
   tiff: "image/tiff",
   ts: "video/mp2t",
   ttf: "font/ttf",
   txt: "text/plain",
-  vsd: "application/vnd.visio",
   wasm: "application/wasm",
   webm: "video/webm",
   weba: "audio/webm",
@@ -103,14 +85,10 @@ var mimes = {
   woff: "font/woff",
   woff2: "font/woff2",
   xhtml: "application/xhtml+xml",
-  xls: "application/vnd.ms-excel",
-  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
   xml: "application/xml",
-  xul: "application/vnd.mozilla.xul+xml",
   zip: "application/zip",
   "3gp": "video/3gpp",
   "3g2": "video/3gpp2",
-  "7z": "application/x-7z-compressed",
   gltf: "model/gltf+json",
   glb: "model/gltf-binary"
 };

package/dist/server.js

@@ -55,7 +55,7 @@ var Request = class extends GlobalRequest {
 Object.defineProperty(global, "Request", {
   value: Request
 });
-var newRequestFromIncoming = (method, url, incoming) => {
+var newRequestFromIncoming = (method, url, incoming, abortController) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
   for (let i = 0; i < rawHeaders.length; i += 2) {
@@ -67,7 +67,8 @@ var newRequestFromIncoming = (method, url, incoming) => {
   }
   const init = {
     method,
-    headers: headerRecord
+    headers: headerRecord,
+    signal: abortController.signal
   };
   if (!(method === "GET" || method === "HEAD")) {
     init.body = import_node_stream.Readable.toWeb(incoming);
@@ -78,6 +79,8 @@ var getRequestCache = Symbol("getRequestCache");
 var requestCache = Symbol("requestCache");
 var incomingKey = Symbol("incomingKey");
 var urlKey = Symbol("urlKey");
+var abortControllerKey = Symbol("abortControllerKey");
+var getAbortController = Symbol("getAbortController");
 var requestPrototype = {
   get method() {
     return this[incomingKey].method || "GET";
@@ -85,11 +88,17 @@ var requestPrototype = {
   get url() {
     return this[urlKey];
   },
+  [getAbortController]() {
+    this[getRequestCache]();
+    return this[abortControllerKey];
+  },
   [getRequestCache]() {
+    this[abortControllerKey] ||= new AbortController();
     return this[requestCache] ||= newRequestFromIncoming(
       this.method,
       this[urlKey],
-      this[incomingKey]
+      this[incomingKey],
+      this[abortControllerKey]
     );
   }
 };
@@ -183,18 +192,19 @@ var buildOutgoingHttpHeaders = (headers) => {
   if (cookies.length > 0) {
     res["set-cookie"] = cookies;
   }
-  res["content-type"] ??= "text/plain;charset=UTF-8";
+  res["content-type"] ??= "text/plain; charset=UTF-8";
   return res;
 };
 
 // src/response.ts
 var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
 var cacheKey = Symbol("cache");
 var GlobalResponse = global.Response;
 var Response2 = class _Response {
   #body;
   #init;
-  get cache() {
+  [getResponseCache]() {
     delete this[cacheKey];
     return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
   }
@@ -204,7 +214,7 @@ var Response2 = class _Response {
       const cachedGlobalResponse = init[responseCache];
       if (cachedGlobalResponse) {
         this.#init = cachedGlobalResponse;
-        this.cache;
+        this[getResponseCache]();
         return;
       } else {
         this.#init = init.#init;
@@ -213,7 +223,7 @@ var Response2 = class _Response {
       this.#init = init;
     }
     if (typeof body === "string" || body instanceof ReadableStream) {
-      let headers = init?.headers || { "content-type": "text/plain;charset=UTF-8" };
+      let headers = init?.headers || { "content-type": "text/plain; charset=UTF-8" };
       if (headers instanceof Headers) {
         headers = buildOutgoingHttpHeaders(headers);
       }
@@ -236,14 +246,14 @@ var Response2 = class _Response {
 ].forEach((k) => {
   Object.defineProperty(Response2.prototype, k, {
     get() {
-      return this.cache[k];
+      return this[getResponseCache]()[k];
     }
   });
 });
 ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
   Object.defineProperty(Response2.prototype, k, {
     value: function() {
-      return this.cache[k]();
+      return this[getResponseCache]()[k]();
     }
   });
 });
@@ -252,6 +262,22 @@ Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
 Object.defineProperty(global, "Response", {
   value: Response2
 });
+var stateKey = Reflect.ownKeys(new GlobalResponse()).find(
+  (k) => typeof k === "symbol" && k.toString() === "Symbol(state)"
+);
+if (!stateKey) {
+  console.warn("Failed to find Response internal state key");
+}
+function getInternalBody(response) {
+  if (!stateKey) {
+    return;
+  }
+  if (response instanceof Response2) {
+    response = response[getResponseCache]();
+  }
+  const state = response[stateKey];
+  return state && state.body || void 0;
+}
 
 // src/globals.ts
 var import_node_crypto = __toESM(require("crypto"));
@@ -301,48 +327,71 @@ var responseViaCache = (res, outgoing) => {
     );
   }
 };
-var responseViaResponseObject = async (res, outgoing) => {
-  res = res instanceof Promise ? await res.catch(handleFetchError) : res;
-  try {
-    const isCached = cacheKey in res;
-    if (isCached) {
-      return responseViaCache(res, outgoing);
+var responseViaResponseObject = async (res, outgoing, options = {}) => {
+  if (res instanceof Promise) {
+    if (options.errorHandler) {
+      try {
+        res = await res;
+      } catch (err) {
+        const errRes = await options.errorHandler(err);
+        if (!errRes) {
+          return;
+        }
+        res = errRes;
+      }
+    } else {
+      res = await res.catch(handleFetchError);
     }
-  } catch (e) {
-    return handleResponseError(e, outgoing);
+  }
+  if (cacheKey in res) {
+    return responseViaCache(res, outgoing);
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
-  if (res.body) {
-    try {
-      const {
-        "transfer-encoding": transferEncoding,
-        "content-encoding": contentEncoding,
-        "content-length": contentLength,
-        "x-accel-buffering": accelBuffering,
-        "content-type": contentType
-      } = resHeaderRecord;
-      if (transferEncoding || contentEncoding || contentLength || // nginx buffering variant
-      accelBuffering && regBuffer.test(accelBuffering) || !regContentType.test(contentType)) {
-        outgoing.writeHead(res.status, resHeaderRecord);
-        await writeFromReadableStream(res.body, outgoing);
-      } else {
-        const buffer = await res.arrayBuffer();
-        resHeaderRecord["content-length"] = buffer.byteLength;
-        outgoing.writeHead(res.status, resHeaderRecord);
-        outgoing.end(new Uint8Array(buffer));
-      }
-    } catch (e) {
-      handleResponseError(e, outgoing);
+  const internalBody = getInternalBody(res);
+  if (internalBody) {
+    if (internalBody.length) {
+      resHeaderRecord["content-length"] = internalBody.length;
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    if (typeof internalBody.source === "string" || internalBody.source instanceof Uint8Array) {
+      outgoing.end(internalBody.source);
+    } else if (internalBody.source instanceof Blob) {
+      outgoing.end(new Uint8Array(await internalBody.source.arrayBuffer()));
+    } else {
+      await writeFromReadableStream(internalBody.stream, outgoing);
+    }
+  } else if (res.body) {
+    const {
+      "transfer-encoding": transferEncoding,
+      "content-encoding": contentEncoding,
+      "content-length": contentLength,
+      "x-accel-buffering": accelBuffering,
+      "content-type": contentType
+    } = resHeaderRecord;
+    if (transferEncoding || contentEncoding || contentLength || // nginx buffering variant
+    accelBuffering && regBuffer.test(accelBuffering) || !regContentType.test(contentType)) {
+      outgoing.writeHead(res.status, resHeaderRecord);
+      await writeFromReadableStream(res.body, outgoing);
+    } else {
+      const buffer = await res.arrayBuffer();
+      resHeaderRecord["content-length"] = buffer.byteLength;
+      outgoing.writeHead(res.status, resHeaderRecord);
+      outgoing.end(new Uint8Array(buffer));
     }
   } else {
     outgoing.writeHead(res.status, resHeaderRecord);
     outgoing.end();
   }
 };
-var getRequestListener = (fetchCallback) => {
-  return (incoming, outgoing) => {
+var getRequestListener = (fetchCallback, options = {}) => {
+  return async (incoming, outgoing) => {
     let res;
     const req = newRequest(incoming);
+    outgoing.on("close", () => {
+      if (incoming.destroyed) {
+        req[getAbortController]().abort();
+      }
+    });
     try {
       res = fetchCallback(req, { incoming, outgoing });
       if (cacheKey in res) {
@@ -350,12 +399,23 @@ var getRequestListener = (fetchCallback) => {
       }
     } catch (e) {
       if (!res) {
-        res = handleFetchError(e);
+        if (options.errorHandler) {
+          res = await options.errorHandler(e);
+          if (!res) {
+            return;
+          }
+        } else {
+          res = handleFetchError(e);
+        }
       } else {
         return handleResponseError(e, outgoing);
       }
     }
-    return responseViaResponseObject(res, outgoing);
+    try {
+      return responseViaResponseObject(res, outgoing, options);
+    } catch (e) {
+      return handleResponseError(e, outgoing);
+    }
   };
 };