hadars 0.1.1

package/dist/index.js

@@ -0,0 +1,263 @@
+// src/utils/Head.tsx
+import React from "react";
+import { jsx } from "react/jsx-runtime";
+var AppContext = React.createContext({
+  setTitle: () => {
+    console.warn("AppContext: setTitle called outside of provider");
+  },
+  addMeta: () => {
+    console.warn("AppContext: addMeta called outside of provider");
+  },
+  addLink: () => {
+    console.warn("AppContext: addLink called outside of provider");
+  },
+  addStyle: () => {
+    console.warn("AppContext: addStyle called outside of provider");
+  },
+  addScript: () => {
+    console.warn("AppContext: addScript called outside of provider");
+  },
+  setStatus: () => {
+  }
+});
+var AppProviderSSR = React.memo(({ children, context }) => {
+  const { head } = context;
+  const setTitle = React.useCallback((title) => {
+    head.title = title;
+  }, [head]);
+  const addMeta = React.useCallback((id, props) => {
+    head.meta[id] = props;
+  }, [head]);
+  const addLink = React.useCallback((id, props) => {
+    head.link[id] = props;
+  }, [head]);
+  const addStyle = React.useCallback((id, props) => {
+    head.style[id] = props;
+  }, [head]);
+  const addScript = React.useCallback((id, props) => {
+    head.script[id] = props;
+  }, [head]);
+  const setStatus = React.useCallback((status) => {
+    head.status = status;
+  }, [head]);
+  const contextValue = React.useMemo(() => ({
+    setTitle,
+    addMeta,
+    addLink,
+    addStyle,
+    addScript,
+    setStatus
+  }), [setTitle, addMeta, addLink, addStyle, addScript, setStatus]);
+  return /* @__PURE__ */ jsx(AppContext.Provider, { value: contextValue, children });
+});
+var AppProviderCSR = React.memo(({ children }) => {
+  const setTitle = React.useCallback((title) => {
+    document.title = title;
+  }, []);
+  const addMeta = React.useCallback((id, props) => {
+    let meta = document.querySelector(`#${id}`);
+    if (!meta) {
+      meta = document.createElement("meta");
+      meta.setAttribute("id", id);
+      document.head.appendChild(meta);
+    }
+    Object.keys(props).forEach((key) => {
+      const value = props[key];
+      if (value) {
+        meta.setAttribute(key, value);
+      }
+    });
+  }, []);
+  const addLink = React.useCallback((id, props) => {
+    let link = document.querySelector(`#${id}`);
+    if (!link) {
+      link = document.createElement("link");
+      link.setAttribute("id", id);
+      document.head.appendChild(link);
+    }
+    Object.keys(props).forEach((key) => {
+      const value = props[key];
+      if (value) {
+        link.setAttribute(key, value);
+      }
+    });
+  }, []);
+  const addStyle = React.useCallback((id, props) => {
+    let style = document.getElementById(id);
+    if (!style) {
+      style = document.createElement("style");
+      style.setAttribute("id", id);
+      document.head.appendChild(style);
+    }
+    Object.keys(props).forEach((key) => {
+      if (key === "dangerouslySetInnerHTML" && props[key] && props[key].__html) {
+        style.innerHTML = props[key].__html;
+        return;
+      }
+      const value = props[key];
+      if (value) {
+        style[key] = value;
+      }
+    });
+  }, []);
+  const addScript = React.useCallback((id, props) => {
+    let script = document.getElementById(id);
+    if (!script) {
+      script = document.createElement("script");
+      script.setAttribute("id", id);
+      document.body.appendChild(script);
+    }
+    Object.keys(props).forEach((key) => {
+      if (key === "dangerouslySetInnerHTML" && props[key] && props[key].__html) {
+        script.innerHTML = props[key].__html;
+        return;
+      }
+      const value = props[key];
+      if (value) {
+        script[key] = value;
+      }
+    });
+  }, []);
+  const contextValue = React.useMemo(() => ({
+    setTitle,
+    addMeta,
+    addLink,
+    addStyle,
+    addScript,
+    setStatus: () => {
+    }
+  }), [setTitle, addMeta, addLink, addStyle, addScript]);
+  return /* @__PURE__ */ jsx(AppContext.Provider, { value: contextValue, children });
+});
+var useApp = () => React.useContext(AppContext);
+var clientServerDataCache = /* @__PURE__ */ new Map();
+function useServerData(key, fn) {
+  const cacheKey = Array.isArray(key) ? key.join("\0") : key;
+  if (typeof window !== "undefined") {
+    if (clientServerDataCache.has(cacheKey)) {
+      return clientServerDataCache.get(cacheKey);
+    }
+    return fn();
+  }
+  const unsuspend = globalThis.__hadarsUnsuspend;
+  if (!unsuspend)
+    return void 0;
+  const existing = unsuspend.cache.get(cacheKey);
+  if (existing?.status === "suspense-resolved") {
+    try {
+      return fn();
+    } catch {
+      return void 0;
+    }
+  }
+  if (!existing) {
+    let result;
+    try {
+      result = fn();
+    } catch (thrown) {
+      if (thrown !== null && typeof thrown === "object" && typeof thrown.then === "function") {
+        const suspensePromise = Promise.resolve(thrown).then(
+          () => {
+            unsuspend.cache.set(cacheKey, { status: "suspense-resolved" });
+          },
+          () => {
+            unsuspend.cache.set(cacheKey, { status: "suspense-resolved" });
+          }
+        );
+        unsuspend.cache.set(cacheKey, { status: "pending", promise: suspensePromise });
+        unsuspend.hasPending = true;
+        return void 0;
+      }
+      throw thrown;
+    }
+    const isThenable = result !== null && typeof result === "object" && typeof result.then === "function";
+    if (!isThenable) {
+      const value = result;
+      unsuspend.cache.set(cacheKey, { status: "fulfilled", value });
+      return value;
+    }
+    const promise = result.then(
+      (value) => {
+        unsuspend.cache.set(cacheKey, { status: "fulfilled", value });
+      },
+      (reason) => {
+        unsuspend.cache.set(cacheKey, { status: "rejected", reason });
+      }
+    );
+    unsuspend.cache.set(cacheKey, { status: "pending", promise });
+    unsuspend.hasPending = true;
+    return void 0;
+  }
+  if (existing.status === "pending") {
+    unsuspend.hasPending = true;
+    return void 0;
+  }
+  if (existing.status === "rejected")
+    throw existing.reason;
+  return existing.value;
+}
+var genRandomId = () => {
+  return "head-" + Math.random().toString(36).substr(2, 9);
+};
+var Head = React.memo(({ children, status }) => {
+  const {
+    setStatus,
+    setTitle,
+    addMeta,
+    addLink,
+    addStyle,
+    addScript
+  } = useApp();
+  if (status) {
+    setStatus(status);
+  }
+  React.Children.forEach(children, (child) => {
+    if (!React.isValidElement(child))
+      return;
+    const childType = child.type;
+    const childProps = child.props;
+    const id = childProps["id"] || genRandomId();
+    switch (childType) {
+      case "title": {
+        setTitle(childProps["children"]);
+        return;
+      }
+      case "meta": {
+        addMeta(id.toString(), childProps);
+        return;
+      }
+      case "link": {
+        addLink(id.toString(), childProps);
+        return;
+      }
+      case "script": {
+        addScript(id.toString(), childProps);
+        return;
+      }
+      case "style": {
+        addStyle(id.toString(), childProps);
+        return;
+      }
+      default: {
+        console.warn(`HadarsHead: Unsupported child type: ${childType}`);
+        return;
+      }
+    }
+  });
+  return null;
+});
+
+// src/index.tsx
+var HadarsContext = typeof window === "undefined" ? AppProviderSSR : AppProviderCSR;
+function loadModule(path) {
+  return import(
+    /* webpackIgnore: true */
+    path
+  );
+}
+export {
+  HadarsContext,
+  Head as HadarsHead,
+  loadModule,
+  useServerData
+};

