@absolutejs/absolute 0.19.0-beta.121 → 0.19.0-beta.122

package/dist/dev/client/reactRefreshSetup.ts

@@ -28,8 +28,7 @@ if (!window.$RefreshRuntime$) {
 		for (const [type, id] of buffer) {
 			RefreshRuntime.register(type, id);
 		}
-		(
-			window as unknown as Record<string, unknown>
-		).__REFRESH_BUFFER__ = undefined;
+		(window as unknown as Record<string, unknown>).__REFRESH_BUFFER__ =
+			undefined;
 	}
 }

package/dist/index.js

@@ -1169,7 +1169,14 @@ var colors, MONTHS, formatTimestamp = () => {
   hours = hours % HOURS_IN_HALF_DAY || HOURS_IN_HALF_DAY;
   return `${month} ${day} ${hours}:${minutes}:${seconds} ${ampm}`;
 }, startupBanner = (options) => {
-  const { version, duration, port, host, networkUrl, protocol = "http" } = options;
+  const {
+    version,
+    duration,
+    port,
+    host,
+    networkUrl,
+    protocol = "http"
+  } = options;
   const name = `${colors.cyan}${colors.bold}ABSOLUTEJS${colors.reset}`;
   const ver = `${colors.dim}v${version}${colors.reset}`;
   const time = `${colors.dim}ready in${colors.reset} ${colors.bold}${getDurationString(duration)}${colors.reset}`;
@@ -204980,7 +204987,8 @@ var STORE_KEY = "__elysiaStore", getGlobalValue = (key) => Reflect.get(globalThi
   Reflect.set(globalThis, STORE_KEY, app.store);
 }, hmr = (hmrState2, manifest, moduleServerHandler) => (app) => {
   restoreStore(app);
-  return app.onBeforeHandle(async ({ request }) => {
+  const http2Mode = Boolean(globalThis.__http2Config);
+  app.onBeforeHandle(async ({ request }) => {
     if (globalThis.__reactModuleRef) {
       await bridgeReactInternals();
     }
@@ -205015,11 +205023,15 @@ var STORE_KEY = "__elysiaStore", getGlobalValue = (key) => Reflect.get(globalThi
         "Content-Type": getMimeType(pathname)
       }
     });
-  }).ws("/hmr", {
-    close: (ws) => handleClientDisconnect(hmrState2, ws),
-    message: (ws, msg) => handleHMRMessage(hmrState2, ws, msg),
-    open: (ws) => handleClientConnect(hmrState2, ws, manifest)
-  }).get("/hmr-status", () => ({
+  });
+  if (!http2Mode) {
+    app.ws("/hmr", {
+      close: (ws) => handleClientDisconnect(hmrState2, ws),
+      message: (ws, msg) => handleHMRMessage(hmrState2, ws, msg),
+      open: (ws) => handleClientConnect(hmrState2, ws, manifest)
+    });
+  }
+  return app.get("/hmr-status", () => ({
     connectedClients: hmrState2.connectedClients.size,
     isRebuilding: hmrState2.isRebuilding,
     manifestKeys: Object.keys(manifest),
@@ -205035,6 +205047,188 @@ var init_hmr = __esm(() => {
   init_webSocket();
 });
 
+// src/dev/http2Bridge.ts
+var exports_http2Bridge = {};
+__export(exports_http2Bridge, {
+  bridgeHttp2Stream: () => bridgeHttp2Stream
+});
+var WS_OPCODE_TEXT = 1, WS_OPCODE_CLOSE = 8, WS_OPCODE_PING = 9, WS_OPCODE_PONG = 10, parseWsFrame = (buf) => {
+  if (buf.length < 2)
+    return null;
+  const byte0 = buf[0];
+  const byte1 = buf[1];
+  const opcode = byte0 & 15;
+  const masked = (byte1 & 128) !== 0;
+  let payloadLen = byte1 & 127;
+  let offset = 2;
+  if (payloadLen === 126) {
+    if (buf.length < 4)
+      return null;
+    payloadLen = buf.readUInt16BE(2);
+    offset = 4;
+  } else if (payloadLen === 127) {
+    if (buf.length < 10)
+      return null;
+    payloadLen = Number(buf.readBigUInt64BE(2));
+    offset = 10;
+  }
+  if (masked) {
+    if (buf.length < offset + 4 + payloadLen)
+      return null;
+    const maskKey = buf.subarray(offset, offset + 4);
+    offset += 4;
+    const payload = Buffer.allocUnsafe(payloadLen);
+    for (let i = 0;i < payloadLen; i++) {
+      payload[i] = buf[offset + i] ^ maskKey[i & 3];
+    }
+    return { opcode, payload, totalLen: offset + payloadLen };
+  }
+  if (buf.length < offset + payloadLen)
+    return null;
+  return {
+    opcode,
+    payload: buf.subarray(offset, offset + payloadLen),
+    totalLen: offset + payloadLen
+  };
+}, writeWsFrame = (opcode, payload) => {
+  const len = payload.length;
+  let header;
+  if (len < 126) {
+    header = Buffer.allocUnsafe(2);
+    header[0] = 128 | opcode;
+    header[1] = len;
+  } else if (len < 65536) {
+    header = Buffer.allocUnsafe(4);
+    header[0] = 128 | opcode;
+    header[1] = 126;
+    header.writeUInt16BE(len, 2);
+  } else {
+    header = Buffer.allocUnsafe(10);
+    header[0] = 128 | opcode;
+    header[1] = 127;
+    header.writeBigUInt64BE(BigInt(len), 2);
+  }
+  return Buffer.concat([header, payload]);
+}, createHttp2WebSocket = (stream) => {
+  let state = WS_READY_STATE_OPEN;
+  let buffer = Buffer.alloc(0);
+  let onMessage = null;
+  let onClose = null;
+  stream.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (buffer.length > 0) {
+      const frame = parseWsFrame(buffer);
+      if (!frame)
+        break;
+      buffer = buffer.subarray(frame.totalLen);
+      if (frame.opcode === WS_OPCODE_TEXT && onMessage) {
+        onMessage(frame.payload.toString("utf-8"));
+      } else if (frame.opcode === WS_OPCODE_PING) {
+        if (!stream.destroyed) {
+          stream.write(writeWsFrame(WS_OPCODE_PONG, frame.payload));
+        }
+      } else if (frame.opcode === WS_OPCODE_CLOSE) {
+        if (!stream.destroyed) {
+          stream.write(writeWsFrame(WS_OPCODE_CLOSE, Buffer.alloc(0)));
+          stream.end();
+        }
+        state = 3;
+        if (onClose)
+          onClose();
+      }
+    }
+  });
+  stream.on("close", () => {
+    if (state === WS_READY_STATE_OPEN) {
+      state = 3;
+      if (onClose)
+        onClose();
+    }
+  });
+  stream.on("error", () => {
+    state = 3;
+  });
+  const ws = {
+    get readyState() {
+      return state;
+    },
+    send(data) {
+      if (state !== WS_READY_STATE_OPEN || stream.destroyed)
+        return;
+      stream.write(writeWsFrame(WS_OPCODE_TEXT, Buffer.from(data)));
+    },
+    close() {
+      if (state !== WS_READY_STATE_OPEN || stream.destroyed)
+        return;
+      stream.write(writeWsFrame(WS_OPCODE_CLOSE, Buffer.alloc(0)));
+      stream.end();
+      state = 2;
+    },
+    onMessage: null,
+    onClose: null
+  };
+  onMessage = (data) => ws.onMessage?.(data);
+  onClose = () => ws.onClose?.();
+  return ws;
+}, bridgeHttp2Stream = async (stream, headers, fetchHandler, hmrState2, manifest) => {
+  const method = headers[":method"] ?? "GET";
+  const path = headers[":path"] ?? "/";
+  if (method === "CONNECT" && headers[":protocol"] === "websocket" && hmrState2 && manifest) {
+    stream.respond({ ":status": 200 });
+    const ws = createHttp2WebSocket(stream);
+    ws.onMessage = (data) => handleHMRMessage(hmrState2, ws, data);
+    ws.onClose = () => handleClientDisconnect(hmrState2, ws);
+    handleClientConnect(hmrState2, ws, manifest);
+    return;
+  }
+  const authority = headers[":authority"] ?? "localhost";
+  const scheme = headers[":scheme"] ?? "https";
+  const url = `${scheme}://${authority}${path}`;
+  const requestHeaders = new Headers;
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.startsWith(":") || value === undefined)
+      continue;
+    const headerValue = Array.isArray(value) ? value.join(", ") : value;
+    requestHeaders.set(key, headerValue);
+  }
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const bodyBlob = hasBody ? await new Promise((resolve24) => {
+    const chunks = [];
+    stream.on("data", (chunk) => chunks.push(chunk));
+    stream.on("end", () => {
+      resolve24(new Blob([Buffer.concat(chunks)]));
+    });
+  }) : null;
+  const request = new Request(url, {
+    body: bodyBlob,
+    headers: requestHeaders,
+    method
+  });
+  try {
+    const response = await fetchHandler(request);
+    const responseHeaders = {
+      ":status": response.status
+    };
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    if (!response.body) {
+      stream.respond(responseHeaders);
+      stream.end();
+      return;
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    stream.respond(responseHeaders);
+    stream.end(Buffer.from(arrayBuffer));
+  } catch {
+    stream.respond({ ":status": 500, "content-type": "text/plain" });
+    stream.end("Internal Server Error");
+  }
+};
+var init_http2Bridge = __esm(() => {
+  init_webSocket();
+});
+
 // src/dev/devCert.ts
 var exports_devCert = {};
 __export(exports_devCert, {
@@ -205386,6 +205580,10 @@ var prepare = async (configOrPath) => {
         warmCache2(`${SRC_URL_PREFIX2}${rel}`);
       }
     }
+    globalThis.__http2Config = {
+      hmrState: result.hmrState,
+      manifest: result.manifest
+    };
     const hmrPlugin = hmr2(result.hmrState, result.manifest, moduleHandler);
     const devIndexDir = resolve23(buildDir, "_src_indexes");
     for (const key of Object.keys(result.manifest)) {
@@ -205412,6 +205610,8 @@ var pageRouterPlugin = () => {
 };
 // src/plugins/networking.ts
 init_constants();
+import { readFileSync as readFileSync12 } from "fs";
+import { join as join18 } from "path";
 import { argv } from "process";
 var {env: env3 } = globalThis.Bun;
 
@@ -205444,45 +205644,65 @@ if (hostFlag) {
   localIP = getLocalIPAddress();
   host = "0.0.0.0";
 }
-var tls = (() => {
-  if (env3.NODE_ENV !== "development")
-    return;
-  if (env3.ABSOLUTE_HTTPS !== "true")
-    return;
-  try {
-    const { loadDevCert: loadDevCert2 } = (init_devCert(), __toCommonJS(exports_devCert));
-    return loadDevCert2();
-  } catch {
-    return;
-  }
-})();
-var protocol = tls ? "https" : "http";
-var networking = (app) => app.listen({
-  hostname: host,
-  port,
-  ...tls ? {
-    tls: {
-      cert: tls.cert,
-      key: tls.key
-    }
-  } : {}
-}, () => {
+var isHttpsDev = env3.NODE_ENV === "development" && env3.ABSOLUTE_HTTPS === "true";
+var protocol = isHttpsDev ? "https" : "http";
+var showBanner = () => {
   const isHotReload = Boolean(globalThis.__hmrServerStartup);
   globalThis.__hmrServerStartup = true;
-  if (isHotReload) {
+  if (isHotReload)
     return;
-  }
-  const buildDuration = globalThis.__hmrBuildDuration ?? Number(env3.ABSOLUTE_BUILD_DURATION || 0);
-  const version = globalThis.__absoluteVersion || env3.ABSOLUTE_VERSION || "";
   startupBanner({
-    duration: buildDuration,
+    duration: globalThis.__hmrBuildDuration ?? Number(env3.ABSOLUTE_BUILD_DURATION || 0),
     host,
     networkUrl: hostFlag ? `${protocol}://${localIP}:${port}/` : undefined,
     port,
     protocol,
-    version
+    version: globalThis.__absoluteVersion || env3.ABSOLUTE_VERSION || ""
   });
-});
+};
+var networking = (app) => {
+  if (isHttpsDev) {
+    const certDir = join18(process.cwd(), ".absolutejs");
+    const cert = readFileSync12(join18(certDir, "cert.pem"), "utf-8");
+    const key = readFileSync12(join18(certDir, "key.pem"), "utf-8");
+    app.compile();
+    const http2 = __require("http2");
+    const server2 = http2.createSecureServer({
+      cert,
+      key,
+      settings: { enableConnectProtocol: true }
+    });
+    server2.on("session", (session) => {
+      session.settings({ enableConnectProtocol: true });
+    });
+    const { bridgeHttp2Stream: bridgeHttp2Stream2 } = (init_http2Bridge(), __toCommonJS(exports_http2Bridge));
+    const http2Config = globalThis.__http2Config;
+    server2.on("stream", (stream, headers) => {
+      bridgeHttp2Stream2(stream, headers, app.fetch.bind(app), http2Config?.hmrState, http2Config?.manifest);
+    });
+    server2.listen(Number(port), () => {
+      showBanner();
+    });
+    return app;
+  }
+  const tls = (() => {
+    if (!isHttpsDev)
+      return;
+    try {
+      const { loadDevCert: loadDevCert2 } = (init_devCert(), __toCommonJS(exports_devCert));
+      return loadDevCert2();
+    } catch {
+      return;
+    }
+  })();
+  return app.listen({
+    hostname: host,
+    port,
+    ...tls ? { tls: { cert: tls.cert, key: tls.key } } : {}
+  }, () => {
+    showBanner();
+  });
+};
 // src/utils/defineConfig.ts
 var defineConfig = (config) => config;
 // src/utils/generateHeadElement.ts
@@ -205582,5 +205802,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=B6CD570418E7300764756E2164756E21
+//# debugId=781BD03FD0AB276C64756E2164756E21
 //# sourceMappingURL=index.js.map