hadars 0.1.1

package/dist/index.cjs

@@ -0,0 +1,303 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.tsx
+var src_exports = {};
+__export(src_exports, {
+  HadarsContext: () => HadarsContext,
+  HadarsHead: () => Head,
+  loadModule: () => loadModule,
+  useServerData: () => useServerData
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/utils/Head.tsx
+var import_react = __toESM(require("react"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+var AppContext = import_react.default.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 = import_react.default.memo(({ children, context }) => {
+  const { head } = context;
+  const setTitle = import_react.default.useCallback((title) => {
+    head.title = title;
+  }, [head]);
+  const addMeta = import_react.default.useCallback((id, props) => {
+    head.meta[id] = props;
+  }, [head]);
+  const addLink = import_react.default.useCallback((id, props) => {
+    head.link[id] = props;
+  }, [head]);
+  const addStyle = import_react.default.useCallback((id, props) => {
+    head.style[id] = props;
+  }, [head]);
+  const addScript = import_react.default.useCallback((id, props) => {
+    head.script[id] = props;
+  }, [head]);
+  const setStatus = import_react.default.useCallback((status) => {
+    head.status = status;
+  }, [head]);
+  const contextValue = import_react.default.useMemo(() => ({
+    setTitle,
+    addMeta,
+    addLink,
+    addStyle,
+    addScript,
+    setStatus
+  }), [setTitle, addMeta, addLink, addStyle, addScript, setStatus]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AppContext.Provider, { value: contextValue, children });
+});
+var AppProviderCSR = import_react.default.memo(({ children }) => {
+  const setTitle = import_react.default.useCallback((title) => {
+    document.title = title;
+  }, []);
+  const addMeta = import_react.default.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 = import_react.default.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 = import_react.default.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 = import_react.default.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 = import_react.default.useMemo(() => ({
+    setTitle,
+    addMeta,
+    addLink,
+    addStyle,
+    addScript,
+    setStatus: () => {
+    }
+  }), [setTitle, addMeta, addLink, addStyle, addScript]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AppContext.Provider, { value: contextValue, children });
+});
+var useApp = () => import_react.default.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 = import_react.default.memo(({ children, status }) => {
+  const {
+    setStatus,
+    setTitle,
+    addMeta,
+    addLink,
+    addStyle,
+    addScript
+  } = useApp();
+  if (status) {
+    setStatus(status);
+  }
+  import_react.default.Children.forEach(children, (child) => {
+    if (!import_react.default.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
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HadarsContext,
+  HadarsHead,
+  loadModule,
+  useServerData
+});

package/dist/index.d.ts

@@ -0,0 +1,160 @@
+import * as React$1 from 'react';
+import React__default, { MetaHTMLAttributes, LinkHTMLAttributes, StyleHTMLAttributes, ScriptHTMLAttributes } from 'react';
+
+type HadarsGetInitialProps<T extends {}> = (req: HadarsRequest) => Promise<T> | T;
+type HadarsGetClientProps<T extends {}> = (props: T) => Promise<T> | T;
+type HadarsGetAfterRenderProps<T extends {}> = (props: HadarsProps<T>, html: string) => Promise<HadarsProps<T>> | HadarsProps<T>;
+type HadarsGetFinalProps<T extends {}> = (props: HadarsProps<T>) => Promise<T> | T;
+type HadarsApp<T extends {}> = React.FC<HadarsProps<T>>;
+type HadarsEntryModule<T extends {}> = {
+    default: HadarsApp<T>;
+    getInitProps?: HadarsGetInitialProps<T>;
+    getAfterRenderProps?: HadarsGetAfterRenderProps<T>;
+    getFinalProps?: HadarsGetFinalProps<T>;
+    getClientProps?: HadarsGetClientProps<T>;
+};
+interface AppHead {
+    title: string;
+    status: number;
+    meta: Record<string, MetaProps>;
+    link: Record<string, LinkProps>;
+    style: Record<string, StyleProps>;
+    script: Record<string, ScriptProps>;
+}
+type UnsuspendEntry = {
+    status: 'pending';
+    promise: Promise<unknown>;
+} | {
+    status: 'fulfilled';
+    value: unknown;
+} | {
+    status: 'suspense-resolved';
+} | {
+    status: 'rejected';
+    reason: unknown;
+};
+/** @internal Populated by the framework's render loop — use useServerData() instead. */
+interface AppUnsuspend {
+    cache: Map<string, UnsuspendEntry>;
+    hasPending: boolean;
+}
+interface AppContext {
+    path?: string;
+    head: AppHead;
+    /** @internal Framework use only — use the useServerData() hook instead. */
+    _unsuspend?: AppUnsuspend;
+}
+type HadarsEntryBase = {
+    location: string;
+    context: AppContext;
+};
+type HadarsProps<T extends {}> = T & HadarsEntryBase;
+type MetaProps = MetaHTMLAttributes<HTMLMetaElement>;
+type LinkProps = LinkHTMLAttributes<HTMLLinkElement>;
+type StyleProps = StyleHTMLAttributes<HTMLStyleElement>;
+type ScriptProps = ScriptHTMLAttributes<HTMLScriptElement>;
+interface HadarsOptions {
+    port?: number;
+    entry: string;
+    baseURL?: string;
+    swcPlugins?: SwcPluginList;
+    proxy?: Record<string, string> | ((req: HadarsRequest) => Promise<Response | null> | Response | null);
+    proxyCORS?: boolean;
+    define?: Record<string, string>;
+    /**
+     * Bun WebSocket handler passed directly to `Bun.serve()`.
+     * Ignored on Node.js and Deno — use `fetch` + a third-party WS library there.
+     * Pass a `Bun.WebSocketHandler` instance here when running on Bun.
+     */
+    websocket?: unknown;
+    fetch?: (req: HadarsRequest) => Promise<Response | undefined> | Response | undefined;
+    wsPath?: string;
+    hmrPort?: number;
+    /**
+     * Parallelism level for `run()` mode (production server). Defaults to 1.
+     * Has no effect in `dev()` mode.
+     *
+     * **Node.js** — forks this many worker processes via `node:cluster`, each
+     * binding to the same port via OS round-robin. Set to `os.cpus().length`
+     * to saturate all CPU cores.
+     *
+     * **Bun / Deno** — creates a `node:worker_threads` render pool of this size.
+     * Each thread handles the synchronous `renderToString` step, freeing the
+     * main event loop for I/O. Only applies when `streaming` is `false` (the default).
+     */
+    workers?: number;
+    /**
+     * Whether to use streaming SSR (`renderToReadableStream`) for rendering React
+     * components. Defaults to `false`. Set to `true` to use streaming via
+     * `renderToReadableStream` instead of the synchronous `renderToString`.
+     */
+    streaming?: boolean;
+}
+type SwcPluginItem = string | [string, Record<string, unknown>] | {
+    path: string;
+    options?: Record<string, unknown>;
+} | ((...args: any[]) => any);
+type SwcPluginList = SwcPluginItem[];
+interface HadarsRequest extends Request {
+    pathname: string;
+    search: string;
+    location: string;
+    cookies: Record<string, string>;
+}
+
+/**
+ * Fetch async data on the server during SSR. Returns `undefined` on the first
+ * render pass(es) while the promise is in flight; returns the resolved value
+ * once the framework's render loop has awaited it.
+ *
+ * On the client the pre-resolved value is read from the hydration cache
+ * serialised into the page by the server, so no fetch is issued in the browser.
+ *
+ * The `key` (string or array of strings) uniquely identifies the cached value
+ * across all SSR render passes and client hydration — it must be stable and
+ * unique within the page.
+ *
+ * `fn` may return a `Promise<T>` (normal async usage), return `T` synchronously,
+ * or throw a thenable (React Suspense protocol). All three cases are handled:
+ * - Async `Promise<T>`: awaited across render iterations, result cached.
+ * - Synchronous return: value stored immediately, returned on the same pass.
+ * - Thrown thenable (e.g. `useQuery({ suspense: true })`): the thrown promise is
+ *   awaited, the cache entry is then cleared so that the next render re-calls
+ *   `fn()` — at that point the Suspense hook returns synchronously.
+ *
+ * @example
+ * const user = useServerData('current_user', () => db.getUser(id));
+ * const post = useServerData(['post', postId], () => db.getPost(postId));
+ * if (!user) return null; // undefined while pending on the first SSR pass
+ */
+declare function useServerData<T>(key: string | string[], fn: () => Promise<T> | T): T | undefined;
+declare const Head: React__default.FC<{
+    children?: React__default.ReactNode;
+    status?: number;
+}>;
+
+declare const HadarsContext: React$1.FC<{
+    children: React.ReactNode;
+    context: AppContext;
+}>;
+/**
+ * Dynamically loads a module with target-aware behaviour:
+ *
+ * - **Browser** (after loader transform): becomes `import('./path')`, which
+ *   rspack splits into a separate chunk for true code splitting.
+ * - **SSR** (after loader transform): becomes
+ *   `Promise.resolve(require('./path'))`, which rspack bundles statically.
+ *
+ * The hadars rspack loader must be active for the transform to apply.
+ * This runtime fallback uses a plain dynamic import (no code splitting).
+ *
+ * @example
+ * // Code-split React component:
+ * const MyComp = React.lazy(() => loadModule('./MyComp'));
+ *
+ * // Dynamic data:
+ * const { default: fn } = await loadModule<typeof import('./util')>('./util');
+ */
+declare function loadModule<T = any>(path: string): Promise<T>;
+
+export { HadarsApp, HadarsContext, HadarsEntryModule, HadarsGetAfterRenderProps, HadarsGetClientProps, HadarsGetFinalProps, HadarsGetInitialProps, Head as HadarsHead, HadarsOptions, HadarsProps, HadarsRequest, loadModule, useServerData };