hadars 0.2.0 → 0.2.1

package/dist/lambda.js

@@ -1,10 +1,14 @@
 import {
-  renderPreflight,
-  renderToString
-} from "./chunk-LY5MTHFV.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";
@@ -12,122 +16,6 @@ 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();
-      try {
-        cookies[key] = decodeURIComponent(value);
-      } catch {
-        cookies[key] = 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 } from "node:fs/promises";
 var MIME = {
@@ -165,201 +53,6 @@ async function tryServeFile(filePath) {
   }
 }
 
-// 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, id, opts, selfClose = false) {
-  let attrs = ` id="${escAttr(id)}"`;
-  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}>`;
-}
-function buildHeadHtml(seoData) {
-  let html = `<title>${escText(seoData.title ?? "")}</title>`;
-  for (const [id, opts] of Object.entries(seoData.meta))
-    html += renderHeadTag("meta", id, opts, true);
-  for (const [id, opts] of Object.entries(seoData.link))
-    html += renderHeadTag("link", id, opts, true);
-  for (const [id, opts] of Object.entries(seoData.style))
-    html += renderHeadTag("style", id, opts);
-  for (const [id, opts] of Object.entries(seoData.script))
-    html += renderHeadTag("script", id, 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;
-  const element = createElement(App, props);
-  try {
-    await renderPreflight(element);
-  } finally {
-    globalThis.__hadarsUnsuspend = null;
-  }
-  const status = context.head.status;
-  const getAppBody = async () => {
-    globalThis.__hadarsUnsuspend = unsuspend;
-    try {
-      return await renderToString(element);
-    } finally {
-      globalThis.__hadarsUnsuspend = null;
-    }
-  };
-  const finalize = async () => {
-    const { context: _, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
-    const serverData = {};
-    let hasServerData = false;
-    for (const [key, entry] of unsuspend.cache) {
-      if (entry.status === "fulfilled") {
-        serverData[key] = entry.value;
-        hasServerData = true;
-      }
-    }
-    return {
-      clientProps: {
-        ...restProps,
-        location: req.location,
-        ...hasServerData ? { __serverData: serverData } : {}
-      }
-    };
-  };
-  return { head: context.head, status, getAppBody, finalize };
-};
-
-// 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 Promise.resolve(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 (headHtml) => {
-    if (preHead !== null) {
-      return [preHead + headHtml + postHead, postContent];
-    }
-    return htmlFilePromise.then((html) => {
-      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;

package/dist/ssr-render-worker.js

@@ -1031,16 +1031,17 @@ async function runFullLifecycle(serialReq) {
   };
   let props = {
     ...getInitProps ? await getInitProps(parsedReq) : {},
-    location: serialReq.location,
-    context
+    location: serialReq.location
   };
   const unsuspend = { cache: /* @__PURE__ */ new Map() };
   globalThis.__hadarsUnsuspend = unsuspend;
+  globalThis.__hadarsContext = context;
   let appHtml;
   try {
     appHtml = await renderToString(createElement(Component, props));
   } finally {
     globalThis.__hadarsUnsuspend = null;
+    globalThis.__hadarsContext = null;
   }
   const headHtml = buildHeadHtml(context.head);
   const status = context.head.status ?? 200;