elit 3.6.7 → 3.6.9

package/dist/wss.mjs

@@ -610,8 +610,9 @@ var init_runtime2 = __esm({
 
 // src/server/http/server-runtime.ts
 import { EventEmitter as EventEmitter7 } from "events";
-function createServer(optionsOrListener, requestListener) {
-  return new Server(typeof optionsOrListener === "function" ? optionsOrListener : requestListener);
+function createServer(arg1, arg2) {
+  const requestListener = typeof arg1 === "function" ? arg1 : arg2;
+  return new Server(requestListener);
 }
 var Server;
 var init_server_runtime = __esm({
@@ -635,9 +636,28 @@ var init_server_runtime = __esm({
       unregisterWebSocketServer(wsServer) {
         this._bunWebSocketServers.delete(wsServer);
       }
+      resolvePmInheritedFd(explicitPort, explicitFd) {
+        if (typeof explicitFd === "number" && Number.isInteger(explicitFd) && explicitFd >= 0) {
+          return explicitFd;
+        }
+        const fdValue = process.env.ELIT_PM_LISTEN_FD;
+        if (!fdValue) {
+          return void 0;
+        }
+        const parsedFd = Number.parseInt(fdValue, 10);
+        if (!Number.isInteger(parsedFd) || parsedFd < 0) {
+          return void 0;
+        }
+        const publicPort = Number.parseInt(process.env.ELIT_PM_PUBLIC_PORT ?? process.env.ELIT_PM_PORT ?? "", 10);
+        if (Number.isInteger(explicitPort) && Number.isInteger(publicPort) && explicitPort !== publicPort) {
+          return void 0;
+        }
+        return parsedFd;
+      }
       listen(...args) {
         let port = 3e3;
         let hostname = "0.0.0.0";
+        let fd;
         let callback;
         const firstArg = args[0];
         if (typeof firstArg === "number") {
@@ -652,8 +672,10 @@ var init_server_runtime = __esm({
         } else if (firstArg && typeof firstArg === "object") {
           port = firstArg.port || 3e3;
           hostname = firstArg.hostname || "0.0.0.0";
+          fd = typeof firstArg.fd === "number" ? firstArg.fd : void 0;
           callback = args[1];
         }
+        fd = this.resolvePmInheritedFd(firstArg && typeof firstArg === "object" ? firstArg.port : port, fd);
         const self = this;
         if (isNode) {
           this.nativeServer = http.createServer((req, res) => {
@@ -668,11 +690,19 @@ var init_server_runtime = __esm({
           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();
-          });
+          if (fd !== void 0) {
+            this.nativeServer.listen({ fd, exclusive: false }, () => {
+              this._listening = true;
+              this.emit("listening");
+              if (callback) callback();
+            });
+          } else {
+            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;
@@ -791,7 +821,6 @@ var init_server_runtime = __esm({
                     this.writeHead(statusCode);
                   }
                   responseReady = true;
-                  return this;
                 }
               };
               if (self.requestListener) {
@@ -799,51 +828,141 @@ var init_server_runtime = __esm({
               } else {
                 self.emit("request", incomingMessage, serverResponse);
               }
-              if (responseReady) {
-                return new Response(body, {
-                  status: statusCode,
-                  statusText: statusMessage,
-                  headers
-                });
+              if (!responseReady) {
+                serverResponse.end();
               }
-              return new Promise((resolve) => {
-                serverResponse.end = (chunk) => {
-                  if (chunk !== void 0) {
-                    body += chunk;
-                  }
-                  resolve(new Response(body, {
-                    status: statusCode,
-                    statusText: statusMessage,
-                    headers
-                  }));
-                };
+              return new Response(body, {
+                status: statusCode,
+                statusText: statusMessage,
+                headers
               });
             },
-            error: createErrorResponse
+            error: (err) => {
+              this.emit("error", err);
+              return createErrorResponse();
+            }
           });
+          this._listening = true;
           emitListeningWithCallback(this, callback);
+          this.nativeServer.stop = this.nativeServer.stop || this.nativeServer.close;
+          this.nativeServer.close = this.nativeServer.close || this.nativeServer.stop;
+          this.nativeServer.on?.("close", () => {
+            this._listening = false;
+            this.emit("close");
+          });
         } else if (isDeno) {
+          const server = this;
           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);
+            hostname
+          }, async (req) => {
+            const urlObj = new URL(req.url);
+            const requestUrl = urlObj.pathname + urlObj.search;
+            const incomingHeaders = headersToRecord(req.headers);
+            const rawHeaders = headersToRawHeaders(req.headers);
+            const bodyChunks = [];
+            const responseHeaders = new Headers();
+            let statusCode = 200;
+            let statusText = "OK";
+            let responseClosed = false;
+            const incomingMessage = {
+              method: req.method,
+              url: requestUrl,
+              headers: incomingHeaders,
+              httpVersion: "1.1",
+              rawHeaders,
+              _req: req,
+              text: () => req.text(),
+              json: () => req.json()
+            };
+            const serverResponse = {
+              statusCode: 200,
+              statusMessage: "OK",
+              headersSent: false,
+              setHeader(name, value) {
+                responseHeaders.set(name, Array.isArray(value) ? value.join(", ") : String(value));
+                return this;
+              },
+              getHeader(name) {
+                return responseHeaders.get(name) ?? void 0;
+              },
+              getHeaders() {
+                const headers = {};
+                responseHeaders.forEach((value, key) => {
+                  headers[key] = value;
+                });
+                return headers;
+              },
+              writeHead(status, arg2, arg3) {
+                statusCode = status;
+                this.statusCode = status;
+                this.headersSent = true;
+                if (typeof arg2 === "string") {
+                  statusText = arg2;
+                  this.statusMessage = arg2;
+                  if (arg3) {
+                    Object.entries(arg3).forEach(([key, value]) => {
+                      responseHeaders.set(key, Array.isArray(value) ? value.join(", ") : String(value));
+                    });
+                  }
+                } else if (arg2) {
+                  Object.entries(arg2).forEach(([key, value]) => {
+                    responseHeaders.set(key, Array.isArray(value) ? value.join(", ") : String(value));
+                  });
                 }
-              });
-            },
-            onError: (error) => {
-              this.emit("error", error);
-              return createErrorResponse();
+                return this;
+              },
+              write(chunk) {
+                if (!this.headersSent) {
+                  this.writeHead(statusCode);
+                }
+                if (typeof chunk === "string") {
+                  bodyChunks.push(new TextEncoder().encode(chunk));
+                } else if (chunk instanceof Uint8Array) {
+                  bodyChunks.push(chunk);
+                } else if (chunk !== void 0 && chunk !== null) {
+                  bodyChunks.push(new TextEncoder().encode(String(chunk)));
+                }
+                return true;
+              },
+              end(chunk) {
+                if (chunk !== void 0) {
+                  this.write(chunk);
+                }
+                if (!this.headersSent) {
+                  this.writeHead(statusCode);
+                }
+                responseClosed = true;
+              }
+            };
+            if (server.requestListener) {
+              server.requestListener(incomingMessage, serverResponse);
+            } else {
+              server.emit("request", incomingMessage, serverResponse);
+            }
+            if (!responseClosed) {
+              serverResponse.end();
             }
+            const body = bodyChunks.length === 0 ? void 0 : (() => {
+              const totalLength = bodyChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+              const output = new ArrayBuffer(totalLength);
+              const combined = new Uint8Array(output);
+              let offset = 0;
+              for (const chunk of bodyChunks) {
+                combined.set(chunk, offset);
+                offset += chunk.length;
+              }
+              return output;
+            })();
+            return new Response(body, {
+              status: statusCode,
+              statusText,
+              headers: responseHeaders
+            });
           });
+          this._listening = true;
           emitListeningWithCallback(this, callback);
+          this.nativeServer.finished.then(() => closeAndEmit(this)).catch((err) => this.emit("error", err));
         }
         return this;
       }
@@ -1451,9 +1570,28 @@ var Server2 = class extends EventEmitter8 {
     this.options = options;
     this.requestListener = requestListener;
   }
+  resolvePmInheritedFd(explicitPort, explicitFd) {
+    if (typeof explicitFd === "number" && Number.isInteger(explicitFd) && explicitFd >= 0) {
+      return explicitFd;
+    }
+    const fdValue = process.env.ELIT_PM_LISTEN_FD;
+    if (!fdValue) {
+      return void 0;
+    }
+    const parsedFd = Number.parseInt(fdValue, 10);
+    if (!Number.isInteger(parsedFd) || parsedFd < 0) {
+      return void 0;
+    }
+    const publicPort = Number.parseInt(process.env.ELIT_PM_PUBLIC_PORT ?? process.env.ELIT_PM_PORT ?? "", 10);
+    if (Number.isInteger(explicitPort) && Number.isInteger(publicPort) && explicitPort !== publicPort) {
+      return void 0;
+    }
+    return parsedFd;
+  }
   listen(...args) {
     let port = 3e3;
     let hostname = "0.0.0.0";
+    let fd;
     let callback;
     const firstArg = args[0];
     if (typeof firstArg === "number") {
@@ -1468,8 +1606,10 @@ var Server2 = class extends EventEmitter8 {
     } else if (firstArg && typeof firstArg === "object") {
       port = firstArg.port || 3e3;
       hostname = firstArg.hostname || "0.0.0.0";
+      fd = typeof firstArg.fd === "number" ? firstArg.fd : void 0;
       callback = args[1];
     }
+    fd = this.resolvePmInheritedFd(firstArg && typeof firstArg === "object" ? firstArg.port : port, fd);
     const self = this;
     if (isNode) {
       const { IncomingMessage: IncomingMessage2, ServerResponse: ServerResponse2 } = loadHttpClasses();
@@ -1482,11 +1622,19 @@ var Server2 = class extends EventEmitter8 {
           self.emit("request", incomingMessage, serverResponse);
         }
       });
-      this.nativeServer.listen(port, hostname, () => {
-        this._listening = true;
-        this.emit("listening");
-        if (callback) callback();
-      });
+      if (fd !== void 0) {
+        this.nativeServer.listen({ fd, exclusive: false }, () => {
+          this._listening = true;
+          this.emit("listening");
+          if (callback) callback();
+        });
+      } else {
+        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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elit",
-  "version": "3.6.7",
+  "version": "3.6.9",
   "description": "Optimized lightweight library for creating DOM elements with reactive state",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -155,6 +155,11 @@
       "import": "./dist/database.mjs",
       "require": "./dist/database.cjs"
     },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.mjs",
+      "require": "./dist/config.cjs"
+    },
     "./test": {
       "types": "./dist/test.d.ts",
       "browser": "./dist/test.js",
@@ -217,11 +222,11 @@
     "build": "node ./scripts/tsup-runner.mjs",
     "dev": "node ./scripts/tsup-runner.mjs --watch",
     "typecheck": "tsc --noEmit",
-    "test": "elit test",
-    "test:run": "elit test --run",
-    "test:coverage": "elit test --coverage",
-    "test:e2e": "elit test --e2e",
-    "test:wapk:google-drive": "elit test --run --file ./testing/unit/wapk.google-drive.integration.test.ts",
+    "test": "node ./scripts/run-local-cli.mjs test",
+    "test:run": "node ./scripts/run-local-cli.mjs test --run",
+    "test:coverage": "node ./scripts/run-local-cli.mjs test --coverage",
+    "test:e2e": "node ./scripts/run-local-cli.mjs test --e2e",
+    "test:wapk:google-drive": "node ./scripts/run-local-cli.mjs test --run --file ./testing/unit/wapk.google-drive.integration.test.ts",
     "benchmark": "node benchmark/server-benchmark.js",
     "benchmark:router": "node benchmark/router-benchmark.js",
     "docs:dev": "npm run --prefix docs dev",