hadars 0.4.1 → 0.4.2

package/src/slim-react/renderContext.ts

@@ -1,294 +0,0 @@
-/**
- * Render-time context for tree-position-based `useId` and React Context values.
- *
- * State lives on `globalThis` rather than module-level variables so that
- * multiple slim-react instances (the render worker's direct import and the
- * SSR bundle's bundled copy) share the same singletons without coordination.
- *
- * Context values are stored in a plain Map that is created per render call.
- * Node.js is single-threaded: only one render is executing between any two
- * await points. The renderer captures the map reference before every await
- * and restores it in the continuation, so concurrent renders stay isolated
- * without any external dependencies.
- */
-
-// The context map for the render that is currently executing (between awaits).
-// Kept on globalThis so both slim-react instances share the same slot.
-const MAP_KEY = "__slimReactContextMap";
-const _g = globalThis as any;
-if (!("__slimReactContextMap" in _g)) _g[MAP_KEY] = null;
-
-/**
- * Swap in a new context map and return the previous one.
- * Called at render entry-points and at every await/then continuation to
- * restore the correct map for the resuming render.
- */
-export function swapContextMap(
-  map: Map<object, unknown> | null,
-): Map<object, unknown> | null {
-  const prev: Map<object, unknown> | null = _g[MAP_KEY];
-  _g[MAP_KEY] = map;
-  return prev;
-}
-
-/** Return the active map without changing it (used to capture before an await). */
-export function captureMap(): Map<object, unknown> | null {
-  return _g[MAP_KEY];
-}
-
-const UNSUSPEND_KEY = "__hadarsUnsuspend";
-
-/**
- * Capture the current __hadarsUnsuspend slot alongside captureMap() before
- * an async boundary.  Because useServerData reads this global, concurrent
- * renders would corrupt each other's cache if it weren't restored after every
- * await continuation — exactly like the context map itself.
- */
-export function captureUnsuspend(): unknown {
-  return _g[UNSUSPEND_KEY];
-}
-
-/** Restore a previously captured __hadarsUnsuspend slot after an await. */
-export function restoreUnsuspend(u: unknown): void {
-  _g[UNSUSPEND_KEY] = u;
-}
-
-/** Read the current value for a context within the active render. */
-export function getContextValue<T>(context: object): T {
-  const map: Map<object, unknown> | null = _g[MAP_KEY];
-  if (map && map.has(context)) return map.get(context) as T;
-  const c = context as any;
-  return ("_defaultValue" in c ? c._defaultValue : c._currentValue) as T;
-}
-
-/**
- * Push a new Provider value into the active map.
- * Returns the previous value so the caller can restore it on exit.
- */
-export function pushContextValue(context: object, value: unknown): unknown {
-  let map: Map<object, unknown> | null = _g[MAP_KEY];
-  // Lazily create the Map on the first Provider encountered — renders without
-  // any Context.Provider never allocate a Map at all.
-  if (map === null) {
-    map = new Map();
-    _g[MAP_KEY] = map;
-  }
-  const c = context as any;
-  const prev = map.has(context)
-    ? map.get(context)
-    : ("_defaultValue" in c ? c._defaultValue : c._currentValue);
-  map.set(context, value);
-  return prev;
-}
-
-/** Restore a previously saved context value (called by Provider on exit). */
-export function popContextValue(context: object, prev: unknown): void {
-  (_g[MAP_KEY] as Map<object, unknown> | null)?.set(context, prev);
-}
-
-// TreeContext matches React 19's representation exactly:
-// `id` is a packed bitfield with a leading sentinel `1` bit followed by tree
-// path slots. The most-recently-pushed slot occupies the HIGHEST non-sentinel
-// bits, matching React 19's Fizz `pushTreeContext` bit-packing order.
-// `overflow` accumulates segments that no longer fit in the 30-bit budget,
-// prepended newest-first (same as React 19).
-export interface TreeContext {
-  id: number;       // bitfield with sentinel; 1 = empty (just sentinel, no data)
-  overflow: string; // base-32 partial path segments that overflowed
-}
-
-interface RenderState {
-  currentTreeContext: TreeContext;
-  localIdCounter: number;
-  idPrefix: string;
-}
-
-const GLOBAL_KEY = "__slimReactRenderState";
-// React 19's initial context is { id: 1, overflow: "" } — sentinel bit only.
-const EMPTY: TreeContext = { id: 1, overflow: "" };
-
-/**
- * Module-level cache for the shared RenderState singleton.
- * Avoids a `globalThis[key]` property lookup on every push/pop/reset call
- * (which happens multiple times per component during rendering).
- * Both slim-react instances (direct import + SSR bundle copy) initialise the
- * same `globalThis[GLOBAL_KEY]` object and then each cache that same reference,
- * so correctness is preserved.
- */
-let _stateCache: RenderState | null = null;
-
-function s(): RenderState {
-  if (_stateCache !== null) return _stateCache;
-  if (!_g[GLOBAL_KEY]) {
-    _g[GLOBAL_KEY] = { currentTreeContext: { ...EMPTY }, localIdCounter: 0, idPrefix: "" };
-  }
-  _stateCache = _g[GLOBAL_KEY] as RenderState;
-  return _stateCache;
-}
-
-/**
- * Flat primitive stacks for pushTreeContext / popTreeContext.
- *
- * Instead of allocating a new `{ id, overflow }` object on every array child
- * (which is the hot path — called once per child in every array render), we
- * save the two scalar fields into parallel pre-allocated arrays and return a
- * numeric depth index.  No heap objects are allocated in the push. Both arrays
- * grow lazily and are never shrunk, so after a few renders they stop growing.
- */
-const _treeIdStack: number[]       = [];
-const _treeOvStack: string[]        = [];
-let   _treeDepth   = 0;
-
-export function resetRenderState(idPrefix = "") {
-  const st = s();
-  // Mutate in place — avoids allocating a new TreeContext object each render.
-  st.currentTreeContext.id       = EMPTY.id;
-  st.currentTreeContext.overflow = EMPTY.overflow;
-  st.localIdCounter = 0;
-  st.idPrefix       = idPrefix;
-  _treeDepth        = 0;
-}
-
-export function setIdPrefix(prefix: string) {
-  s().idPrefix = prefix;
-}
-
-/**
- * Push a new level onto the tree context — matches React 19's Fizz
- * `pushTreeContext` exactly:
- *   - new slot occupies the HIGHER bit positions (above the old base data)
- *   - on overflow, the LOWEST bits of the old data move to the overflow string
- *     (rounded to a multiple of 5 so base-32 digits align on byte boundaries)
- */
-/**
- * Push a new tree-context level.  Returns a numeric depth token (not an
- * object) so the caller can pop with zero heap allocation in the common case.
- */
-export function pushTreeContext(totalChildren: number, index: number): number {
-  const st  = s();
-  const ctx = st.currentTreeContext;
-  const depth = _treeDepth++;
-
-  // Save current scalars into the flat stacks — no object allocation.
-  _treeIdStack[depth] = ctx.id;
-  _treeOvStack[depth] = ctx.overflow;
-
-  const baseIdWithLeadingBit = ctx.id;
-  const baseOverflow         = ctx.overflow;
-  const baseLength = 31 - Math.clz32(baseIdWithLeadingBit);
-  let   baseId     = baseIdWithLeadingBit & ~(1 << baseLength);
-
-  const slot    = index + 1;
-  const newBits = 32 - Math.clz32(totalChildren);
-  const length  = newBits + baseLength;
-
-  // Mutate currentTreeContext in place — avoids allocating a new object.
-  if (30 < length) {
-    const overflowBits = baseLength - (baseLength % 5);
-    const overflowStr  = (baseId & ((1 << overflowBits) - 1)).toString(32);
-    baseId >>= overflowBits;
-    const newBaseLength = baseLength - overflowBits;
-    ctx.id       = (1 << (newBits + newBaseLength)) | (slot << newBaseLength) | baseId;
-    ctx.overflow = overflowStr + baseOverflow;
-  } else {
-    ctx.id       = (1 << length) | (slot << baseLength) | baseId;
-    ctx.overflow = baseOverflow;
-  }
-  return depth;
-}
-
-export function popTreeContext(depth: number): void {
-  const ctx    = s().currentTreeContext;
-  ctx.id       = _treeIdStack[depth]!;
-  ctx.overflow = _treeOvStack[depth]!;
-  _treeDepth   = depth;
-}
-
-export function pushComponentScope(): number {
-  const st = s();
-  const saved = st.localIdCounter;
-  st.localIdCounter = 0;
-  return saved;
-}
-
-export function popComponentScope(saved: number) {
-  s().localIdCounter = saved;
-}
-
-/** True if the current component has called useId at least once. */
-export function componentCalledUseId(): boolean {
-  return s().localIdCounter > 0;
-}
-
-export interface ContextSnapshot {
-  tree: TreeContext;
-  localId: number;
-  treeDepth: number;
-  /** Saved parent-context id values for the stack slots 0..treeDepth-1.
-   *  Required so that concurrent renders cannot corrupt popTreeContext calls
-   *  that run after an await continuation. */
-  idStack: number[];
-  ovStack: string[];
-}
-
-export function snapshotContext(): ContextSnapshot {
-  const st    = s();
-  const ctx   = st.currentTreeContext;
-  const depth = _treeDepth;
-  return {
-    tree:      { id: ctx.id, overflow: ctx.overflow },
-    localId:   st.localIdCounter,
-    treeDepth: depth,
-    // Snapshot the live stack so that popTreeContext reads correct saved values
-    // even if another concurrent render's resetRenderState stomped the arrays.
-    idStack:   _treeIdStack.slice(0, depth),
-    ovStack:   _treeOvStack.slice(0, depth),
-  };
-}
-
-export function restoreContext(snap: ContextSnapshot): void {
-  const st  = s();
-  const ctx = st.currentTreeContext;
-  ctx.id            = snap.tree.id;
-  ctx.overflow      = snap.tree.overflow;
-  st.localIdCounter = snap.localId;
-  _treeDepth        = snap.treeDepth;
-  // Restore the stack so subsequent popTreeContext calls see the right values.
-  for (let i = 0; i < snap.treeDepth; i++) {
-    _treeIdStack[i] = snap.idStack[i]!;
-    _treeOvStack[i] = snap.ovStack[i]!;
-  }
-}
-
-/**
- * Produce the base-32 tree path string from the current context.
- * Strips the sentinel bit then concatenates stripped_id + overflow —
- * the same formula React 19 uses in both its Fizz SSR renderer and
- * the client-side `mountId`.
- */
-function getTreeId(): string {
-  const { id, overflow } = s().currentTreeContext;
-  if (id === 1) return overflow; // sentinel only → no local path segment
-  const stripped = (id & ~(1 << (31 - Math.clz32(id)))).toString(32);
-  return stripped + overflow;
-}
-
-/**
- * Generate a `useId`-compatible ID for the current call site.
- *
- * Format: `_R_<idPrefix><treeId>_`  (React 19.2+)
- *   with an optional `H<n>` suffix for the n-th useId call in the same
- *   component (matching React 19's `localIdCounter` behaviour).
- *
- * React 19.2 uses `_R_<id>_` (underscore-delimited).
- * This matches React 19.2's output from both renderToString (Fizz) and
- * hydrateRoot, so SSR-generated IDs agree with client React during hydration.
- */
-export function makeId(): string {
-  const st = s();
-  const treeId = getTreeId();
-  const n = st.localIdCounter++;
-  let id = "_R_" + st.idPrefix + treeId;
-  if (n > 0) id += "H" + n.toString(32);
-  return id + "_";
-}

