@hono/node-server 1.17.0 → 1.18.0

package/dist/index.js

@@ -291,30 +291,24 @@ Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
 
 // src/utils.ts
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    stream.cancel();
-    return;
-  }
-  const reader = stream.getReader();
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  reader.read().then(flow, cancel);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const handleError = () => {
+  };
+  writable.on("error", handleError);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
   return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
+    writable.off("error", handleError);
   });
-  function cancel(error) {
-    reader.cancel(error).catch(() => {
-    });
+  function handleStreamError(error) {
     if (error) {
       writable.destroy(error);
     }
   }
   function onDrain() {
-    reader.read().then(flow, cancel);
+    reader.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
@@ -323,13 +317,21 @@ function writeFromReadableStream(stream, writable) {
       } else if (!writable.write(value)) {
         writable.once("drain", onDrain);
       } else {
-        return reader.read().then(flow, cancel);
+        return reader.read().then(flow, handleStreamError);
       }
     } catch (e) {
-      cancel(e);
+      handleStreamError(e);
     }
   }
 }
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
   if (!(headers instanceof Headers)) {
@@ -371,8 +373,6 @@ global.fetch = (info, init) => {
 
 // src/listener.ts
 var outgoingEnded = Symbol("outgoingEnded");
-var regBuffer = /^no$/i;
-var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
   status: 400
 });
@@ -444,23 +444,48 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   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);
-      flushHeaders(outgoing);
-      await writeFromReadableStream(res.body, outgoing);
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    for (let i = 0; i < 2; i++) {
+      currentReadPromise = reader.read();
+      const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+        console.error(e);
+        done = true;
+      });
+      if (!chunk) {
+        if (i === 1 && resHeaderRecord["transfer-encoding"] !== "chunked") {
+          await new Promise((resolve) => setTimeout(resolve));
+          i--;
+          continue;
+        }
+        break;
+      }
+      currentReadPromise = void 0;
+      if (chunk.value) {
+        values.push(chunk.value);
+      }
+      if (chunk.done) {
+        done = true;
+        break;
+      }
+    }
+    if (done && !("content-length" in resHeaderRecord)) {
+      resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
     } else {
-      const buffer = await res.arrayBuffer();
-      resHeaderRecord["content-length"] = buffer.byteLength;
-      outgoing.writeHead(res.status, resHeaderRecord);
-      outgoing.end(new Uint8Array(buffer));
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
     }
   } else if (resHeaderRecord[X_ALREADY_SENT]) {
   } else {

package/dist/index.mjs

@@ -252,30 +252,24 @@ Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
 
 // src/utils.ts
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    stream.cancel();
-    return;
-  }
-  const reader = stream.getReader();
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  reader.read().then(flow, cancel);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const handleError = () => {
+  };
+  writable.on("error", handleError);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
   return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
+    writable.off("error", handleError);
   });
-  function cancel(error) {
-    reader.cancel(error).catch(() => {
-    });
+  function handleStreamError(error) {
     if (error) {
       writable.destroy(error);
     }
   }
   function onDrain() {
-    reader.read().then(flow, cancel);
+    reader.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
@@ -284,13 +278,21 @@ function writeFromReadableStream(stream, writable) {
       } else if (!writable.write(value)) {
         writable.once("drain", onDrain);
       } else {
-        return reader.read().then(flow, cancel);
+        return reader.read().then(flow, handleStreamError);
       }
     } catch (e) {
-      cancel(e);
+      handleStreamError(e);
     }
   }
 }
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
   if (!(headers instanceof Headers)) {
@@ -332,8 +334,6 @@ global.fetch = (info, init) => {
 
 // src/listener.ts
 var outgoingEnded = Symbol("outgoingEnded");
-var regBuffer = /^no$/i;
-var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
   status: 400
 });
