elit 3.6.6 → 3.6.7

package/dist/http.js

@@ -7,23 +7,88 @@
     throw Error('Dynamic require of "' + x + '" is not supported');
   });
 
-  // src/http.ts
-  var import_node_events = __require("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
+  var import_node_events = __require("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) {
@@ -48,17 +113,73 @@
     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 import_node_events.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",
@@ -126,13 +247,23 @@
     510: "Not Extended",
     511: "Network Authentication Required"
   };
-  var IncomingMessage = class extends import_node_events.EventEmitter {
-    constructor(req) {
+
+  // src/server/http/incoming-message.ts
+  var import_node_events2 = __require("events");
+  var IncomingMessage = class extends import_node_events2.EventEmitter {
+    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;
@@ -143,14 +274,13 @@
         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));
@@ -161,14 +291,80 @@
       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 import_node_events.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
+  var import_node_events3 = __require("events");
+  var ServerResponse = class extends import_node_events3.EventEmitter {
     constructor(_req, nodeRes) {
       super();
       this.statusCode = 200;
@@ -301,7 +497,6 @@
     _setResolver(resolve) {
       this._resolve = resolve;
     }
-    // Express.js-like methods
     json(data, statusCode = 200) {
       if (!this.headersSent) {
         this.setHeader("Content-Type", "application/json");
@@ -325,7 +520,15 @@
       return this;
     }
   };
-  var Server = class extends import_node_events.EventEmitter {
+
+  // src/server/http/runtime.ts
+  function getRuntime() {
+    return runtime;
+  }
+
+  // src/server/http/server-runtime.ts
+  var import_node_events4 = __require("events");
+  var Server = class extends import_node_events4.EventEmitter {
     constructor(requestListener) {
       super();
       this._bunWebSocketServers = /* @__PURE__ */ new Set();
@@ -400,6 +603,8 @@
             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) => {
@@ -436,9 +641,9 @@
             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()
@@ -497,6 +702,8 @@
             };
             if (self.requestListener) {
               self.requestListener(incomingMessage, serverResponse);
+            } else {
+              self.emit("request", incomingMessage, serverResponse);
             }
             if (responseReady) {
               return new Response(body, {
@@ -571,9 +778,11 @@
           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);
       }
@@ -583,70 +792,11 @@
       return this._listening;
     }
   };
-  var ClientRequest = class extends import_node_events.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,