elit 2.0.0 → 3.0.0

package/dist/http.js

@@ -0,0 +1,632 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/http.ts
+var http_exports = {};
+__export(http_exports, {
+  Agent: () => Agent,
+  ClientRequest: () => ClientRequest,
+  IncomingMessage: () => IncomingMessage,
+  METHODS: () => METHODS,
+  STATUS_CODES: () => STATUS_CODES,
+  Server: () => Server,
+  ServerResponse: () => ServerResponse,
+  createServer: () => createServer,
+  default: () => http_default,
+  get: () => get,
+  getRuntime: () => getRuntime,
+  request: () => request
+});
+module.exports = __toCommonJS(http_exports);
+var import_node_events = require("events");
+
+// 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/http.ts
+function queueCallback(callback) {
+  if (callback) queueMicrotask(callback);
+}
+function headersToInit(headers) {
+  const result = {};
+  for (const key in headers) {
+    const value = headers[key];
+    result[key] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return result;
+}
+function createAddress(port, address, family = "IPv4") {
+  return { port, family, address };
+}
+function createErrorResponse() {
+  return new Response("Internal Server Error", { status: 500 });
+}
+function emitListeningWithCallback(server, callback) {
+  server._listening = true;
+  server.emit("listening");
+  queueCallback(callback);
+}
+function closeAndEmit(server, callback) {
+  server._listening = false;
+  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");
+  }
+}
+var METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+];
+var STATUS_CODES = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a teapot",
+  422: "Unprocessable Entity",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+var IncomingMessage = class extends import_node_events.EventEmitter {
+  constructor(req) {
+    super();
+    this.httpVersion = "1.1";
+    this.rawHeaders = [];
+    this._req = req;
+    if (isNode) {
+      this.method = req.method;
+      this.url = req.url;
+      this.headers = req.headers;
+      this.statusCode = req.statusCode;
+      this.statusMessage = req.statusMessage;
+      this.httpVersion = req.httpVersion;
+      this.rawHeaders = req.rawHeaders;
+      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 = [];
+    }
+  }
+  async text() {
+    if (isNode) {
+      return new Promise((resolve, reject) => {
+        const chunks = [];
+        this._req.on("data", (chunk) => chunks.push(chunk));
+        this._req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        this._req.on("error", reject);
+      });
+    }
+    return this._req.text();
+  }
+  async json() {
+    if (isNode) {
+      const text = await this.text();
+      return JSON.parse(text);
+    }
+    return this._req.json();
+  }
+};
+var ServerResponse = class extends import_node_events.EventEmitter {
+  constructor(_req, nodeRes) {
+    super();
+    this.statusCode = 200;
+    this.statusMessage = "OK";
+    this.headersSent = false;
+    this._body = "";
+    this._finished = false;
+    this._nodeRes = nodeRes;
+    this._headers = /* @__PURE__ */ Object.create(null);
+  }
+  setHeader(name, value) {
+    if (this.headersSent) {
+      throw new Error("Cannot set headers after they are sent");
+    }
+    if (isNode && this._nodeRes) {
+      this._nodeRes.setHeader(name, value);
+    }
+    this._headers[name.toLowerCase()] = value;
+    return this;
+  }
+  getHeader(name) {
+    if (isNode && this._nodeRes) {
+      return this._nodeRes.getHeader(name);
+    }
+    return this._headers[name.toLowerCase()];
+  }
+  getHeaders() {
+    if (isNode && this._nodeRes) {
+      return this._nodeRes.getHeaders();
+    }
+    return { ...this._headers };
+  }
+  getHeaderNames() {
+    if (isNode && this._nodeRes) {
+      return this._nodeRes.getHeaderNames();
+    }
+    return Object.keys(this._headers);
+  }
+  hasHeader(name) {
+    if (isNode && this._nodeRes) {
+      return this._nodeRes.hasHeader(name);
+    }
+    return name.toLowerCase() in this._headers;
+  }
+  removeHeader(name) {
+    if (this.headersSent) {
+      throw new Error("Cannot remove headers after they are sent");
+    }
+    if (isNode && this._nodeRes) {
+      this._nodeRes.removeHeader(name);
+    }
+    delete this._headers[name.toLowerCase()];
+  }
+  writeHead(statusCode, statusMessage, headers) {
+    if (this.headersSent) {
+      throw new Error("Cannot write headers after they are sent");
+    }
+    this.statusCode = statusCode;
+    if (typeof statusMessage === "string") {
+      this.statusMessage = statusMessage;
+      if (headers) {
+        for (const key in headers) {
+          this.setHeader(key, headers[key]);
+        }
+      }
+    } else if (statusMessage) {
+      for (const key in statusMessage) {
+        this.setHeader(key, statusMessage[key]);
+      }
+    }
+    if (isNode && this._nodeRes) {
+      if (typeof statusMessage === "string") {
+        this._nodeRes.writeHead(statusCode, statusMessage, headers);
+      } else {
+        this._nodeRes.writeHead(statusCode, statusMessage);
+      }
+    }
+    this.headersSent = true;
+    return this;
+  }
+  write(chunk, encoding, callback) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = "utf8";
+    }
+    if (!this.headersSent) {
+      this.writeHead(this.statusCode);
+    }
+    if (isNode && this._nodeRes) {
+      return this._nodeRes.write(chunk, encoding, callback);
+    }
+    this._body += chunk;
+    queueCallback(callback);
+    return true;
+  }
+  end(chunk, encoding, callback) {
+    if (this._finished) {
+      return this;
+    }
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = void 0;
+    } else if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = "utf8";
+    }
+    if (chunk !== void 0) {
+      this.write(chunk, encoding);
+    }
+    if (!this.headersSent) {
+      this.writeHead(this.statusCode);
+    }
+    this._finished = true;
+    if (isNode && this._nodeRes) {
+      this._nodeRes.end(callback);
+      this.emit("finish");
+    } else {
+      const response = new Response(this._body, {
+        status: this.statusCode,
+        statusText: this.statusMessage,
+        headers: headersToInit(this._headers)
+      });
+      if (this._resolve) {
+        this._resolve(response);
+      }
+      queueCallback(callback);
+    }
+    return this;
+  }
+  _setResolver(resolve) {
+    this._resolve = resolve;
+  }
+};
+var Server = class extends import_node_events.EventEmitter {
+  constructor(requestListener) {
+    super();
+    this._listening = false;
+    this.requestListener = requestListener;
+  }
+  listen(...args) {
+    let port = 3e3;
+    let hostname = "0.0.0.0";
+    let callback;
+    const firstArg = args[0];
+    if (typeof firstArg === "number") {
+      port = firstArg;
+      const secondArg = args[1];
+      if (typeof secondArg === "string") {
+        hostname = secondArg;
+        callback = args[2] || args[3];
+      } else if (typeof secondArg === "function") {
+        callback = secondArg;
+      }
+    } else if (firstArg && typeof firstArg === "object") {
+      port = firstArg.port || 3e3;
+      hostname = firstArg.hostname || "0.0.0.0";
+      callback = args[1];
+    }
+    const self = this;
+    if (isNode) {
+      this.nativeServer = http.createServer((req, res) => {
+        const incomingMessage = new IncomingMessage(req);
+        const serverResponse = new ServerResponse(incomingMessage, res);
+        if (self.requestListener) {
+          self.requestListener(incomingMessage, serverResponse);
+        } else {
+          self.emit("request", incomingMessage, serverResponse);
+        }
+      });
+      this.nativeServer.on("upgrade", (req, socket, head) => {
+        self.emit("upgrade", req, socket, head);
+      });
+      this.nativeServer.listen(port, hostname, () => {
+        this._listening = true;
+        this.emit("listening");
+        if (callback) callback();
+      });
+      this.nativeServer.on("error", (err) => this.emit("error", err));
+      this.nativeServer.on("close", () => {
+        this._listening = false;
+        this.emit("close");
+      });
+    } else if (isBun) {
+      this.nativeServer = Bun.serve({
+        port,
+        hostname,
+        fetch: (req) => {
+          const urlObj = new URL(req.url);
+          const pathname = urlObj.pathname + urlObj.search;
+          let statusCode = 200;
+          let statusMessage = "OK";
+          let body = "";
+          const headers = /* @__PURE__ */ Object.create(null);
+          let responseReady = false;
+          const incomingMessage = {
+            method: req.method,
+            url: pathname,
+            headers: req.headers,
+            httpVersion: "1.1",
+            rawHeaders: [],
+            _req: req,
+            text: () => req.text(),
+            json: () => req.json()
+          };
+          const serverResponse = {
+            statusCode: 200,
+            statusMessage: "OK",
+            headersSent: false,
+            _headers: headers,
+            setHeader(name, value) {
+              headers[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+              return this;
+            },
+            getHeader(name) {
+              return headers[name.toLowerCase()];
+            },
+            getHeaders() {
+              return { ...headers };
+            },
+            writeHead(status, arg2, arg3) {
+              statusCode = status;
+              this.statusCode = status;
+              this.headersSent = true;
+              if (typeof arg2 === "string") {
+                statusMessage = arg2;
+                this.statusMessage = arg2;
+                if (arg3) {
+                  for (const key in arg3) {
+                    headers[key.toLowerCase()] = arg3[key];
+                  }
+                }
+              } else if (arg2) {
+                for (const key in arg2) {
+                  headers[key.toLowerCase()] = arg2[key];
+                }
+              }
+              return this;
+            },
+            write(chunk) {
+              if (!this.headersSent) {
+                this.writeHead(statusCode);
+              }
+              body += chunk;
+              return true;
+            },
+            end(chunk) {
+              if (chunk !== void 0) {
+                this.write(chunk);
+              }
+              if (!this.headersSent) {
+                this.writeHead(statusCode);
+              }
+              responseReady = true;
+              return this;
+            }
+          };
+          if (self.requestListener) {
+            self.requestListener(incomingMessage, serverResponse);
+          }
+          if (responseReady) {
+            return new Response(body, {
+              status: statusCode,
+              statusText: statusMessage,
+              headers
+            });
+          }
+          return new Promise((resolve) => {
+            serverResponse.end = (chunk) => {
+              if (chunk !== void 0) {
+                body += chunk;
+              }
+              resolve(new Response(body, {
+                status: statusCode,
+                statusText: statusMessage,
+                headers
+              }));
+            };
+          });
+        },
+        error: createErrorResponse
+      });
+      emitListeningWithCallback(this, callback);
+    } else if (isDeno) {
+      this.nativeServer = Deno.serve({
+        port,
+        hostname,
+        handler: (req) => {
+          return new Promise((resolve) => {
+            const incomingMessage = new IncomingMessage(req);
+            const serverResponse = new ServerResponse();
+            serverResponse._setResolver(resolve);
+            if (self.requestListener) {
+              self.requestListener(incomingMessage, serverResponse);
+            } else {
+              self.emit("request", incomingMessage, serverResponse);
+            }
+          });
+        },
+        onError: (error) => {
+          this.emit("error", error);
+          return createErrorResponse();
+        }
+      });
+      emitListeningWithCallback(this, callback);
+    }
+    return this;
+  }
+  close(callback) {
+    if (!this.nativeServer) {
+      if (callback) queueMicrotask(() => callback());
+      return this;
+    }
+    if (isNode) {
+      this.nativeServer.close(callback);
+    } else if (isBun) {
+      this.nativeServer.stop();
+      closeAndEmit(this, callback);
+    } else if (isDeno) {
+      this.nativeServer.shutdown();
+      closeAndEmit(this, callback);
+    }
+    return this;
+  }
+  address() {
+    if (!this.nativeServer) return null;
+    if (isNode) {
+      const addr = this.nativeServer.address();
+      if (!addr) return null;
+      if (typeof addr === "string") {
+        return createAddress(0, addr, "unix");
+      }
+      return addr;
+    } else if (isBun) {
+      return createAddress(this.nativeServer.port, this.nativeServer.hostname);
+    } else if (isDeno) {
+      const addr = this.nativeServer.addr;
+      return createAddress(addr.port, addr.hostname);
+    }
+    return null;
+  }
+  get listening() {
+    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;
+}
+var http_default = {
+  createServer,
+  request,
+  get,
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  Agent,
+  ClientRequest,
+  METHODS,
+  STATUS_CODES,
+  getRuntime
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Agent,
+  ClientRequest,
+  IncomingMessage,
+  METHODS,
+  STATUS_CODES,
+  Server,
+  ServerResponse,
+  createServer,
+  get,
+  getRuntime,
+  request
+});