@hono/node-server 1.14.1 → 1.14.2

package/dist/index.js

@@ -201,6 +201,74 @@ var newRequest = (incoming, defaultHostname) => {
   return req;
 };
 
+// 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;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    let headers;
+    this.#body = body;
+    if (init instanceof _Response) {
+      const cachedGlobalResponse = init[responseCache];
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse;
+        this[getResponseCache]();
+        return;
+      } else {
+        this.#init = init.#init;
+        headers = new Headers(init.#init.headers);
+      }
+    } else {
+      this.#init = init;
+    }
+    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+      headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
+      this[cacheKey] = [init?.status || 200, body, headers];
+    }
+  }
+  get headers() {
+    const cache = this[cacheKey];
+    if (cache) {
+      if (!(cache[2] instanceof Headers)) {
+        cache[2] = new Headers(cache[2]);
+      }
+      return cache[2];
+    }
+    return this[getResponseCache]().headers;
+  }
+  get status() {
+    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+  }
+  get ok() {
+    const status = this.status;
+    return status >= 200 && status < 300;
+  }
+};
+["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this[getResponseCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+
 // src/utils.ts
 function writeFromReadableStream(stream, writable) {
   if (stream.locked) {
@@ -261,86 +329,6 @@ var buildOutgoingHttpHeaders = (headers) => {
   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;
-  [getResponseCache]() {
-    delete this[cacheKey];
-    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
-  }
-  constructor(body, init) {
-    this.#body = body;
-    if (init instanceof _Response) {
-      const cachedGlobalResponse = init[responseCache];
-      if (cachedGlobalResponse) {
-        this.#init = cachedGlobalResponse;
-        this[getResponseCache]();
-        return;
-      } else {
-        this.#init = init.#init;
-      }
-    } else {
-      this.#init = init;
-    }
-    if (typeof body === "string" || typeof body?.getReader !== "undefined") {
-      let headers = init?.headers || { "content-type": "text/plain; charset=UTF-8" };
-      if (headers instanceof Headers) {
-        headers = buildOutgoingHttpHeaders(headers);
-      }
-      ;
-      this[cacheKey] = [init?.status || 200, body, headers];
-    }
-  }
-};
-[
-  "body",
-  "bodyUsed",
-  "headers",
-  "ok",
-  "redirected",
-  "status",
-  "statusText",
-  "trailers",
-  "type",
-  "url"
-].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    get() {
-      return this[getResponseCache]()[k];
-    }
-  });
-});
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    value: function() {
-      return this[getResponseCache]()[k]();
-    }
-  });
-});
-Object.setPrototypeOf(Response2, GlobalResponse);
-Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-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/utils/response/constants.ts
 var X_ALREADY_SENT = "x-hono-already-sent";
 
@@ -382,14 +370,24 @@ var handleResponseError = (e, outgoing) => {
     outgoing.destroy(err);
   }
 };