package/dist/loader.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loader_exports = {};
+__export(loader_exports, {
+  default: () => loader
+});
+module.exports = __toCommonJS(loader_exports);
+const LOAD_MODULE_RE = /\bloadModule\s*(?:<.*?>\s*)?\(\s*(['"`])((?:\\.|(?!\1)[^\\])*)\1\s*\)/gs;
+function loader(source) {
+  const isServer = this.target === "node" || this.target === "async-node";
+  return source.replace(LOAD_MODULE_RE, (_match, quote, modulePath) => {
+    if (isServer) {
+      return `Promise.resolve(require(${quote}${modulePath}${quote}))`;
+    } else {
+      return `import(${quote}${modulePath}${quote})`;
+    }
+  });
+}

package/dist/ssr-render-worker.js

@@ -0,0 +1,92 @@
+// src/ssr-render-worker.ts
+import { workerData, parentPort } from "node:worker_threads";
+import { createRequire } from "node:module";
+import pathMod from "node:path";
+import { pathToFileURL } from "node:url";
+var { ssrBundlePath } = workerData;
+var _React = null;
+var _renderToStaticMarkup = null;
+var _renderToString = null;
+var _renderToReadableStream = null;
+var _Component = null;
+async function init() {
+  if (_React && _renderToStaticMarkup && _renderToString && _renderToReadableStream && _Component)
+    return;
+  const req = createRequire(pathMod.resolve(process.cwd(), "__ninety_fake__.js"));
+  if (!_React) {
+    const reactPath = pathToFileURL(req.resolve("react")).href;
+    const reactMod = await import(reactPath);
+    _React = reactMod.default ?? reactMod;
+  }
+  if (!_renderToString || !_renderToStaticMarkup) {
+    const serverPath = pathToFileURL(req.resolve("react-dom/server")).href;
+    const serverMod = await import(serverPath);
+    _renderToString = serverMod.renderToString;
+    _renderToStaticMarkup = serverMod.renderToStaticMarkup;
+  }
+  if (!_renderToReadableStream) {
+    const browserPath = pathToFileURL(req.resolve("react-dom/server.browser")).href;
+    const browserMod = await import(browserPath);
+    _renderToReadableStream = browserMod.renderToReadableStream;
+  }
+  if (!_Component) {
+    const ssrMod = await import(pathToFileURL(ssrBundlePath).href);
+    _Component = ssrMod.default;
+  }
+}
+function buildReactPage(R, appProps, clientProps) {
+  return R.createElement(
+    R.Fragment,
+    null,
+    R.createElement(
+      "div",
+      { id: "app" },
+      R.createElement(_Component, appProps)
+    ),
+    R.createElement("script", {
+      id: "hadars",
+      type: "application/json",
+      dangerouslySetInnerHTML: {
+        __html: JSON.stringify({ hadars: { props: clientProps } })
+      }
+    })
+  );
+}
+parentPort.on("message", async (msg) => {
+  const { id, type } = msg;
+  try {
+    await init();
+    const R = _React;
+    const unsuspend = msg.appProps?.context?._unsuspend ?? null;
+    if (type === "renderStream") {
+      const { appProps: appProps2, clientProps: clientProps2 } = msg;
+      const ReactPage2 = buildReactPage(R, appProps2, clientProps2);
+      globalThis.__hadarsUnsuspend = unsuspend;
+      const stream = await _renderToReadableStream(ReactPage2);
+      globalThis.__hadarsUnsuspend = null;
+      const reader = stream.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        parentPort.postMessage({ id, type: "chunk", chunk: value }, [value.buffer]);
+      }
+      parentPort.postMessage({ id, type: "done" });
+      return;
+    }
+    const { appProps, clientProps } = msg;
+    const ReactPage = buildReactPage(R, appProps, clientProps);
+    globalThis.__hadarsUnsuspend = unsuspend;
+    const html = _renderToString(ReactPage);
+    globalThis.__hadarsUnsuspend = null;
+    parentPort.postMessage({ id, html });
+  } catch (err) {
+    globalThis.__hadarsUnsuspend = null;
+    const errMsg = err?.message ?? String(err);
+    if (type === "renderStream") {
+      parentPort.postMessage({ id, type: "error", error: errMsg });
+    } else {
+      parentPort.postMessage({ id, error: errMsg });
+    }
+  }
+});