@@ -405,23 +405,48 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   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);
-      flushHeaders(outgoing);
-      await writeFromReadableStream(res.body, outgoing);
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    for (let i = 0; i < 2; i++) {
+      currentReadPromise = reader.read();
+      const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+        console.error(e);
+        done = true;
+      });
+      if (!chunk) {
+        if (i === 1 && resHeaderRecord["transfer-encoding"] !== "chunked") {
+          await new Promise((resolve) => setTimeout(resolve));
+          i--;
+          continue;
+        }
+        break;
+      }
+      currentReadPromise = void 0;
+      if (chunk.value) {
+        values.push(chunk.value);
+      }
+      if (chunk.done) {
+        done = true;
+        break;
+      }
+    }
+    if (done && !("content-length" in resHeaderRecord)) {
+      resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
     } else {
-      const buffer = await res.arrayBuffer();
-      resHeaderRecord["content-length"] = buffer.byteLength;
-      outgoing.writeHead(res.status, resHeaderRecord);
-      outgoing.end(new Uint8Array(buffer));
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
     }
   } else if (resHeaderRecord[X_ALREADY_SENT]) {
   } else {

package/dist/listener.js

@@ -283,30 +283,24 @@ Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
 
 // src/utils.ts
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    stream.cancel();
-    return;
-  }
-  const reader = stream.getReader();
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  reader.read().then(flow, cancel);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const handleError = () => {
+  };
+  writable.on("error", handleError);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
   return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
+    writable.off("error", handleError);
   });
-  function cancel(error) {
-    reader.cancel(error).catch(() => {
-    });
+  function handleStreamError(error) {
     if (error) {
       writable.destroy(error);
     }
   }
   function onDrain() {
-    reader.read().then(flow, cancel);
+    reader.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
@@ -315,13 +309,21 @@ function writeFromReadableStream(stream, writable) {
       } else if (!writable.write(value)) {
         writable.once("drain", onDrain);
       } else {
-        return reader.read().then(flow, cancel);
+        return reader.read().then(flow, handleStreamError);
       }
     } catch (e) {
-      cancel(e);
+      handleStreamError(e);
     }
   }
 }
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
   if (!(headers instanceof Headers)) {
@@ -363,8 +365,6 @@ global.fetch = (info, init) => {
 
 // src/listener.ts
 var outgoingEnded = Symbol("outgoingEnded");
-var regBuffer = /^no$/i;
-var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
   status: 400
 });
@@ -436,23 +436,48 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   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);
-      flushHeaders(outgoing);
-      await writeFromReadableStream(res.body, outgoing);
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    for (let i = 0; i < 2; i++) {
+      currentReadPromise = reader.read();
+      const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+        console.error(e);
+        done = true;
+      });
+      if (!chunk) {
+        if (i === 1 && resHeaderRecord["transfer-encoding"] !== "chunked") {
+          await new Promise((resolve) => setTimeout(resolve));
+          i--;
+          continue;
+        }
+        break;
+      }
+      currentReadPromise = void 0;
+      if (chunk.value) {
+        values.push(chunk.value);
+      }
+      if (chunk.done) {
+        done = true;
+        break;
+      }
+    }
+    if (done && !("content-length" in resHeaderRecord)) {
+      resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
     } else {
-      const buffer = await res.arrayBuffer();
-      resHeaderRecord["content-length"] = buffer.byteLength;
-      outgoing.writeHead(res.status, resHeaderRecord);
-      outgoing.end(new Uint8Array(buffer));
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
     }
   } else if (resHeaderRecord[X_ALREADY_SENT]) {
   } else {

package/dist/listener.mjs

@@ -249,30 +249,24 @@ Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
 
 // src/utils.ts
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    stream.cancel();
-    return;
-  }
-  const reader = stream.getReader();
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  reader.read().then(flow, cancel);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const handleError = () => {
+  };
+  writable.on("error", handleError);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
   return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
+    writable.off("error", handleError);
   });