-var responseViaCache = (res, outgoing) => {
-  const [status, body, header] = res[cacheKey];
+var responseViaCache = async (res, outgoing) => {
+  let [status, body, header] = res[cacheKey];
+  if (header instanceof Headers) {
+    header = buildOutgoingHttpHeaders(header);
+  }
   if (typeof body === "string") {
     header["Content-Length"] = Buffer.byteLength(body);
-    outgoing.writeHead(status, header);
+  } else if (body instanceof Uint8Array) {
+    header["Content-Length"] = body.byteLength;
+  } else if (body instanceof Blob) {
+    header["Content-Length"] = body.size;
+  }
+  outgoing.writeHead(status, header);
+  if (typeof body === "string" || body instanceof Uint8Array) {
     outgoing.end(body);
+  } else if (body instanceof Blob) {
+    outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
-    outgoing.writeHead(status, header);
     return writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
@@ -415,25 +413,6 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     return responseViaCache(res, outgoing);
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
-  const internalBody = getInternalBody(res);
-  if (internalBody) {
-    const { length, source, stream } = internalBody;
-    if (source instanceof Uint8Array && source.byteLength !== length) {
-    } else {
-      if (length) {
-        resHeaderRecord["content-length"] = length;
-      }
-      outgoing.writeHead(res.status, resHeaderRecord);
-      if (typeof source === "string" || source instanceof Uint8Array) {
-        outgoing.end(source);
-      } else if (source instanceof Blob) {
-        outgoing.end(new Uint8Array(await source.arrayBuffer()));
-      } else {
-        await writeFromReadableStream(stream, outgoing);
-      }
-      return;
-    }
-  }
   if (res.body) {
     const {
       "transfer-encoding": transferEncoding,

package/dist/index.mjs

@@ -162,6 +162,74 @@ var newRequest = (incoming, defaultHostname) => {
   return req;
 };
 
+// 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;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    let headers;
+    this.#body = body;
+    if (init instanceof _Response) {
+      const cachedGlobalResponse = init[responseCache];
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse;
+        this[getResponseCache]();
+        return;
+      } else {
+        this.#init = init.#init;
+        headers = new Headers(init.#init.headers);
+      }
+    } else {
+      this.#init = init;
+    }
+    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+      headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
+      this[cacheKey] = [init?.status || 200, body, headers];
+    }
+  }
+  get headers() {
+    const cache = this[cacheKey];
+    if (cache) {
+      if (!(cache[2] instanceof Headers)) {
+        cache[2] = new Headers(cache[2]);
+      }
+      return cache[2];
+    }
+    return this[getResponseCache]().headers;
+  }
+  get status() {
+    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+  }
+  get ok() {
+    const status = this.status;
+    return status >= 200 && status < 300;
+  }
+};
+["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this[getResponseCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+
 // src/utils.ts
 function writeFromReadableStream(stream, writable) {
   if (stream.locked) {
@@ -222,86 +290,6 @@ var buildOutgoingHttpHeaders = (headers) => {
   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;
-  [getResponseCache]() {
-    delete this[cacheKey];
-    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
-  }
-  constructor(body, init) {
-    this.#body = body;
-    if (init instanceof _Response) {
-      const cachedGlobalResponse = init[responseCache];
-      if (cachedGlobalResponse) {
-        this.#init = cachedGlobalResponse;
-        this[getResponseCache]();
-        return;
-      } else {
-        this.#init = init.#init;
-      }
-    } else {
-      this.#init = init;
-    }
-    if (typeof body === "string" || typeof body?.getReader !== "undefined") {
-      let headers = init?.headers || { "content-type": "text/plain; charset=UTF-8" };
-      if (headers instanceof Headers) {
-        headers = buildOutgoingHttpHeaders(headers);
-      }
-      ;
-      this[cacheKey] = [init?.status || 200, body, headers];
-    }
-  }
-};
-[
-  "body",
-  "bodyUsed",
-  "headers",
-  "ok",
-  "redirected",
-  "status",
-  "statusText",
-  "trailers",
-  "type",
-  "url"
-].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    get() {
-      return this[getResponseCache]()[k];
-    }
-  });
-});
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    value: function() {
-      return this[getResponseCache]()[k]();
-    }
-  });
-});
-Object.setPrototypeOf(Response2, GlobalResponse);
-Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-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/utils/response/constants.ts
 var X_ALREADY_SENT = "x-hono-already-sent";
 
@@ -343,14 +331,24 @@ var handleResponseError = (e, outgoing) => {
     outgoing.destroy(err);
   }
 };