package/src/slim-react/types.ts

@@ -1,33 +0,0 @@
-// ---- Symbols ----
-// Use the same symbols as React so elements produced here are wire-compatible
-// with elements produced by the real React JSX runtime (e.g. when a library
-// uses React.createElement directly).  This means the SSR bundle can be aliased
-// to slim-react without any element shape mismatch.
-//
-// React 19 introduced "react.transitional.element" as the canonical $$typeof for
-// elements created by createElement / the jsx-runtime.  We keep the old
-// "react.element" as slim-react's own emission symbol (unchanged wire format for
-// SSR HTML — it makes no difference) and accept both in the renderer.
-export const SLIM_ELEMENT   = Symbol.for("react.element");
-export const REACT19_ELEMENT = Symbol.for("react.transitional.element");
-export const FRAGMENT_TYPE  = Symbol.for("react.fragment");
-export const SUSPENSE_TYPE  = Symbol.for("react.suspense");
-
-// ---- Types ----
-export type ComponentFunction = (props: any) => SlimNode;
-
-export type SlimElement = {
-  $$typeof: typeof SLIM_ELEMENT;
-  type: string | ComponentFunction | symbol;
-  props: Record<string, any>;
-  key: string | number | null;
-};
-
-export type SlimNode =
-  | SlimElement
-  | string
-  | number
-  | boolean
-  | null
-  | undefined
-  | SlimNode[];

