elit 3.6.6 → 3.6.7

package/dist/http.mjs

@@ -6,23 +6,88 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/http.ts
-import { EventEmitter } from "events";
+// src/server/http/agent.ts
+var Agent = class {
+  constructor(options) {
+    this.options = options;
+  }
+};
 
-// src/runtime.ts
-var runtime = (() => {
-  if (typeof Deno !== "undefined") return "deno";
-  if (typeof Bun !== "undefined") return "bun";
-  return "node";
-})();
-var isNode = runtime === "node";
-var isBun = runtime === "bun";
-var isDeno = runtime === "deno";
+// src/server/http/client-request.ts
+import { EventEmitter } from "events";
 
-// src/http.ts
+// src/server/http/utils.ts
 function queueCallback(callback) {
   if (callback) queueMicrotask(callback);
 }
+function getRequestPath(url) {
+  if (!url) return "";
+  try {
+    const urlObj = new URL(url);
+    return urlObj.pathname + urlObj.search;
+  } catch {
+    return url;
+  }
+}
+function headersToRecord(headers) {
+  const result = /* @__PURE__ */ Object.create(null);
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function headersToRawHeaders(headers) {
+  const rawHeaders = [];
+  headers.forEach((value, key) => {
+    rawHeaders.push(key, value);
+  });
+  return rawHeaders;
+}
+function normalizeRequestBodyChunk(chunk, encoding = "utf8") {
+  if (typeof chunk === "string") {
+    if (encoding !== "utf8" && typeof Buffer !== "undefined") {
+      return Buffer.from(chunk, encoding);
+    }
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return chunk;
+  }
+  if (chunk instanceof ArrayBuffer) {
+    return new Uint8Array(chunk);
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  }
+  return new TextEncoder().encode(String(chunk));
+}
+function buildRequestBody(chunks) {
+  if (chunks.length === 0) {
+    return void 0;
+  }
+  if (chunks.length === 1) {
+    return chunks[0];
+  }
+  if (chunks.every((chunk) => typeof chunk === "string")) {
+    return chunks.join("");
+  }
+  const encoder = new TextEncoder();
+  const bodyParts = chunks.map((chunk) => typeof chunk === "string" ? encoder.encode(chunk) : chunk);
+  const totalLength = bodyParts.reduce((sum, part) => sum + part.byteLength, 0);
+  const body = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const part of bodyParts) {
+    body.set(part, offset);
+    offset += part.byteLength;
+  }
+  return body;
+}
+function isFetchResponse(value) {
+  return typeof value?.status === "number" && typeof value?.statusText === "string" && typeof value?.headers?.forEach === "function";
+}
+function isNodeIncomingMessage(value) {
+  return typeof value?.on === "function" && typeof value?.headers === "object" && (typeof value?.httpVersion === "string" || value?.socket !== void 0);
+}
 function headersToInit(headers) {
   const result = {};
   for (const key in headers) {
@@ -47,17 +112,73 @@ function closeAndEmit(server, callback) {
   server.emit("close");
   if (callback) queueMicrotask(() => callback());
 }
-var http;
-var https;
-if (isNode && typeof process !== "undefined") {
-  try {
-    http = __require("http");
-    https = __require("https");
-  } catch (e) {
-    http = __require("http");
-    https = __require("https");
+
+// src/server/http/client-request.ts
+var ClientRequest = class extends EventEmitter {
+  constructor(_url, _options = {}) {
+    super();
+    this._bodyChunks = [];
+    this._ended = false;
   }
-}
+  _setNativeRequest(nativeRequest) {
+    this._nativeRequest = nativeRequest;
+  }
+  _setExecutor(executor) {
+    this._executor = executor;
+  }
+  write(chunk, encoding, callback) {
+    if (this._ended) {
+      throw new Error("Cannot write after end");
+    }
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = void 0;
+    }
+    if (this._nativeRequest) {
+      const actualEncoding2 = typeof encoding === "string" ? encoding : void 0;
+      return this._nativeRequest.write(chunk, actualEncoding2, callback);
+    }
+    const actualEncoding = typeof encoding === "string" ? encoding : "utf8";
+    this._bodyChunks.push(normalizeRequestBodyChunk(chunk, actualEncoding));
+    queueCallback(callback);
+    return true;
+  }
+  end(chunk, encoding, callback) {
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = void 0;
+      encoding = void 0;
+    } else if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = void 0;
+    }
+    if (this._ended) {
+      queueCallback(callback);
+      return;
+    }
+    this._ended = true;
+    if (this._nativeRequest) {
+      const actualEncoding = typeof encoding === "string" ? encoding : void 0;
+      if (chunk !== void 0) {
+        this._nativeRequest.end(chunk, actualEncoding, callback);
+      } else {
+        this._nativeRequest.end(callback);
+      }
+      return;
+    }
+    if (chunk !== void 0) {
+      this._bodyChunks.push(normalizeRequestBodyChunk(chunk, typeof encoding === "string" ? encoding : "utf8"));
+    }
+    const executor = this._executor;
+    const body = buildRequestBody(this._bodyChunks);
+    if (executor) {
+      Promise.resolve().then(() => executor(body)).catch((error) => this.emit("error", error));
+    }
+    queueCallback(callback);
+  }
+};
+
+// src/server/http/constants.ts
 var METHODS = [
   "GET",
   "POST",
@@ -125,13 +246,23 @@ var STATUS_CODES = {
   510: "Not Extended",
   511: "Network Authentication Required"
 };
-var IncomingMessage = class extends EventEmitter {
-  constructor(req) {
+
+// src/server/http/incoming-message.ts
+import { EventEmitter as EventEmitter2 } from "events";
+var IncomingMessage = class extends EventEmitter2 {
+  constructor(req, requestMethod) {
     super();
     this.httpVersion = "1.1";
     this.rawHeaders = [];
     this._req = req;
-    if (isNode) {
+    if (isFetchResponse(req)) {
+      this.method = requestMethod || "GET";
+      this.url = getRequestPath(req.url);
+      this.headers = headersToRecord(req.headers);
+      this.statusCode = req.status;
+      this.statusMessage = req.statusText;
+      this.rawHeaders = headersToRawHeaders(req.headers);
+    } else if (isNodeIncomingMessage(req)) {
       this.method = req.method;
       this.url = req.url;
       this.headers = req.headers;
@@ -142,14 +273,13 @@ var IncomingMessage = class extends EventEmitter {
       this.socket = req.socket;
     } else {
       this.method = req.method;
-      const urlObj = new URL(req.url);
-      this.url = urlObj.pathname + urlObj.search;
-      this.headers = req.headers;
-      this.rawHeaders = [];
+      this.url = getRequestPath(req.url);
+      this.headers = headersToRecord(req.headers);
+      this.rawHeaders = headersToRawHeaders(req.headers);
     }
   }
   async text() {
-    if (isNode) {
+    if (isNodeIncomingMessage(this._req)) {
       return new Promise((resolve, reject) => {
         const chunks = [];
         this._req.on("data", (chunk) => chunks.push(chunk));
@@ -160,14 +290,80 @@ var IncomingMessage = class extends EventEmitter {
     return this._req.text();
   }
   async json() {
-    if (isNode) {
+    if (isNodeIncomingMessage(this._req)) {
       const text = await this.text();
       return JSON.parse(text);
     }
     return this._req.json();
   }
 };
-var ServerResponse = class extends EventEmitter {
+
+// src/shares/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
+// src/server/http/node-modules.ts
+var http;
+var https;
+if (isNode && typeof process !== "undefined") {
+  try {
+    http = __require("http");
+    https = __require("https");
+  } catch {
+    http = __require("http");
+    https = __require("https");
+  }
+}
+
+// src/server/http/request-api.ts
+function request(url, options, callback) {
+  const urlString = typeof url === "string" ? url : url.toString();
+  const req = new ClientRequest(urlString, options);
+  if (isNode) {
+    const urlObj = new URL(urlString);
+    const client = urlObj.protocol === "https:" ? https : http;
+    const nodeReq = client.request(urlString, {
+      method: options?.method || "GET",
+      headers: options?.headers,
+      timeout: options?.timeout,
+      signal: options?.signal
+    }, (res) => {
+      const incomingMessage = new IncomingMessage(res);
+      if (callback) callback(incomingMessage);
+      req.emit("response", incomingMessage);
+    });
+    req._setNativeRequest(nodeReq);
+    nodeReq.on("error", (error) => req.emit("error", error));
+  } else {
+    req._setExecutor(async (body) => {
+      const response = await fetch(urlString, {
+        method: options?.method || "GET",
+        headers: options?.headers,
+        body,
+        signal: options?.signal
+      });
+      const incomingMessage = new IncomingMessage(response, options?.method || "GET");
+      if (callback) callback(incomingMessage);
+      req.emit("response", incomingMessage);
+    });
+  }
+  return req;
+}
+function get(url, options, callback) {
+  const req = request(url, { ...options, method: "GET" }, callback);
+  req.end();
+  return req;
+}
+
+// src/server/http/response.ts
+import { EventEmitter as EventEmitter3 } from "events";
+var ServerResponse = class extends EventEmitter3 {
   constructor(_req, nodeRes) {
     super();
     this.statusCode = 200;
@@ -300,7 +496,6 @@ var ServerResponse = class extends EventEmitter {
   _setResolver(resolve) {
     this._resolve = resolve;
   }
-  // Express.js-like methods
   json(data, statusCode = 200) {
     if (!this.headersSent) {
       this.setHeader("Content-Type", "application/json");
@@ -324,7 +519,15 @@ var ServerResponse = class extends EventEmitter {
     return this;
   }
 };
-var Server = class extends EventEmitter {
+
+// src/server/http/runtime.ts
+function getRuntime() {
+  return runtime;
+}
+
+// src/server/http/server-runtime.ts
+import { EventEmitter as EventEmitter4 } from "events";
+var Server = class extends EventEmitter4 {
   constructor(requestListener) {
     super();
     this._bunWebSocketServers = /* @__PURE__ */ new Set();
@@ -399,6 +602,8 @@ var Server = class extends EventEmitter {
           const urlObj = new URL(req.url);
           const pathname = urlObj.pathname;
           const requestUrl = urlObj.pathname + urlObj.search;
+          const incomingHeaders = headersToRecord(req.headers);
+          const rawHeaders = headersToRawHeaders(req.headers);
           const upgradeHeader = req.headers.get("upgrade");
           if (upgradeHeader && upgradeHeader.toLowerCase() === "websocket") {
             const matchingWebSocketServer = Array.from(this._bunWebSocketServers).find((wsServer) => {
@@ -435,9 +640,9 @@ var Server = class extends EventEmitter {
           const incomingMessage = {
             method: req.method,
             url: requestUrl,
-            headers: req.headers,
+            headers: incomingHeaders,
             httpVersion: "1.1",
-            rawHeaders: [],
+            rawHeaders,
             _req: req,
             text: () => req.text(),
             json: () => req.json()
@@ -496,6 +701,8 @@ var Server = class extends EventEmitter {
           };
           if (self.requestListener) {
             self.requestListener(incomingMessage, serverResponse);
+          } else {
+            self.emit("request", incomingMessage, serverResponse);
           }
           if (responseReady) {
             return new Response(body, {
@@ -570,9 +777,11 @@ var Server = class extends EventEmitter {
         return createAddress(0, addr, "unix");
       }
       return addr;
-    } else if (isBun) {
+    }
+    if (isBun) {
       return createAddress(this.nativeServer.port, this.nativeServer.hostname);
-    } else if (isDeno) {
+    }
+    if (isDeno) {
       const addr = this.nativeServer.addr;
       return createAddress(addr.port, addr.hostname);
     }
@@ -582,70 +791,11 @@ var Server = class extends EventEmitter {
     return this._listening;
   }
 };
-var ClientRequest = class extends EventEmitter {
-  constructor(_url, _options = {}) {
-    super();
-  }
-  write(_chunk) {
-    return true;
-  }
-  end(callback) {
-    queueCallback(callback);
-  }
-};
-var Agent = class {
-  constructor(options) {
-    this.options = options;
-  }
-};
 function createServer(optionsOrListener, requestListener) {
   return new Server(typeof optionsOrListener === "function" ? optionsOrListener : requestListener);
 }
-function request(url, options, callback) {
-  const urlString = typeof url === "string" ? url : url.toString();
-  const req = new ClientRequest(urlString, options);
-  if (isNode) {
-    const urlObj = new URL(urlString);
-    const client = urlObj.protocol === "https:" ? https : http;
-    const nodeReq = client.request(urlString, {
-      method: options?.method || "GET",
-      headers: options?.headers,
-      timeout: options?.timeout,
-      signal: options?.signal
-    }, (res) => {
-      const incomingMessage = new IncomingMessage(res);
-      if (callback) callback(incomingMessage);
-      req.emit("response", incomingMessage);
-    });
-    nodeReq.on("error", (error) => req.emit("error", error));
-    nodeReq.end();
-  } else {
-    queueMicrotask(async () => {
-      try {
-        const response = await fetch(urlString, {
-          method: options?.method || "GET",
-          headers: options?.headers,
-          signal: options?.signal
-        });
-        const fetchRequest = new Request(urlString);
-        const incomingMessage = new IncomingMessage(fetchRequest);
-        incomingMessage.statusCode = response.status;
-        incomingMessage.statusMessage = response.statusText;
-        if (callback) callback(incomingMessage);
-        req.emit("response", incomingMessage);
-      } catch (error) {
-        req.emit("error", error);
-      }
-    });
-  }
-  return req;
-}
-function get(url, options, callback) {
-  return request(url, { ...options, method: "GET" }, callback);
-}
-function getRuntime() {
-  return runtime;
-}
+
+// src/server/http/index.ts
 var http_default = {
   createServer,
   request,