@hueest/xray 0.6.0 → 0.7.0

package/dist/react.dev.js

@@ -1,5 +1,5 @@
-import { n as BOUNDARY_ATTR } from "./plate-BwJUgHDc.js";
-import { a as markStitchesLive, c as useSkeletonTiming, i as isStitchLive, n as collectStitchNames, o as renderPlate, r as isRenderProp, s as resolveContent, t as SuspendWhileLoading } from "./react.core-DeEli0Lp.js";
+import { n as BOUNDARY_ATTR } from "./plate-CXIh5_OB.js";
+import { a as markStitchesLive, c as useSkeletonTiming, i as isStitchLive, n as collectStitchNames, o as renderPlate, r as isRenderProp, s as resolveContent, t as SuspendWhileLoading } from "./react.core-BS2yvqeh.js";
 import { Suspense, useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/react.dev.tsx
@@ -16,36 +16,31 @@ function useReplayOn() {
 	return useSyncExternalStore(replay?.subscribe ?? noSubscribe, replay?.get ?? alwaysFalse, alwaysFalse);
 }
 /**
-* The Fixtures (ADR 0015) seam, applied at the ready (`loading=false`) path right
-* before `resolveContent`. It is the ONE place Record reads `data` and Replay
-* substitutes it — the render-prop `data` argument is in scope here (open Q1,
-* confirmed).
+* The Fixtures (ADR 0015) seam, applied at the ready (`loading=false`) path right before
+* `resolveContent`. It is the ONE place Record reads `data` and Replay substitutes it — the
+* render-prop `data` argument is in scope here.
 *
-* Replay: when the toggle is on and a Fixture exists, the recorded `data` is
-* substituted for the live `data` according to `replayMode` — `'prefer'` always
-* uses the Fixture; `'missing-only'` uses it only when live `data` is NULLISH
-* (`missing ≡ nullish`, so an empty array/object is present and stays
-* capturable). The substituted value is returned synchronously so it feeds
-* `resolveContent` for THIS render; the capture-all sweep only re-renders at each
-* width and reads the SAME Fixture from the store (which the sweep never changes
-* per width), so every View is captured from one width-independent Fixture with
-* no new capture trigger (open Q2, confirmed — capture follows whatever renders,
-* ADR 0002).
+* Replay: when the toggle is on and a Fixture exists, the recorded `data` is substituted for the
+* live `data` according to `replayMode` — `'prefer'` always uses the Fixture; `'missing-only'` uses
+* it only when live `data` is NULLISH (`missing ≡ nullish`, so an empty array/object is present and
+* stays capturable). The substituted value is returned synchronously so it feeds `resolveContent`
+* for THIS render; the capture-all sweep only re-renders at each width and reads the SAME Fixture
+* from the store (which the sweep never changes per width), so every View is captured from one
+* width-independent Fixture with no new capture trigger (capture follows whatever renders, ADR
+* 0002).
 *
-* Record: the live `data` is registered (in an effect, so render stays pure) so
-* the HUD button and the auto modes always have the current input in scope. The
-* auto modes (`'first-ready'`, `'always'`) fire from the same effect; `'manual'`
-* (the default) records nothing automatically. We register and auto-record the
-* LIVE `data`, never the replayed value, so Replay and Record never feed each
-* other.
+* Record: the live `data` is registered (in an effect, so render stays pure) so the HUD button and
+* the auto modes always have the current input in scope. The auto modes (`'first-ready'`,
+* `'always'`) fire from the same effect; `'manual'` (the default) records nothing automatically.
+* Register and auto-record the LIVE `data`, never the replayed value, so Replay and Record never
+* feed each other.
 *
-* Only the render-prop children form is the `data` seam (ADR 0014/0015), so
-* Fixtures apply to it alone: `renderProp` gates participation. A plain-children
-* Skeleton has no `data` input, so it must NOT register, auto-record, or replay —
-* the hook is a pass-through for it, which keeps a never-registered plain name out
-* of `recordAll` and lets `record(name)` throw loudly (no render-prop data) as the
-* store contract documents. A render-prop Skeleton passed `data={undefined}` is
-* still a render prop and participates exactly as any other.
+* Only the render-prop children form is the `data` seam (ADR 0014/0015), so Fixtures apply to it
+* alone: `renderProp` gates participation. A plain-children Skeleton has no `data` input, so it
+* must NOT register, auto-record, or replay — the hook is a pass-through for it, which keeps a
+* never-registered plain name out of `recordAll` and lets `record(name)` throw loudly (no
+* render-prop data) as the store contract documents. A render-prop Skeleton passed
+* `data={undefined}` is still a render prop and participates exactly as any other.
 */
 function useFixtureData(name, data, renderProp) {
 	const replayOn = useReplayOn();
@@ -72,8 +67,8 @@ function useFixtureData(name, data, renderProp) {
 	return recordedFixture.data;
 }
 /**
-* The plate to render: the freshest capture from the client store (hot-swapped
-* in place, no remount) when present, else the imported prop.
+* The plate to render: the freshest capture from the client store (hot-swapped in place, no
+* remount) when present, else the imported prop.
 */
 function useLivePlate(plate) {
 	const store = globalThis.__XRAY__?.plates;
@@ -82,10 +77,9 @@ function useLivePlate(plate) {
 	return useSyncExternalStore(subscribe, getSnapshot, () => plate);
 }
 /**
-* Dev `<Skeleton>`: production behavior plus the Light Box override, the
-* live-store hot-swap, and browse-time capture. The xray plugin aliases
-* `@hueest/xray/react` to this module in `serve`; production gets the hook-free
-* `react.tsx`.
+* Dev `<Skeleton>`: production behavior plus the Light Box override, the live-store hot-swap, and
+* browse-time capture. The xray plugin aliases `@hueest/xray/react` to this module in `serve`;
+* production gets the lean `react.tsx`.
 */
 function Skeleton(props) {
 	const { plate, css, loading = false, suspense = false, fallback, delay, children, data, captureWalker, maxNodes, maxBreadth, maxDepth } = props;
@@ -132,10 +126,10 @@ function Content(props) {
 	return /* @__PURE__ */ jsx(CaptureBoundary, { ...props });
 }
 /**
-* Assemble the per-site Collect limits (ADR 0022) from the flat `<Skeleton>` props
-* into the nested shape `captured` expects, or `undefined` when none are set (so
-* the client's plugin defaults apply). Called inside the capture effect, keyed on
-* the flat primitives, so it never builds an object during render.
+* Assemble the per-site Collect limits (ADR 0022) from the flat `<Skeleton>` props into the nested
+* shape `captured` expects, or `undefined` when none are set (so the client's plugin defaults
+* apply). Called inside the capture effect, keyed on the flat primitives, so it never builds an
+* object during render.
 */
 function collectLimits(maxNodes, maxBreadth, maxDepth) {
 	if (maxNodes === void 0 && maxBreadth === void 0 && maxDepth === void 0) return void 0;
@@ -146,12 +140,11 @@ function collectLimits(maxNodes, maxBreadth, maxDepth) {
 	};
 }
 /**
-* `root="auto"` (default): the existing `display:contents` boundary wrapper marks
-* the capture seam so a parent capture stops here and references this plate by
-* name rather than re-serializing the content (ADR 0006). A render prop is called
-* with the verbatim `data` and a no-op `ref` (the wrapper, not the consumer's
-* element, carries the marker); its result renders inside the wrapper exactly as
-* plain children do.
+* `root="auto"` (default): the existing `display:contents` boundary wrapper marks the capture seam
+* so a parent capture stops here and references this plate by name rather than re-serializing the
+* content (ADR 0006). A render prop is called with the verbatim `data` and a no-op `ref` (the
+* wrapper, not the consumer's element, carries the marker); its result renders inside the wrapper
+* exactly as plain children do.
 */
 function CaptureBoundary({ plate, delay, children, data, captureWalker, maxNodes, maxBreadth, maxDepth }) {
 	const ref = useRef(null);
@@ -181,17 +174,15 @@ function CaptureBoundary({ plate, delay, children, data, captureWalker, maxNodes
 	});
 }
 /**
-* `root="manual"` (ADR 0014): no wrapper. The render prop is handed a CALLBACK
-* ref that, when spread onto the consumer's root element, writes the existing
-* `data-xr-boundary` marker onto it and registers it as the capture root, so a
-* parent capture reads the identical marker (`serialize.ts` does
-* `BOUNDARY_ATTR ?? ROOT_ATTR`) and cannot tell a manual root from an auto one.
+* `root="manual"` (ADR 0014): no wrapper. The render prop is handed a CALLBACK ref that, when
+* spread onto the consumer's root element, writes the existing `data-xr-boundary` marker onto it
+* and registers it as the capture root, so a parent capture reads the identical marker
+* (`measure.ts` does `BOUNDARY_ATTR ?? ROOT_ATTR`) and cannot tell a manual root from an auto one.
 *
-* If the consumer forgets to spread the ref, the marker never lands and the
-* parent capture descends into and silently swallows this subtree's DOM: the
-* exact stitch-isolation breakage ADR 0006 prevents, and the worst failure xray
-* can produce. A dev-time effect asserts the ref fired and loudly `console.error`s
-* when it did not.
+* If the consumer forgets to spread the ref, the marker never lands and the parent capture descends
+* into and silently swallows this subtree's DOM: the exact stitch-isolation breakage ADR 0006
+* prevents, and the worst failure xray can produce. A dev-time effect asserts the ref fired and
+* loudly `console.error`s when it did not.
 */
 function ManualBoundary({ plate, delay, children, data, captureWalker, maxNodes, maxBreadth, maxDepth }) {
 	const disposeRef = useRef(void 0);
@@ -222,9 +213,11 @@ function ManualBoundary({ plate, delay, children, data, captureWalker, maxNodes,
 	}, [plate.name]);
 	return /* @__PURE__ */ jsx(Fragment$1, { children: resolveContent(children, useFixtureData(plate.name, data, isRenderProp(children)), ref) });
 }
-/** Render a plate's skeleton, seeding the live store from its resolved refs so a
-* stitch resolves before its child is re-captured and survives a parent
-* hot-swap (which pushes a refs-less plate). Never overwrites a live capture. */
+/**
+* Render a plate's skeleton, seeding the live store from its resolved refs so a stitch resolves
+* before its child is re-captured and survives a parent hot-swap (which pushes a refs-less plate).
+* Never overwrites a live capture.
+*/
 function PlateView({ plate, css, fallback, nested = false, rootRef, instant }) {
 	useEffect(() => {
 		const store = globalThis.__XRAY__?.plates;
@@ -238,9 +231,9 @@ function PlateView({ plate, css, fallback, nested = false, rootRef, instant }) {
 	}), nested, rootRef, instant, css);
 }
 /**
-* A stitch in dev: resolve the child plate from the live store (so re-capturing
-* it hot-swaps it inside every parent), falling back to the parent's statically
-* imported `refs` until the first capture lands.
+* A stitch in dev: resolve the child plate from the live store (so re-capturing it hot-swaps it
+* inside every parent), falling back to the parent's statically imported `refs` until the first
+* capture lands.
 */
 function RefNode({ name, staticRefs }) {
 	const store = globalThis.__XRAY__?.plates;

package/dist/react.js

@@ -1,33 +1,32 @@
-import { a as markStitchesLive, c as useSkeletonTiming, i as isStitchLive, n as collectStitchNames, o as renderPlate, s as resolveContent, t as SuspendWhileLoading } from "./react.core-DeEli0Lp.js";
+import { a as markStitchesLive, c as useSkeletonTiming, i as isStitchLive, n as collectStitchNames, o as renderPlate, s as resolveContent, t as SuspendWhileLoading } from "./react.core-BS2yvqeh.js";
 import { Suspense, useEffect, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/react.tsx
 /**
 * React adapter for rendering committed Plates through `<Skeleton>`.
 *
-* In production this adapter is hook-free and renders only committed Plate data.
-* During `vite serve`, `xrayVitePlugin()` aliases this export to the dev adapter
-* so ready children can be captured without shipping the capture client, HUD, or
-* Light Box code in production builds.
+* In production this adapter renders only committed Plate data (its only hooks are the
+* display-timing and instant-reveal ones). During `vite serve`, `xrayVitePlugin()` aliases this
+* export to the dev adapter so ready children can be captured without shipping the capture client,
+* HUD, or Light Box code in production builds.
 *
 * @module @hueest/xray/react
 */
 /**
 * Render a committed Plate while content is loading.
 *
-* Use `loading` when your data source exposes an explicit pending state. Use
-* `suspense` when the child suspends; in that mode `<Skeleton>` is the Suspense
-* boundary and the Plate is the fallback. You can also render a bare Skeleton
-* with no children when another framework or router owns the loading boundary.
+* Use `loading` when your data source exposes an explicit pending state. Use `suspense` when the
+* child suspends; in that mode `<Skeleton>` is the Suspense boundary and the Plate is the fallback.
+* You can also render a bare Skeleton with no children when another framework or router owns the
+* loading boundary.
 *
-* In dev, the plugin aliases this component to the dev adapter. When children
-* are ready, that adapter marks the capture boundary, waits for the subtree to
-* settle, and sends the rendered DOM to the xray client. Nested `<Skeleton>`
-* boundaries become Stitches so a parent Plate records a child Plate reference
-* instead of serializing the child subtree again.
+* In dev, the plugin aliases this component to the dev adapter. When children are ready, that
+* adapter marks the capture boundary, waits for the subtree to settle, and sends the rendered DOM
+* to the xray client. Nested `<Skeleton>` boundaries become Stitches so a parent Plate records a
+* child Plate reference instead of serializing the child subtree again.
 *
-* In production this component ships no capture client, HUD, Light Box, store,
-* or subscriptions. Stitches resolve from the statically imported `refs` graph.
+* In production this component ships no capture client, HUD, Light Box, store, or subscriptions.
+* Stitches resolve from the statically imported `refs` graph.
 */
 function Skeleton(props) {
 	const { plate, css, loading = false, suspense = false, fallback, children, data } = props;
@@ -57,11 +56,12 @@ function PlateView({ plate, css, fallback, rootRef, instant }) {
 	if (!plate.chunks) return /* @__PURE__ */ jsx(Fragment$1, { children: fallback ?? null });
 	return renderStatic(plate, false, rootRef, instant, css);
 }
-/** Resolve stitches statically through the import graph (ADR 0006) — pure
-* recursion, no store, no subscription. An unknown child renders nothing. The
-* `instant` flag (ADR 0020) and the inline `css` (two-artifact contract) ride
-* the outermost root only; nested stitches pass neither, so `renderPlate`
-* never marks or styles a nested root. */
+/**
+* Resolve stitches statically through the import graph (ADR 0006) — pure recursion, no store, no
+* subscription. An unknown child renders nothing. The `instant` flag (ADR 0020) and the inline
+* `css` (two-artifact contract) ride the outermost root only; nested stitches pass neither, so
+* `renderPlate` never marks or styles a nested root.
+*/
 function renderStatic(plate, nested, rootRef, instant, css) {
 	return renderPlate(plate, (name) => {
 		const child = plate.refs?.[name];