-  function cancel(error) {
-    reader.cancel(error).catch(() => {
-    });
+  function handleStreamError(error) {
     if (error) {
       writable.destroy(error);
     }
   }
   function onDrain() {
-    reader.read().then(flow, cancel);
+    reader.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
@@ -281,13 +275,21 @@ function writeFromReadableStream(stream, writable) {
       } else if (!writable.write(value)) {
         writable.once("drain", onDrain);
       } else {
-        return reader.read().then(flow, cancel);
+        return reader.read().then(flow, handleStreamError);
       }
     } catch (e) {
-      cancel(e);
+      handleStreamError(e);
     }
   }
 }
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
   if (!(headers instanceof Headers)) {
@@ -329,8 +331,6 @@ global.fetch = (info, init) => {
 
 // src/listener.ts
 var outgoingEnded = Symbol("outgoingEnded");
-var regBuffer = /^no$/i;
-var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
 var handleRequestError = () => new Response(null, {
   status: 400
 });
@@ -402,23 +402,48 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   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);
-      flushHeaders(outgoing);
-      await writeFromReadableStream(res.body, outgoing);
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    for (let i = 0; i < 2; i++) {
+      currentReadPromise = reader.read();
+      const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+        console.error(e);
+        done = true;
+      });
+      if (!chunk) {
+        if (i === 1 && resHeaderRecord["transfer-encoding"] !== "chunked") {
+          await new Promise((resolve) => setTimeout(resolve));
+          i--;
+          continue;
+        }
+        break;
+      }
+      currentReadPromise = void 0;
+      if (chunk.value) {
+        values.push(chunk.value);
+      }
+      if (chunk.done) {
+        done = true;
+        break;
+      }
+    }
+    if (done && !("content-length" in resHeaderRecord)) {
+      resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
     } else {
-      const buffer = await res.arrayBuffer();
-      resHeaderRecord["content-length"] = buffer.byteLength;
-      outgoing.writeHead(res.status, resHeaderRecord);
-      outgoing.end(new Uint8Array(buffer));
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
     }
   } else if (resHeaderRecord[X_ALREADY_SENT]) {
   } else {

package/dist/serve-static.js

@@ -58,37 +58,34 @@ var getStats = (path) => {
   return stats;
 };
 var serveStatic = (options = { root: "" }) => {
-  const root = (0, import_node_path.resolve)(options.root || ".");
+  const root = options.root || "";
   const optionPath = options.path;
   return async (c, next) => {
     if (c.finalized) {
       return next();
     }
     let filename;
-    try {
-      const rawPath = optionPath ?? c.req.path;
-      if (!optionPath) {
-        const decodedPath = decodeURIComponent(rawPath);
-        if (decodedPath.includes("..")) {
-          await options.onNotFound?.(rawPath, c);
-          return next();
+    if (optionPath) {
+      filename = optionPath;
+    } else {
+      try {
+        filename = decodeURIComponent(c.req.path);
+        if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) {
+          throw new Error();
         }
+      } catch {
+        await options.onNotFound?.(c.req.path, c);
+        return next();
       }
-      filename = optionPath ?? decodeURIComponent(c.req.path);
-    } catch {
-      await options.onNotFound?.(c.req.path, c);
-      return next();
     }
-    const requestPath = options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename;
-    let path = optionPath ? options.root ? (0, import_node_path.resolve)((0, import_node_path.join)(root, optionPath)) : optionPath : (0, import_node_path.resolve)((0, import_node_path.join)(root, requestPath));
+    let path = (0, import_node_path.join)(
+      root,
+      !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
+    );
     let stats = getStats(path);
     if (stats && stats.isDirectory()) {
       const indexFile = options.index ?? "index.html";
-      path = (0, import_node_path.resolve)((0, import_node_path.join)(path, indexFile));
-      if (!optionPath && !path.startsWith(root)) {
-        await options.onNotFound?.(path, c);
-        return next();
-      }
+      path = (0, import_node_path.join)(path, indexFile);
       stats = getStats(path);
     }
     if (!stats) {