@mui/internal-docs-infra 0.12.1-canary.2 → 0.12.1-canary.21

package/useDemoController/useDemoController.mjs

@@ -0,0 +1,186 @@
+'use client';
+
+import * as React from 'react';
+import { useCodeExternals } from '@mui/internal-docs-infra/CodeExternalsContext';
+import { getTranspile } from "./transpileClientSingleton.mjs";
+import { useVariantBuilds } from "./useVariantBuilds.mjs";
+
+// The live runtime is loaded LAZILY in two chunks, warmed when a demo activates for
+// editing (via `onActivate` below) or, failing that, on the first build:
+//   - `BuildEngine` — the build half (`buildScope`) + render half (`DemoRunner` + the
+//     react-runner reimplementation), bundled together (see `BuildEngine.ts`).
+//   - `compileCss` — the PostCSS toolchain, only needed for demos with CSS files.
+// Keeping them out of the eager `useDemoController` chunk means a reader who never edits
+// never fetches them. `DemoRunner` is lazy, so the host must render the returned
+// `components` under a `Suspense` boundary — `CodeHighlighterClient` does, falling back to
+// the build-time render while the chunk resolves (see the `components` return doc).
+
+let buildEngineImport = null;
+function preloadBuildEngine() {
+  if (!buildEngineImport) {
+    buildEngineImport = import("./BuildEngine.mjs");
+  }
+  return buildEngineImport;
+}
+let compileCssImport = null;
+function preloadCompileCss() {
+  if (!compileCssImport) {
+    compileCssImport = import(/* webpackChunkName: "compileCss" */"./compileCssWithPostcss.mjs");
+  }
+}
+const DemoRunner = /*#__PURE__*/React.lazy(() => preloadBuildEngine().then(module => ({
+  default: module.DemoRunner
+})));
+/**
+ * Drives the live previews for a demo controller. Owns the controlled `code` state,
+ * transpiles each variant OFF the main thread (via a shared Web Worker, with a
+ * main-thread fallback) and renders the ready ones through {@link DemoRunner}, and
+ * collects the per-variant `errors` — returning exactly the `{ code, setCode,
+ * components, errors }` shape a `CodeControllerContext` provider expects, so a host
+ * wires it up in one line and reads results back through `useDemo`.
+ *
+ * Because transpilation is async, a variant joins `components` only once its build
+ * resolves; editing never blocks the UI thread, and an in-flight variant shows its
+ * fallback rather than a flash of empty preview. Keeping `code` unset until the
+ * first `setCode` lets the host serve its build-time/server render first.
+ *
+ * By default the controlled code is also mirrored across same-origin tabs of the same
+ * page (via the `crossTabSync` option), so a reader editing a demo in a Chrome split
+ * view sees it update in both panes.
+ */
+export function useDemoController() {
+  const [code, setControlledCode] = React.useState(null);
+  // Build errors (transpile/CSS failures) and render errors (the entry throwing) live
+  // in SEPARATE maps so they never clobber each other: a build error is owned by
+  // `useVariantBuilds` (set on failure, cleared on the next good build); a render
+  // error is owned by the live `DemoRunner` (set while it throws, cleared when it
+  // renders cleanly). A CSS-only fix doesn't re-render the entry, so the build channel
+  // must clear itself rather than wait for the runner. They are merged below.
+  const [buildErrors, setBuildErrors] = React.useState({});
+  const [renderErrors, setRenderErrors] = React.useState({});
+  const [transpile, setTranspile] = React.useState(null);
+  const externalsContext = useCodeExternals();
+  const externals = React.useMemo(() => externalsContext?.externals ?? {
+    react: React
+  }, [externalsContext]);
+
+  // Identity-stable reporters; each dedups a no-op so it doesn't churn state. The
+  // `?? null` treats "never set" (undefined) and "cleared" (null) as equal, so
+  // clearing a variant that never errored is a no-op.
+  const reportBuildError = React.useCallback((variant, message) => {
+    setBuildErrors(previous => (previous[variant] ?? null) === message ? previous : {
+      ...previous,
+      [variant]: message
+    });
+  }, []);
+  const reportRenderError = React.useCallback((variant, message) => {
+    setRenderErrors(previous => (previous[variant] ?? null) === message ? previous : {
+      ...previous,
+      [variant]: message
+    });
+  }, []);
+
+  // Reset (the toolbar button clears `code` to `undefined`) must also drop any stale
+  // build/render error, so a prior syntax error's overlay doesn't linger over the
+  // restored original — nothing rebuilds after a reset to clear it otherwise. Do it in
+  // the setter that performs the reset rather than reacting to the `code` change in an
+  // effect; the length guards keep each clear a no-op once its map is empty.
+  const setCode = React.useCallback(action => {
+    setControlledCode(action);
+    // Drop stale errors alongside a reset (`code` cleared to `null`).
+    if (!action) {
+      setBuildErrors({});
+      setRenderErrors({});
+    }
+  }, [setControlledCode]);
+
+  // Resolve the page-shared transpile (worker, or main-thread fallback) into state once
+  // there's code to build — a local first edit, or a cross-tab edit that arrives without
+  // this tab engaging its own editor. `onActivate` below has usually already spun the
+  // worker up (so `getTranspile()` here resolves from cache), but this covers the
+  // passive/synced tab that never activates. Client-only, so the worker is never built
+  // on the server and the controller renders with no `components` until the client takes
+  // over.
+  React.useEffect(() => {
+    if (!code || transpile) {
+      return undefined;
+    }
+    let active = true;
+    getTranspile().then(resolved => {
+      if (active) {
+        setTranspile(() => resolved);
+      }
+    });
+    return () => {
+      active = false;
+    };
+  }, [code, transpile]);
+
+  // Warm the lazy engine modules the moment editing ACTIVATES (before the first
+  // keystroke), all kicked off here so they download in PARALLEL rather than
+  // waterfalling one inside another. The host passes which file kinds the demo spans, so
+  // a CSS-free demo never fetches the CSS toolchain and a reader who never activates
+  // fetches nothing. (If a host doesn't call this, each still loads on the first build,
+  // just a beat later.)
+  const onActivate = React.useCallback(deps => {
+    // The build + render engine — needed for any demo.
+    preloadBuildEngine();
+    // The transpile runs in a Web Worker; `getTranspile()` spins it up, loading sucrase
+    // OFF the main thread. (A direct `import('./transpileSource')` here would instead
+    // pull sucrase INTO the main bundle, defeating the worker.)
+    if (deps.js) {
+      getTranspile();
+    }
+    // The PostCSS toolchain — only for demos with CSS.
+    if (deps.css) {
+      preloadCompileCss();
+    }
+  }, []);
+  const built = useVariantBuilds(code, transpile, externals, reportBuildError);
+  const components = React.useMemo(() => {
+    if (!code) {
+      return undefined;
+    }
+    const result = {};
+    for (const variant of Object.keys(code)) {
+      const variantBuild = built[variant];
+      if (!variantBuild) {
+        continue; // first build still in flight — no component yet
+      }
+      // Render the lazy `DemoRunner` WITHOUT a per-variant Suspense here: the boundary
+      // belongs to the HOST, which can fall back to the BUILD-TIME render while the lazy
+      // chunk resolves. A `<Suspense fallback={null}>` here paints an empty frame on a
+      // NEWLY-MOUNTED boundary — the first edit after `reset()`, where `built` was cleared
+      // so no prior live frame exists for `startTransition` to hold — flashing blank.
+      // Bubbling to the host's boundary shows the original instead.
+      result[variant] = /*#__PURE__*/React.createElement(DemoRunner, {
+        key: variant,
+        runnerCode: variantBuild.runnerCode,
+        scope: variantBuild.scope,
+        css: variantBuild.css,
+        onError: message => reportRenderError(variant, message)
+      });
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+  }, [code, built, reportRenderError]);
+
+  // Merge the two channels: a build failure takes precedence (the preview is stale
+  // until it builds), otherwise the render error, else `null`.
+  const errors = React.useMemo(() => {
+    if (!code) {
+      return {};
+    }
+    const merged = {};
+    for (const variant of new Set([...Object.keys(buildErrors), ...Object.keys(renderErrors)])) {
+      merged[variant] = buildErrors[variant] || renderErrors[variant] || null;
+    }
+    return merged;
+  }, [code, buildErrors, renderErrors]);
+  return {
+    code,
+    setCode,
+    components,
+    errors,
+    onActivate
+  };
+}

package/useDemoController/useRunner.d.mts

@@ -0,0 +1,53 @@
+import * as React from 'react';
+import type { Scope } from "./types.mjs";
+export interface UseRunnerOptions {
+  /** Already-transpiled entry code to evaluate + render (see {@link Runner}). */
+  transpiledCode: string;
+  /** Identifiers (and an `import` registry) exposed to the evaluated entry. */
+  scope?: Scope;
+  /**
+   * When `true`, the preview clears on error instead of keeping the last
+   * successfully-rendered element. Defaults to `false`.
+   */
+  disableCache?: boolean;
+  /**
+   * Shown when the entry throws on a render BEFORE any successful one (so there is no
+   * last-good element to keep) — typically the host's build-time render, so a broken first
+   * edit shows the original instead of blanking. Ignored once a render has succeeded (the
+   * last-good element is kept instead) and when `disableCache` is set.
+   */
+  fallback?: React.ReactNode;
+}
+export interface UseRunnerResult {
+  /** The node to render — a `Runner`, the cached last-good one, the `fallback`, or `null`. */
+  element: React.ReactNode;
+  /** The current error message, or `null` when the code rendered cleanly. */
+  error: string | null;
+}
+/**
+ * Evaluates already-transpiled entry code and returns the element to render plus
+ * the current error message. Transpilation happens upstream (off the main thread);
+ * this hook owns only the synchronous evaluate + render + error bookkeeping.
+ *
+ * Errors are reported asynchronously (after the runner renders), so the hook keeps
+ * the last successfully-rendered element on screen while `error` is set — giving a
+ * stable preview as the source is edited into and out of broken states. The error
+ * is kept across edits and cleared only once a render succeeds, so a continuously-
+ * broken edit never flashes it off and back on. Pass `disableCache` to clear the
+ * preview on error instead.
+ *
+ * The live element and the inputs it was built from live in a SINGLE state object,
+ * not two `useState` hooks. The "adjust state during render" pattern issues a
+ * render-phase update; with the inputs and element split across two hooks, React
+ * could commit the input update while dropping the element one (e.g. when a parent
+ * re-render rebases the in-progress render), stranding a stale element that the
+ * adjust never rebuilt because the inputs already matched. Keeping them together
+ * makes the update atomic: if it is dropped, the inputs revert with it and the
+ * adjust simply re-fires on the next render.
+ */
+export declare function useRunner({
+  transpiledCode,
+  scope,
+  disableCache,
+  fallback
+}: UseRunnerOptions): UseRunnerResult;

package/useDemoController/useRunner.mjs

@@ -0,0 +1,118 @@
+'use client';
+
+import * as React from 'react';
+import { Runner } from "./Runner.mjs";
+/**
+ * Evaluates already-transpiled entry code and returns the element to render plus
+ * the current error message. Transpilation happens upstream (off the main thread);
+ * this hook owns only the synchronous evaluate + render + error bookkeeping.
+ *
+ * Errors are reported asynchronously (after the runner renders), so the hook keeps
+ * the last successfully-rendered element on screen while `error` is set — giving a
+ * stable preview as the source is edited into and out of broken states. The error
+ * is kept across edits and cleared only once a render succeeds, so a continuously-
+ * broken edit never flashes it off and back on. Pass `disableCache` to clear the
+ * preview on error instead.
+ *
+ * The live element and the inputs it was built from live in a SINGLE state object,
+ * not two `useState` hooks. The "adjust state during render" pattern issues a
+ * render-phase update; with the inputs and element split across two hooks, React
+ * could commit the input update while dropping the element one (e.g. when a parent
+ * re-render rebases the in-progress render), stranding a stale element that the
+ * adjust never rebuilt because the inputs already matched. Keeping them together
+ * makes the update atomic: if it is dropped, the inputs revert with it and the
+ * adjust simply re-fires on the next render.
+ */
+export function useRunner({
+  transpiledCode,
+  scope,
+  disableCache,
+  fallback
+}) {
+  const lastGoodElementRef = React.useRef(null);
+  // When an error swaps the preview back to the cached last-good element, that
+  // element re-renders cleanly and fires `onRendered` with no error. This flag
+  // tells that one "success" NOT to clear the error the swap just set.
+  const suppressErrorClearRef = React.useRef(false);
+  // `onRendered` is baked into the `Runner` element, which is only rebuilt when the
+  // code/scope/disableCache inputs change — so a `fallback` that changes on its own
+  // (e.g. the host's build-time render updating) wouldn't reach the closure. Read it
+  // through a ref kept current in an effect so the latest `fallback` is always used.
+  const fallbackRef = React.useRef(fallback);
+  React.useEffect(() => {
+    fallbackRef.current = fallback;
+  });
+  const [state, setState] = React.useState(() => ({
+    element: createRunnerElement(transpiledCode, scope),
+    error: null,
+    transpiledCode,
+    scope,
+    disableCache
+  }));
+
+  // Build a fresh live element whenever the inputs change, using React's supported
+  // "adjust state during render" pattern so an edit takes effect immediately. The
+  // prior error is KEPT here (not reset to null) so a continuously-broken edit
+  // doesn't flash the error off and back on; it's cleared only once a render
+  // actually succeeds (see `onRendered`).
+  if (state.transpiledCode !== transpiledCode || state.scope !== scope || state.disableCache !== disableCache) {
+    const element = createRunnerElement(transpiledCode, scope);
+    setState(previous => ({
+      element,
+      error: previous.error,
+      transpiledCode,
+      scope,
+      disableCache
+    }));
+  }
+  return {
+    element: state.element,
+    error: state.error
+  };
+
+  // Declared after the state above so it can reference `setState`; hoisting lets
+  // the `useState` initializer call it. The refs are only ever touched inside the
+  // async `onRendered` callback, never during render.
+  function createRunnerElement(nextCode, nextScope) {
+    const element = /*#__PURE__*/React.createElement(Runner, {
+      transpiledCode: nextCode,
+      scope: nextScope,
+      onRendered(error) {
+        if (error) {
+          // Keeping a cached element means it re-renders cleanly next and fires a
+          // no-error `onRendered`; mark that one success to be ignored so it
+          // doesn't wipe this error. Only when there actually IS a cached element
+          // to swap to — with `disableCache`, or before the first successful
+          // render, the preview falls back to `fallback`/`null` and no such
+          // re-render happens, so there is nothing to suppress (and suppressing
+          // would eat the real next success).
+          if (!disableCache && lastGoodElementRef.current !== null) {
+            suppressErrorClearRef.current = true;
+          }
+          setState(previous => ({
+            ...previous,
+            // Before any successful render there is no last-good element to keep, so show the
+            // host's build-time `fallback` (the original) rather than blanking. `disableCache`
+            // opts out and clears to `null`.
+            element: disableCache ? null : lastGoodElementRef.current ?? fallbackRef.current ?? null,
+            error: error.toString()
+          }));
+        } else if (suppressErrorClearRef.current) {
+          // The cached last-good element re-rendering after an error swap — keep
+          // the error, just remember the element.
+          suppressErrorClearRef.current = false;
+          lastGoodElementRef.current = element;
+        } else {
+          // A genuine clean render of the current code — cache it and clear any
+          // prior error.
+          lastGoodElementRef.current = element;
+          setState(previous => previous.error === null ? previous : {
+            ...previous,
+            error: null
+          });
+        }
+      }
+    });
+    return element;
+  }
+}

package/useDemoController/useVariantBuilds.d.mts

@@ -0,0 +1,31 @@
+import type { ControlledCode } from '@mui/internal-docs-infra/CodeHighlighter/types';
+import type { Transpile } from "./transpileSource.mjs";
+import type { Scope } from "./types.mjs";
+/** A variant's transpiled, ready-to-render build. */
+export interface VariantBuild {
+  /** The transpiled entry code for the runner to evaluate. */
+  runnerCode: string;
+  /** The built module registry the entry evaluates against. */
+  scope: Scope;
+  /** Compiled stylesheet text for the variant. */
+  css: string;
+}
+/**
+ * Builds each variant's scope OFF the main thread and exposes the ready ones. A
+ * variant appears in the returned map only once its (worker) transpile resolves —
+ * so a host can leave an in-flight variant showing its fallback rather than a
+ * loading state. On edit, a variant keeps its previous build until the new one
+ * resolves (and on a transpile error too, reported via `report`), so the preview
+ * never flashes.
+ *
+ * A variant's FIRST build is never cancelled. On the first edit the controller is
+ * seeded with the ORIGINAL source and the real edit follows; if that edit arrives
+ * before the seed's build settles, it is DEFERRED (not aborted) so the baseline
+ * always builds and renders before the edit lands — giving a broken edit a good
+ * preview to fall back to. Later edits abort the in-flight build as usual.
+ *
+ * Per-variant bookkeeping (request ids, abort controllers, last-built input, the
+ * first-build-done set, and the deferred edit) lives in refs since it never
+ * affects render; only the resolved `built` map is state.
+ */
+export declare function useVariantBuilds(code: ControlledCode | null | undefined, transpile: Transpile | null, externals: Record<string, unknown>, report: (variant: string, message: string | null) => void): Record<string, VariantBuild>;

package/useDemoController/useVariantBuilds.mjs

@@ -0,0 +1,188 @@
+'use client';
+
+import * as React from 'react';
+
+// The build half of the runtime (`buildScope` + its scope-assembly and eval machinery)
+// is the bulk of this engine, but it's only needed once a demo is actually EDITED —
+// before that the host shows the build-time render. So it's loaded LAZILY on the first
+// build, from the shared `BuildEngine` chunk it shares with the render half (`DemoRunner`,
+// loaded by `useDemoController`) — one chunk for the whole engine. The promise is
+// module-level, so the chunk is fetched once and every later build reuses it; readers who
+// never edit never fetch it.
+
+let buildEnginePromise = null;
+function loadBuildScope() {
+  if (!buildEnginePromise) {
+    buildEnginePromise = import("./BuildEngine.mjs").then(module => module.buildScope);
+  }
+  return buildEnginePromise;
+}
+
+/** A variant's transpiled, ready-to-render build. */
+
+/**
+ * Builds each variant's scope OFF the main thread and exposes the ready ones. A
+ * variant appears in the returned map only once its (worker) transpile resolves —
+ * so a host can leave an in-flight variant showing its fallback rather than a
+ * loading state. On edit, a variant keeps its previous build until the new one
+ * resolves (and on a transpile error too, reported via `report`), so the preview
+ * never flashes.
+ *
+ * A variant's FIRST build is never cancelled. On the first edit the controller is
+ * seeded with the ORIGINAL source and the real edit follows; if that edit arrives
+ * before the seed's build settles, it is DEFERRED (not aborted) so the baseline
+ * always builds and renders before the edit lands — giving a broken edit a good
+ * preview to fall back to. Later edits abort the in-flight build as usual.
+ *
+ * Per-variant bookkeeping (request ids, abort controllers, last-built input, the
+ * first-build-done set, and the deferred edit) lives in refs since it never
+ * affects render; only the resolved `built` map is state.
+ */
+export function useVariantBuilds(code, transpile, externals, report) {
+  const [built, setBuilt] = React.useState({});
+
+  // Per-variant async bookkeeping (render-irrelevant → refs, not state).
+  const requestIds = React.useRef(new Map());
+  const controllers = React.useRef(new Map());
+  // The exact input object a variant's latest build was STARTED from (not just
+  // resolved). Set when a build begins, so an unrelated re-render can't re-trigger
+  // a build of the same in-flight input (the controlled code is immutable, so an
+  // unchanged variant keeps its object identity).
+  const builtFrom = React.useRef(new Map());
+  // Variants whose FIRST build has settled (resolved or errored). Until then the
+  // build is never cancelled; a superseding edit waits in `deferred`.
+  const firstBuildDone = React.useRef(new Set());
+  const deferred = React.useRef(new Map());
+  React.useEffect(() => {
+    if (!code || !transpile) {
+      // Controller cleared (e.g. `reset()`): abort in-flight builds and forget all
+      // per-variant state, so the next edit is treated as a first build again
+      // (re-running the `.original` baseline branch). Drop the resolved `built` map
+      // too, so the re-edit starts from an EMPTY map — exactly like a true first
+      // edit — instead of briefly flashing the pre-reset build before the rebuilt
+      // baseline lands.
+      if (!code) {
+        for (const controller of controllers.current.values()) {
+          controller.abort();
+        }
+        controllers.current.clear();
+        requestIds.current.clear();
+        builtFrom.current.clear();
+        firstBuildDone.current.clear();
+        deferred.current.clear();
+        // One-shot reset, NOT a cascading render: `built` is not an effect dep, so
+        // clearing it doesn't re-run this effect, and once empty the updater is a
+        // no-op. Runs only when `code` is undefined, so it never touches an edit.
+        // eslint-disable-next-line react-hooks/set-state-in-effect -- one-shot reset on controller clear
+        setBuilt(previous => Object.keys(previous).length > 0 ? {} : previous);
+      }
+      return;
+    }
+    const startBuild = (variant, variantCode) => {
+      const {
+        source
+      } = variantCode;
+      if (!source) {
+        return;
+      }
+      builtFrom.current.set(variant, variantCode);
+      controllers.current.get(variant)?.abort();
+      const controller = new AbortController();
+      controllers.current.set(variant, controller);
+      const requestId = (requestIds.current.get(variant) ?? 0) + 1;
+      requestIds.current.set(variant, requestId);
+
+      // After this build settles, build any edit deferred while it ran.
+      const buildDeferred = () => {
+        const next = deferred.current.get(variant);
+        if (next) {
+          deferred.current.delete(variant);
+          startBuild(variant, next);
+        }
+      };
+      loadBuildScope().then(buildScope => buildScope({
+        extraFiles: variantCode.extraFiles,
+        externals,
+        mainCode: source,
+        transpile,
+        signal: controller.signal
+      })).then(result => {
+        if (requestIds.current.get(variant) !== requestId) {
+          return; // superseded by a newer edit
+        }
+        firstBuildDone.current.add(variant);
+        // The build is now valid — clear any prior build error. A render error (if
+        // the entry then throws) is a SEPARATE channel reported by the runner; this
+        // only clears the build error, which the runner can't clear itself (a
+        // CSS-only fix never re-renders the entry).
+        report(variant, null);
+        // Commit the freshly-built variant urgently (a transition here would let a later
+        // edit's commit supersede it before it paints, costing the runner its last-good).
+        // The `.original` baseline still renders first when the build is fast enough; when
+        // it isn't (a cold first edit, where React coalesces the baseline + edit commits and
+        // the baseline never paints), a render error in the edit falls back to the host's
+        // build-time render instead of blanking (see the runner's `fallback`).
+        setBuilt(previous => ({
+          ...previous,
+          [variant]: {
+            runnerCode: result.runnerCode ?? '',
+            scope: {
+              import: result.imports
+            },
+            css: result.css
+          }
+        }));
+        buildDeferred();
+      }).catch(thrown => {
+        if (requestIds.current.get(variant) !== requestId || controller.signal.aborted) {
+          return; // superseded / aborted
+        }
+        // The attempt finished (failed) — later edits may now cancel.
+        firstBuildDone.current.add(variant);
+        report(variant, thrown instanceof Error ? thrown.toString() : String(thrown));
+        buildDeferred();
+      });
+    };
+    for (const variant of Object.keys(code)) {
+      const variantCode = code[variant];
+      if (!variantCode || !variantCode.source) {
+        continue;
+      }
+      // First build of a variant that carries a baseline (`.original`, tagged on the
+      // FIRST edit): build the ORIGINAL inputs FIRST so the preview shows a good
+      // baseline before this (possibly broken) edit, then build the edit (which
+      // waits via the defer path below). Gated on `!controllers.has` so it fires
+      // exactly once — a re-render or a lingering `.original` never re-baselines.
+      const original = variantCode.original;
+      if (original?.source && !controllers.current.has(variant)) {
+        deferred.current.set(variant, variantCode);
+        startBuild(variant, {
+          source: original.source,
+          extraFiles: original.extraFiles
+        });
+        continue;
+      }
+      // Skip a variant whose exact input we already built — so editing one variant
+      // doesn't re-transpile and re-evaluate the others.
+      if (builtFrom.current.get(variant) === variantCode) {
+        continue;
+      }
+      // Never cancel a variant's FIRST build: while it's in flight, defer this edit
+      // (keeping only the latest) instead of aborting, so the baseline renders
+      // first. Later edits (first build done) abort the in-flight build as usual.
+      if (controllers.current.get(variant) && !firstBuildDone.current.has(variant)) {
+        deferred.current.set(variant, variantCode);
+        continue;
+      }
+      startBuild(variant, variantCode);
+    }
+  }, [code, transpile, externals, report]);
+
+  // Abort any in-flight builds on unmount.
+  React.useEffect(() => () => {
+    for (const controller of controllers.current.values()) {
+      controller.abort();
+    }
+  }, []);
+  return built;
+}

package/useSearch/types.d.mts

@@ -1,4 +1,4 @@
-import { type ElapsedTime, type Orama, type Result, type SearchParams } from '@orama/orama';
+import type { ElapsedTime, Orama, Result, SearchParams } from '@orama/orama';
 import type { Sitemap, SitemapPage, SitemapSection, SitemapPart, SitemapExport, SitemapSectionData } from "../createSitemap/types.mjs";
 /**
  * Base search result structure that can be extended by consumers

package/useType/TypesDataProvider.d.mts

@@ -8,4 +8,4 @@ export declare function TypesDataProvider({
   children
 }: {
   children: React.ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
+}): React.JSX.Element;

package/useType/TypesDataProvider.mjs

@@ -2,13 +2,12 @@
 
 import * as React from 'react';
 import { TypesDataContext } from "./TypesDataContext.mjs";
-
+import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * Provider that collects type data from all `useTypes()` calls within its subtree.
  * This enables `useType(name)` to look up individual type data anywhere in the tree,
  * and `useTypeProp(typeName, propName)` to look up individual properties.
  */
-import { jsx as _jsx } from "react/jsx-runtime";
 export function TypesDataProvider({
   children
 }) {

package/useType/useType.d.mts

@@ -1,5 +1,5 @@
 import type * as React from 'react';
-import { type TypeData } from "./TypesDataContext.mjs";
+import type { TypeData } from "./TypesDataContext.mjs";
 /**
  * Props passed to the custom `typeRefComponent` element.
  */

package/useType/useTypeProp.d.mts

@@ -1,5 +1,5 @@
 import type * as React from 'react';
-import { type TypePropData } from "./TypesDataContext.mjs";
+import type { TypePropData } from "./TypesDataContext.mjs";
 /**
  * Props passed to the custom `typePropRefComponent` element.
  */