elit 3.6.6 → 3.6.7

package/dist/http.cjs

@@ -17,7 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/http.ts
+// src/server/http/index.ts
 var http_exports = {};
 __export(http_exports, {
   Agent: () => Agent,
@@ -34,22 +34,89 @@ __export(http_exports, {
   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/server/http/agent.ts
+var Agent = class {
+  constructor(options) {
+    this.options = options;
+  }
+};
+
+// 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) {
@@ -74,17 +141,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 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",
@@ -152,13 +275,23 @@ var STATUS_CODES = {
   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;
@@ -169,14 +302,13 @@ var IncomingMessage = class extends import_node_events.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));
@@ -187,14 +319,80 @@ var IncomingMessage = class extends import_node_events.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 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;
@@ -327,7 +525,6 @@ var ServerResponse = class extends import_node_events.EventEmitter {
   _setResolver(resolve) {
     this._resolve = resolve;
   }
-  // Express.js-like methods
   json(data, statusCode = 200) {
     if (!this.headersSent) {
       this.setHeader("Content-Type", "application/json");
@@ -351,7 +548,15 @@ var ServerResponse = class extends import_node_events.EventEmitter {
     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();
@@ -426,6 +631,8 @@ var Server = class extends import_node_events.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) => {
@@ -462,9 +669,9 @@ var Server = class extends import_node_events.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()
@@ -523,6 +730,8 @@ var Server = class extends import_node_events.EventEmitter {
           };
           if (self.requestListener) {
             self.requestListener(incomingMessage, serverResponse);
+          } else {
+            self.emit("request", incomingMessage, serverResponse);
           }
           if (responseReady) {
             return new Response(body, {
@@ -597,9 +806,11 @@ var Server = class extends import_node_events.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);
     }
@@ -609,70 +820,11 @@ var Server = class extends import_node_events.EventEmitter {
     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,

package/dist/http.d.ts

@@ -1,75 +1,44 @@
 import { EventEmitter } from 'node:events';
+import { R as RequestOptions, I as IncomingMessage, a as RequestListener, b as ServerOptions, S as ServerResponse } from './types-DAisuVr5.js';
+export { c as IncomingHttpHeaders, O as OutgoingHttpHeaders } from './types-DAisuVr5.js';
 
 /**
- * HTTP module with unified API across runtimes
- * Ultra-optimized for maximum performance across Node.js, Bun, and Deno
- *
- * Performance optimizations:
- * - Bun fast path: Zero class instantiation (object literals only)
- * - Eliminated EventEmitter overhead for Bun/Deno
- * - Zero-copy headers conversion
- * - Inline response creation
- * - Reduced object allocations
- * - Direct closure capture (no resolver indirection)
+ * HTTP Agent
  */
+declare class Agent {
+    options?: any | undefined;
+    constructor(options?: any | undefined);
+}
 
 /**
- * HTTP Methods
- */
-declare const METHODS: readonly ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
-/**
- * HTTP Status Codes (compact object)
+ * Client request - lightweight wrapper
  */
-declare const STATUS_CODES: Record<number, string>;
+declare class ClientRequest extends EventEmitter {
+    private _nativeRequest?;
+    private _bodyChunks;
+    private _executor?;
+    private _ended;
+    constructor(_url: string | URL, _options?: RequestOptions);
+    _setNativeRequest(nativeRequest: any): void;
+    _setExecutor(executor: (body: BodyInit | undefined) => Promise<void> | void): void;
+    write(chunk: any, encoding?: BufferEncoding | (() => void), callback?: () => void): boolean;
+    end(chunk?: any, encoding?: BufferEncoding | (() => void), callback?: () => void): void;
+}
+
 /**
- * HTTP Headers type
+ * Make HTTP request - optimized per runtime
  */
-type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
-type OutgoingHttpHeaders = Record<string, string | string[] | number>;
+declare function request(url: string | URL, options?: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
 /**
- * IncomingMessage - Ultra-optimized for zero-copy operations
+ * Make HTTP GET request
  */
-declare class IncomingMessage extends EventEmitter {
-    method: string;
-    url: string;
-    headers: IncomingHttpHeaders;
-    statusCode?: number;
-    statusMessage?: string;
-    httpVersion: string;
-    rawHeaders: string[];
-    socket: any;
-    private _req;
-    constructor(req: any);
-    text(): Promise<string>;
-    json(): Promise<any>;
-}
+declare function get(url: string | URL, options?: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
+
 /**
- * ServerResponse - Ultra-optimized write operations
+ * Get current runtime
  */
-declare class ServerResponse extends EventEmitter {
-    statusCode: number;
-    statusMessage: string;
-    headersSent: boolean;
-    private _headers;
-    private _body;
-    private _resolve?;
-    private _finished;
-    private _nodeRes?;
-    constructor(_req?: IncomingMessage, nodeRes?: any);
-    setHeader(name: string, value: string | string[] | number): this;
-    getHeader(name: string): string | string[] | number | undefined;
-    getHeaders(): OutgoingHttpHeaders;
-    getHeaderNames(): string[];
-    hasHeader(name: string): boolean;
-    removeHeader(name: string): void;
-    writeHead(statusCode: number, statusMessage?: string | OutgoingHttpHeaders, headers?: OutgoingHttpHeaders): this;
-    write(chunk: any, encoding?: BufferEncoding | (() => void), callback?: () => void): boolean;
-    end(chunk?: any, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
-    _setResolver(resolve: (response: Response) => void): void;
-    json(data: any, statusCode?: number): this;
-    send(data: any): this;
-    status(code: number): this;
-}
+declare function getRuntime(): 'node' | 'bun' | 'deno';
+
 /**
  * Server - Optimized for each runtime
  */
@@ -97,61 +66,26 @@ declare class Server extends EventEmitter {
     } | null;
     get listening(): boolean;
 }
-/**
- * Request listener type
- */
-type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
-/**
- * Request options
- */
-interface RequestOptions {
-    method?: string;
-    headers?: OutgoingHttpHeaders;
-    timeout?: number;
-    signal?: AbortSignal;
-}
-/**
- * Server options
- */
-interface ServerOptions {
-    IncomingMessage?: typeof IncomingMessage;
-    ServerResponse?: typeof ServerResponse;
-}
-/**
- * Client request - lightweight wrapper
- */
-declare class ClientRequest extends EventEmitter {
-    constructor(_url: string | URL, _options?: RequestOptions);
-    write(_chunk: any): boolean;
-    end(callback?: () => void): void;
-}
-/**
- * HTTP Agent
- */
-declare class Agent {
-    options?: any | undefined;
-    constructor(options?: any | undefined);
-}
 /**
  * Create HTTP server
  */
 declare function createServer(requestListener?: RequestListener): Server;
 declare function createServer(options: ServerOptions, requestListener?: RequestListener): Server;
+
 /**
- * Make HTTP request - optimized per runtime
- */
-declare function request(url: string | URL, options?: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
-/**
- * Make HTTP GET request
+ * HTTP Methods
  */
-declare function get(url: string | URL, options?: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
+declare const METHODS: readonly ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
 /**
- * Get current runtime
+ * HTTP Status Codes (compact object)
  */
-declare function getRuntime(): 'node' | 'bun' | 'deno';
+declare const STATUS_CODES: Record<number, string>;
+
 /**
- * Default export
+ * HTTP module with unified API across runtimes
+ * Ultra-optimized for maximum performance across Node.js, Bun, and Deno
  */
+
 declare const _default: {
     createServer: typeof createServer;
     request: typeof request;
@@ -166,4 +100,4 @@ declare const _default: {
     getRuntime: typeof getRuntime;
 };
 
-export { Agent, ClientRequest, type IncomingHttpHeaders, IncomingMessage, METHODS, type OutgoingHttpHeaders, type RequestListener, type RequestOptions, STATUS_CODES, Server, type ServerOptions, ServerResponse, createServer, _default as default, get, getRuntime, request };
+export { Agent, ClientRequest, IncomingMessage, METHODS, RequestListener, RequestOptions, STATUS_CODES, Server, ServerOptions, ServerResponse, createServer, _default as default, get, getRuntime, request };