-var responseViaCache = (res, outgoing) => {
-  const [status, body, header] = res[cacheKey];
+var responseViaCache = async (res, outgoing) => {
+  let [status, body, header] = res[cacheKey];
+  if (header instanceof Headers) {
+    header = buildOutgoingHttpHeaders(header);
+  }
   if (typeof body === "string") {
     header["Content-Length"] = Buffer.byteLength(body);
-    outgoing.writeHead(status, header);
+  } else if (body instanceof Uint8Array) {
+    header["Content-Length"] = body.byteLength;
+  } else if (body instanceof Blob) {
+    header["Content-Length"] = body.size;
+  }
+  outgoing.writeHead(status, header);
+  if (typeof body === "string" || body instanceof Uint8Array) {
     outgoing.end(body);
+  } else if (body instanceof Blob) {
+    outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
-    outgoing.writeHead(status, header);
     return writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
@@ -376,25 +374,6 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     return responseViaCache(res, outgoing);
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
-  const internalBody = getInternalBody(res);
-  if (internalBody) {
-    const { length, source, stream } = internalBody;
-    if (source instanceof Uint8Array && source.byteLength !== length) {
-    } else {
-      if (length) {
-        resHeaderRecord["content-length"] = length;
-      }
-      outgoing.writeHead(res.status, resHeaderRecord);
-      if (typeof source === "string" || source instanceof Uint8Array) {
-        outgoing.end(source);
-      } else if (source instanceof Blob) {
-        outgoing.end(new Uint8Array(await source.arrayBuffer()));
-      } else {
-        await writeFromReadableStream(stream, outgoing);
-      }
-      return;
-    }
-  }
   if (res.body) {
     const {
       "transfer-encoding": transferEncoding,

package/dist/listener.js

@@ -195,6 +195,74 @@ var newRequest = (incoming, defaultHostname) => {
   return req;
 };
 
+// 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;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    let headers;
+    this.#body = body;
+    if (init instanceof _Response) {
+      const cachedGlobalResponse = init[responseCache];
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse;
+        this[getResponseCache]();
+        return;
+      } else {
+        this.#init = init.#init;
+        headers = new Headers(init.#init.headers);
+      }
+    } else {
+      this.#init = init;
+    }
+    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+      headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
+      this[cacheKey] = [init?.status || 200, body, headers];
+    }
+  }
+  get headers() {
+    const cache = this[cacheKey];
+    if (cache) {
+      if (!(cache[2] instanceof Headers)) {
+        cache[2] = new Headers(cache[2]);
+      }
+      return cache[2];
+    }
+    return this[getResponseCache]().headers;
+  }
+  get status() {
+    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+  }
+  get ok() {
+    const status = this.status;
+    return status >= 200 && status < 300;
+  }
+};
+["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this[getResponseCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+
 // src/utils.ts
 function writeFromReadableStream(stream, writable) {
   if (stream.locked) {
@@ -255,86 +323,6 @@ var buildOutgoingHttpHeaders = (headers) => {
   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;
-  [getResponseCache]() {
-    delete this[cacheKey];
-    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
-  }
-  constructor(body, init) {
-    this.#body = body;
-    if (init instanceof _Response) {
-      const cachedGlobalResponse = init[responseCache];
-      if (cachedGlobalResponse) {
-        this.#init = cachedGlobalResponse;
-        this[getResponseCache]();
-        return;
-      } else {
-        this.#init = init.#init;
-      }
-    } else {
-      this.#init = init;
-    }
-    if (typeof body === "string" || typeof body?.getReader !== "undefined") {
-      let headers = init?.headers || { "content-type": "text/plain; charset=UTF-8" };
-      if (headers instanceof Headers) {
-        headers = buildOutgoingHttpHeaders(headers);
-      }
-      ;
-      this[cacheKey] = [init?.status || 200, body, headers];
-    }
-  }
-};
-[
-  "body",
-  "bodyUsed",
-  "headers",
-  "ok",
-  "redirected",
-  "status",
-  "statusText",
-  "trailers",
-  "type",
-  "url"
-].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    get() {
-      return this[getResponseCache]()[k];
-    }
-  });
-});
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    value: function() {
-      return this[getResponseCache]()[k]();
-    }
-  });
-});
-Object.setPrototypeOf(Response2, GlobalResponse);
-Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-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/utils/response/constants.ts
 var X_ALREADY_SENT = "x-hono-already-sent";
 
@@ -376,14 +364,24 @@ var handleResponseError = (e, outgoing) => {
     outgoing.destroy(err);
   }
 };
-var responseViaCache = (res, outgoing) => {
-  const [status, body, header] = res[cacheKey];
+var responseViaCache = async (res, outgoing) => {
+  let [status, body, header] = res[cacheKey];
+  if (header instanceof Headers) {
+    header = buildOutgoingHttpHeaders(header);
+  }
   if (typeof body === "string") {
     header["Content-Length"] = Buffer.byteLength(body);
-    outgoing.writeHead(status, header);
+  } else if (body instanceof Uint8Array) {
+    header["Content-Length"] = body.byteLength;
+  } else if (body instanceof Blob) {
+    header["Content-Length"] = body.size;
+  }
+  outgoing.writeHead(status, header);
+  if (typeof body === "string" || body instanceof Uint8Array) {
     outgoing.end(body);
+  } else if (body instanceof Blob) {
+    outgoing.end(new Uint8Array(await body.arrayBuffer()));
   } else {
-    outgoing.writeHead(status, header);
     return writeFromReadableStream(body, outgoing)?.catch(
       (e) => handleResponseError(e, outgoing)
     );
@@ -409,25 +407,6 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
     return responseViaCache(res, outgoing);
   }
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
-  const internalBody = getInternalBody(res);
-  if (internalBody) {
-    const { length, source, stream } = internalBody;
-    if (source instanceof Uint8Array && source.byteLength !== length) {
-    } else {
-      if (length) {
-        resHeaderRecord["content-length"] = length;
-      }
-      outgoing.writeHead(res.status, resHeaderRecord);
-      if (typeof source === "string" || source instanceof Uint8Array) {
-        outgoing.end(source);
-      } else if (source instanceof Blob) {
-        outgoing.end(new Uint8Array(await source.arrayBuffer()));
-      } else {
-        await writeFromReadableStream(stream, outgoing);
-      }
-      return;
-    }
-  }
   if (res.body) {
     const {
       "transfer-encoding": transferEncoding,