package/src/source/context.ts

@@ -1,113 +0,0 @@
-/**
- * Gatsby sourceNodes context shim.
- *
- * Gatsby passes a rich object to each source plugin's `sourceNodes` function.
- * We implement the subset that the vast majority of CMS source plugins actually
- * use so that existing plugins work without modification.
- */
-
-import { createHash } from 'node:crypto';
-import { EventEmitter } from 'node:events';
-import type { NodeStore, HadarsNode } from './store';
-
-// ── Types ─────────────────────────────────────────────────────────────────────
-
-export interface GatsbyCache {
-    get(key: string): Promise<unknown>;
-    set(key: string, value: unknown): Promise<void>;
-}
-
-export interface GatsbyReporter {
-    info(message: string): void;
-    warn(message: string): void;
-    error(message: string, err?: Error): void;
-    panic(message: string, err?: Error): never;
-    activityTimer(name: string): { start(): void; end(): void };
-    verbose(message: string): void;
-}
-
-export interface GatsbyActions {
-    createNode(node: HadarsNode): void;
-    deleteNode(node: { id: string }): void;
-    touchNode(node: { id: string }): void;
-}
-
-export interface GatsbyNodeHelpers {
-    actions: GatsbyActions;
-    createNodeId(input: string): string;
-    createContentDigest(content: unknown): string;
-    getNode(id: string): HadarsNode | undefined;
-    getNodes(): HadarsNode[];
-    getNodesByType(type: string): HadarsNode[];
-    cache: GatsbyCache;
-    reporter: GatsbyReporter;
-    // Gatsby passes these; many plugins destructure but never call them
-    store: unknown;
-    emitter: unknown;
-    tracing: unknown;
-    schema: unknown;
-    /** Available in Gatsby 4+ — mostly unused by source plugins. */
-    parentSpan: unknown;
-}
-
-// ── Factory ───────────────────────────────────────────────────────────────────
-
-export function makeGatsbyContext(
-    store: NodeStore,
-    pluginName: string,
-    pluginOptions: Record<string, unknown> = {},
-    emitter: EventEmitter = new EventEmitter(),
-): GatsbyNodeHelpers {
-    // A simple in-memory cache per plugin instance
-    const cacheMap = new Map<string, unknown>();
-    const cache: GatsbyCache = {
-        get: (key) => Promise.resolve(cacheMap.get(key)),
-        set: (key, value) => { cacheMap.set(key, value); return Promise.resolve(); },
-    };
-
-    const reporter: GatsbyReporter & Record<string, unknown> = {
-        info:    (msg) => console.log(`[${pluginName}] ${msg}`),
-        warn:    (msg) => console.warn(`[${pluginName}] WARN: ${msg}`),
-        error:   (msg, err) => console.error(`[${pluginName}] ERROR: ${msg}`, err ?? ''),
-        panic:   (msg, err) => { console.error(`[${pluginName}] PANIC: ${msg}`, err ?? ''); process.exit(1); },
-        verbose: (msg) => { if (process.env.HADARS_VERBOSE) console.log(`[${pluginName}] ${msg}`); },
-        activityTimer: (name) => ({
-            start: () => { if (process.env.HADARS_VERBOSE) console.log(`[${pluginName}] ▶ ${name}`); },
-            end:   () => { if (process.env.HADARS_VERBOSE) console.log(`[${pluginName}] ■ ${name}`); },
-        }),
-        // Gatsby 4+ reporter extras — used by some plugins but safe to no-op
-        setErrorMap: () => {},
-        log:         (msg: string) => console.log(`[${pluginName}] ${msg}`),
-        success:     (msg: string) => console.log(`[${pluginName}] ✓ ${msg}`),
-    };
-
-    const actions: GatsbyActions = {
-        createNode: (node) => store.createNode(node),
-        deleteNode: ({ id }) => {
-            // NodeStore doesn't implement delete — it's rarely needed on a first run.
-            // Warn so plugin authors know the operation was ignored.
-            console.warn(`[${pluginName}] deleteNode("${id}") called but is not supported by hadars — node will remain in the store.`);
-        },
-        touchNode: () => { /* no-op — only relevant for Gatsby's caching layer */ },
-    };
-
-    return {
-        actions,
-        createNodeId:       (input) => createHash('sha256').update(pluginName + input).digest('hex'),
-        createContentDigest: (content) => {
-            const str = typeof content === 'string' ? content : JSON.stringify(content);
-            return createHash('md5').update(str).digest('hex');
-        },
-        getNode:         (id) => store.getNode(id),
-        getNodes:        ()   => store.getNodes(),
-        getNodesByType:  (t)  => store.getNodesByType(t),
-        cache,
-        reporter,
-        // Stubs for rarely-used Gatsby internals that plugins may destructure
-        store:      {},
-        emitter,
-        tracing:    { startSpan: () => ({ finish: () => {} }) },
-        schema:     {},
-        parentSpan: null,
-    };
-}

