@hono/node-server 1.17.0 → 1.18.0

package/dist/vercel.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/node-server",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "Node.js Adapter for Hono",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",