hadars 0.1.40 → 0.2.1

package/dist/lambda.d.cts

@@ -1,5 +1,4 @@
-import { H as HadarsEntryModule, a as HadarsOptions } from './hadars-Bh-V5YXg.cjs';
-import 'react';
+import { H as HadarsEntryModule, a as HadarsOptions } from './hadars-DEBSYAQl.cjs';
 
 /**
  * AWS Lambda adapter for hadars.

package/dist/lambda.d.ts

@@ -1,5 +1,4 @@
-import { H as HadarsEntryModule, a as HadarsOptions } from './hadars-Bh-V5YXg.js';
-import 'react';
+import { H as HadarsEntryModule, a as HadarsOptions } from './hadars-DEBSYAQl.js';
 
 /**
  * AWS Lambda adapter for hadars.

package/dist/lambda.js

@@ -1,9 +1,14 @@
 import {
-  renderToString
-} from "./chunk-2ENP7IAW.js";
-import {
-  createElement
-} from "./chunk-OS3V4CPN.js";
+  buildHeadHtml,
+  buildSsrHtml,
+  createProxyHandler,
+  createRenderCache,
+  getReactResponse,
+  makePrecontentHtmlGetter,
+  parseRequest
+} from "./chunk-HWOLYLPF.js";
+import "./chunk-LY5MTHFV.js";
+import "./chunk-OS3V4CPN.js";
 
 // src/lambda.ts
 import "react";
@@ -11,120 +16,8 @@ import pathMod from "node:path";
 import { pathToFileURL } from "node:url";
 import fs from "node:fs/promises";
 
-// src/utils/proxyHandler.tsx
-var cloneHeaders = (headers) => {
-  return new Headers(headers);
-};
-var getCORSHeaders = (req) => {
-  const origin = req.headers.get("Origin") || "*";
-  return {
-    "Access-Control-Allow-Origin": origin,
-    "Access-Control-Allow-Methods": "GET,HEAD,PUT,PATCH,POST,DELETE",
-    "Access-Control-Allow-Headers": req.headers.get("Access-Control-Request-Headers") || "*",
-    "Access-Control-Allow-Credentials": "true"
-  };
-};
-var createProxyHandler = (options) => {
-  const { proxy, proxyCORS } = options;
-  if (!proxy) {
-    return () => void 0;
-  }
-  if (typeof proxy === "function") {
-    return async (req) => {
-      if (req.method === "OPTIONS" && options.proxyCORS) {
-        return new Response(null, {
-          status: 204,
-          headers: getCORSHeaders(req)
-        });
-      }
-      const res = await proxy(req);
-      if (res && proxyCORS) {
-        const modifiedHeaders = new Headers(res.headers);
-        Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
-          modifiedHeaders.set(key, value);
-        });
-        return new Response(res.body, {
-          status: res.status,
-          statusText: res.statusText,
-          headers: modifiedHeaders
-        });
-      }
-      return res || void 0;
-    };
-  }
-  const proxyRules = Object.entries(proxy).sort((a, b) => b[0].length - a[0].length);
-  return async (req) => {
-    for (const [path, target] of proxyRules) {
-      if (req.pathname.startsWith(path)) {
-        if (req.method === "OPTIONS" && proxyCORS) {
-          return new Response(null, {
-            status: 204,
-            headers: getCORSHeaders(req)
-          });
-        }
-        const targetURL = new URL(target);
-        targetURL.pathname = targetURL.pathname.replace(/\/$/, "") + req.pathname.slice(path.length);
-        targetURL.search = req.search;
-        const sendHeaders = cloneHeaders(req.headers);
-        sendHeaders.set("Host", targetURL.host);
-        const hasBody = !["GET", "HEAD"].includes(req.method);
-        const proxyReq = new Request(targetURL.toString(), {
-          method: req.method,
-          headers: sendHeaders,
-          body: hasBody ? req.body : void 0,
-          redirect: "follow",
-          // Node.js (undici) requires duplex:'half' when body is a ReadableStream
-          ...hasBody ? { duplex: "half" } : {}
-        });
-        const res = await fetch(proxyReq);
-        const body = await res.arrayBuffer();
-        const clonedRes = new Headers(res.headers);
-        clonedRes.delete("content-length");
-        clonedRes.delete("content-encoding");
-        if (proxyCORS) {
-          Object.entries(getCORSHeaders(req)).forEach(([key, value]) => {
-            clonedRes.set(key, value);
-          });
-        }
-        return new Response(body, {
-          status: res.status,
-          statusText: res.statusText,
-          headers: clonedRes
-        });
-      }
-    }
-    return void 0;
-  };
-};
-
-// src/utils/cookies.ts
-var parseCookies = (cookieString) => {
-  const cookies = {};
-  if (!cookieString) {
-    return cookies;
-  }
-  const pairs = cookieString.split(";");
-  for (const pair of pairs) {
-    const index = pair.indexOf("=");
-    if (index > -1) {
-      const key = pair.slice(0, index).trim();
-      const value = pair.slice(index + 1).trim();
-      cookies[key] = decodeURIComponent(value);
-    }
-  }
-  return cookies;
-};
-
-// src/utils/request.tsx
-var parseRequest = (request) => {
-  const url = new URL(request.url);
-  const cookies = request.headers.get("Cookie") || "";
-  const cookieRecord = parseCookies(cookies);
-  return Object.assign(request, { pathname: url.pathname, search: url.search, location: url.pathname + url.search, cookies: cookieRecord });
-};
-
 // src/utils/staticFile.ts
-import { readFile, stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 var MIME = {
   html: "text/html; charset=utf-8",
   htm: "text/html; charset=utf-8",
@@ -150,202 +43,16 @@ var MIME = {
   pdf: "application/pdf"
 };
 async function tryServeFile(filePath) {
-  try {
-    await stat(filePath);
-  } catch {
-    return null;
-  }
   try {
     const data = await readFile(filePath);
     const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
     const contentType = MIME[ext] ?? "application/octet-stream";
-    return new Response(data.buffer, { headers: { "Content-Type": contentType } });
+    return new Response(data, { headers: { "Content-Type": contentType } });
   } catch {
     return null;
   }
 }
 
-// src/utils/response.tsx
-var ESC = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" };
-var escAttr = (s) => s.replace(/[&<>"]/g, (c) => ESC[c] ?? c);
-var escText = (s) => s.replace(/[&<>]/g, (c) => ESC[c] ?? c);
-var ATTR = {
-  className: "class",
-  htmlFor: "for",
-  httpEquiv: "http-equiv",
-  charSet: "charset",
-  crossOrigin: "crossorigin",
-  noModule: "nomodule",
-  referrerPolicy: "referrerpolicy",
-  fetchPriority: "fetchpriority",
-  hrefLang: "hreflang"
-};
-function renderHeadTag(tag, opts, selfClose = false) {
-  let attrs = "";
-  let inner = "";
-  for (const [k, v] of Object.entries(opts)) {
-    if (k === "key" || k === "children") continue;
-    if (k === "dangerouslySetInnerHTML") {
-      inner = v.__html ?? "";
-      continue;
-    }
-    const attr = ATTR[k] ?? k;
-    if (v === true) attrs += ` ${attr}`;
-    else if (v !== false && v != null) attrs += ` ${attr}="${escAttr(String(v))}"`;
-  }
-  return selfClose ? `<${tag}${attrs}>` : `<${tag}${attrs}>${inner}</${tag}>`;
-}
-var getHeadHtml = (seoData) => {
-  let html = `<title>${escText(seoData.title ?? "")}</title>`;
-  for (const opts of Object.values(seoData.meta))
-    html += renderHeadTag("meta", opts, true);
-  for (const opts of Object.values(seoData.link))
-    html += renderHeadTag("link", opts, true);
-  for (const opts of Object.values(seoData.style))
-    html += renderHeadTag("style", opts);
-  for (const opts of Object.values(seoData.script))
-    html += renderHeadTag("script", opts);
-  return html;
-};
-var getReactResponse = async (req, opts) => {
-  const App = opts.document.body;
-  const { getInitProps, getFinalProps } = opts.document;
-  const context = {
-    head: { title: "Hadars App", meta: {}, link: {}, style: {}, script: {}, status: 200 }
-  };
-  let props = {
-    ...getInitProps ? await getInitProps(req) : {},
-    location: req.location,
-    context
-  };
-  const unsuspend = { cache: /* @__PURE__ */ new Map() };
-  globalThis.__hadarsUnsuspend = unsuspend;
-  let bodyHtml;
-  try {
-    bodyHtml = await renderToString(createElement(App, props));
-  } finally {
-    globalThis.__hadarsUnsuspend = null;
-  }
-  const { context: _, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
-  const serverData = {};
-  for (const [key, entry] of unsuspend.cache) {
-    if (entry.status === "fulfilled") serverData[key] = entry.value;
-  }
-  const clientProps = {
-    ...restProps,
-    location: req.location,
-    ...Object.keys(serverData).length > 0 ? { __serverData: serverData } : {}
-  };
-  return {
-    bodyHtml,
-    clientProps,
-    status: context.head.status,
-    headHtml: getHeadHtml(context.head)
-  };
-};
-
-// src/utils/ssrHandler.ts
-var HEAD_MARKER = '<meta name="HADARS_HEAD">';
-var BODY_MARKER = '<meta name="HADARS_BODY">';
-var encoder = new TextEncoder();
-async function buildSsrHtml(bodyHtml, clientProps, headHtml, getPrecontentHtml) {
-  const [precontentHtml, postContent] = await getPrecontentHtml(headHtml);
-  const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c");
-  return precontentHtml + `<div id="app">${bodyHtml}</div><script id="hadars" type="application/json">${scriptContent}</script>` + postContent;
-}
-var makePrecontentHtmlGetter = (htmlFilePromise) => {
-  let preHead = null;
-  let postHead = null;
-  let postContent = null;
-  return async (headHtml) => {
-    if (preHead === null || postHead === null || postContent === null) {
-      const html = await htmlFilePromise;
-      const headEnd = html.indexOf(HEAD_MARKER);
-      const contentStart = html.indexOf(BODY_MARKER);
-      preHead = html.slice(0, headEnd);
-      postHead = html.slice(headEnd + HEAD_MARKER.length, contentStart);
-      postContent = html.slice(contentStart + BODY_MARKER.length);
-    }
-    return [preHead + headHtml + postHead, postContent];
-  };
-};
-async function transformStream(data, stream) {
-  const writer = stream.writable.getWriter();
-  writer.write(data);
-  writer.close();
-  const chunks = [];
-  const reader = stream.readable.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    chunks.push(value);
-  }
-  const total = chunks.reduce((n, c) => n + c.length, 0);
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const c of chunks) {
-    out.set(c, offset);
-    offset += c.length;
-  }
-  return out;
-}
-var gzipCompress = (d) => transformStream(d, new globalThis.CompressionStream("gzip"));
-var gzipDecompress = (d) => transformStream(d, new globalThis.DecompressionStream("gzip"));
-async function buildCacheEntry(res, ttl) {
-  const buf = await res.arrayBuffer();
-  const body = await gzipCompress(new Uint8Array(buf));
-  const headers = [];
-  res.headers.forEach((v, k) => {
-    if (k.toLowerCase() !== "content-encoding" && k.toLowerCase() !== "content-length") {
-      headers.push([k, v]);
-    }
-  });
-  headers.push(["content-encoding", "gzip"]);
-  return { body, status: res.status, headers, expiresAt: ttl != null ? Date.now() + ttl : null };
-}
-async function serveFromEntry(entry, req) {
-  const accept = req.headers.get("Accept-Encoding") ?? "";
-  if (accept.includes("gzip")) {
-    return new Response(entry.body.buffer, { status: entry.status, headers: entry.headers });
-  }
-  const plain = await gzipDecompress(entry.body);
-  const headers = entry.headers.filter(([k]) => k.toLowerCase() !== "content-encoding");
-  return new Response(plain.buffer, { status: entry.status, headers });
-}
-function createRenderCache(opts, handler) {
-  const store = /* @__PURE__ */ new Map();
-  const inFlight = /* @__PURE__ */ new Map();
-  return async (req, ctx) => {
-    const hadarsReq = parseRequest(req);
-    const cacheOpts = await opts(hadarsReq);
-    const key = cacheOpts?.key ?? null;
-    if (key != null) {
-      const entry = store.get(key);
-      if (entry) {
-        const expired = entry.expiresAt != null && Date.now() >= entry.expiresAt;
-        if (!expired) return serveFromEntry(entry, req);
-        store.delete(key);
-      }
-      let flight = inFlight.get(key);
-      if (!flight) {
-        const ttl = cacheOpts?.ttl;
-        flight = handler(new Request(req), ctx).then(async (res) => {
-          if (!res || res.status < 200 || res.status >= 300 || res.headers.has("set-cookie")) {
-            return null;
-          }
-          const newEntry2 = await buildCacheEntry(res, ttl);
-          store.set(key, newEntry2);
-          return newEntry2;
-        }).catch(() => null).finally(() => inFlight.delete(key));
-        inFlight.set(key, flight);
-      }
-      const newEntry = await flight;
-      if (newEntry) return serveFromEntry(newEntry, req);
-    }
-    return handler(req, ctx);
-  };
-}
-
 // src/lambda.ts
 function eventToRequest(event) {
   let method;
@@ -451,7 +158,7 @@ function createLambdaHandler(options, bundled) {
         getInitProps,
         getFinalProps
       } = await getSsrModule();
-      const { bodyHtml, clientProps, status, headHtml } = await getReactResponse(request, {
+      const { head, status, getAppBody, finalize } = await getReactResponse(request, {
         document: {
           body: Component,
           lang: "en",
@@ -460,12 +167,16 @@ function createLambdaHandler(options, bundled) {
         }
       });
       if (request.headers.get("Accept") === "application/json") {
-        const serverData = clientProps.__serverData ?? {};
+        const { clientProps: clientProps2 } = await finalize();
+        const serverData = clientProps2.__serverData ?? {};
         return new Response(JSON.stringify({ serverData }), {
           status,
           headers: { "Content-Type": "application/json; charset=utf-8" }
         });
       }
+      const bodyHtml = await getAppBody();
+      const { clientProps } = await finalize();
+      const headHtml = buildHeadHtml(head);
       const html = await buildSsrHtml(bodyHtml, clientProps, headHtml, getPrecontentHtml);
       return new Response(html, {
         status,