package/src/source/graphiql.ts

@@ -1,101 +0,0 @@
-/**
- * GraphiQL dev endpoint — serves the GraphiQL IDE at GET /__hadars/graphql
- * and a JSON GraphQL API at POST /__hadars/graphql.
- *
- * Only mounted in dev mode when config.sources is present.
- */
-
-import type { GraphQLExecutor } from '../types/hadars';
-
-export const GRAPHQL_PATH = '/__hadars/graphql';
-
-// GraphiQL HTML shell — UMD bundles from unpkg (dev-only).
-// Using UMD avoids ES module peer-dependency conflicts (CodeMirror, etc.)
-// and matches the official GraphiQL standalone embedding guide.
-const GRAPHIQL_HTML = `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>GraphiQL — hadars</title>
-  <style>
-    * { box-sizing: border-box; margin: 0; padding: 0; }
-    body { height: 100vh; overflow: hidden; }
-    #graphiql { height: 100vh; }
-  </style>
-  <link rel="stylesheet" href="https://unpkg.com/graphiql@3/graphiql.min.css" />
-</head>
-<body>
-  <div id="graphiql"></div>
-  <script src="https://unpkg.com/react@18/umd/react.production.min.js" crossorigin></script>
-  <script src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js" crossorigin></script>
-  <script src="https://unpkg.com/graphiql@3/graphiql.min.js" crossorigin></script>
-  <script>
-    const root = ReactDOM.createRoot(document.getElementById('graphiql'));
-    root.render(
-      React.createElement(GraphiQL, {
-        fetcher: GraphiQL.createFetcher({ url: '${GRAPHQL_PATH}' }),
-      })
-    );
-  </script>
-</body>
-</html>`;
-
-/**
- * Returns a fetch handler that covers GET and POST for `/__hadars/graphql`.
- * Returns `undefined` for any other path so callers can chain normally.
- */
-export function createGraphiqlHandler(
-    executor: GraphQLExecutor,
-): (req: Request) => Promise<Response | undefined> {
-    return async (req: Request): Promise<Response | undefined> => {
-        let url: URL;
-        try {
-            url = new URL(req.url);
-        } catch {
-            return undefined;
-        }
-        if (url.pathname !== GRAPHQL_PATH) return undefined;
-
-        // GET — serve GraphiQL IDE
-        if (req.method === 'GET') {
-            return new Response(GRAPHIQL_HTML, {
-                headers: { 'Content-Type': 'text/html; charset=utf-8' },
-            });
-        }
-
-        // POST — execute GraphQL query
-        if (req.method === 'POST') {
-            let body: { query?: string; variables?: Record<string, unknown>; operationName?: string };
-            try {
-                body = await req.json();
-            } catch {
-                return new Response(JSON.stringify({ errors: [{ message: 'Invalid JSON body' }] }), {
-                    status: 400,
-                    headers: { 'Content-Type': 'application/json' },
-                });
-            }
-
-            if (typeof body.query !== 'string' || !body.query.trim()) {
-                return new Response(JSON.stringify({ errors: [{ message: 'Missing or invalid "query" field — must be a non-empty string' }] }), {
-                    status: 400,
-                    headers: { 'Content-Type': 'application/json' },
-                });
-            }
-
-            try {
-                const result = await executor(body.query, body.variables);
-                return new Response(JSON.stringify(result), {
-                    headers: { 'Content-Type': 'application/json' },
-                });
-            } catch (err) {
-                return new Response(JSON.stringify({ errors: [{ message: (err as Error).message }] }), {
-                    status: 500,
-                    headers: { 'Content-Type': 'application/json' },
-                });
-            }
-        }
-
-        return new Response('Method Not Allowed', { status: 405 });
-    };
-}