hadars 0.2.0 → 0.2.2-rc.0

package/dist/chunk-H72BZXOA.js

@@ -0,0 +1,332 @@
+import {
+  renderPreflight,
+  renderToString
+} from "./chunk-LY5MTHFV.js";
+import {
+  createElement
+} from "./chunk-OS3V4CPN.js";
+
+// 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/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/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, opts.staticCtx) : {},
+    location: req.location,
+    context
+  };
+  const unsuspend = { cache: /* @__PURE__ */ new Map() };
+  globalThis.__hadarsUnsuspend = unsuspend;
+  globalThis.__hadarsContext = context;
+  const element = createElement(App, props);
+  try {
+    await renderPreflight(element);
+  } finally {
+    globalThis.__hadarsUnsuspend = null;
+    globalThis.__hadarsContext = null;
+  }
+  const status = context.head.status;
+  const getAppBody = async () => {
+    globalThis.__hadarsUnsuspend = unsuspend;
+    globalThis.__hadarsContext = context;
+    try {
+      return await renderToString(element);
+    } finally {
+      globalThis.__hadarsUnsuspend = null;
+      globalThis.__hadarsContext = null;
+    }
+  };
+  const finalize = async () => {
+    const 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);
+  };
+}
+
+export {
+  parseRequest,
+  createProxyHandler,
+  buildHeadHtml,
+  getReactResponse,
+  buildSsrHtml,
+  makePrecontentHtmlGetter,
+  createRenderCache
+};