@hueest/xray 0.2.0 → 0.3.0

package/dist/{react.core-BzMG_cDy.d.ts → react.core-BUj8ziwh.d.ts}

@@ -1,5 +1,5 @@
-import { r as Plate } from "./plate-Bv6W-GkA.js";
-import { o as XrayCaptureWalker } from "./serialize-B--oY2bV.js";
+import { r as Plate } from "./plate-BIr62u7l.js";
+import { a as XrayCaptureWalker } from "./serialize-Cs7hUxmK.js";
 import { ReactNode } from "react";
 
 //#region src/react.core.d.ts
@@ -44,7 +44,7 @@ interface SkeletonBase {
    * The escape hatch beyond the declarative `data-xr-*` annotations: a closure
    * that decides, per element, whether to ignore it, collapse it to one Bone, or
    * defer to the built-in walk. Threaded through the dev adapter into
-   * `captureRegime`; PRODUCTION ignores it entirely (it never captures). On both
+   * `captureView`; PRODUCTION ignores it entirely (it never captures). On both
    * `root` variants of the union, so a manual root may carry one too.
    */
   captureWalker?: XrayCaptureWalker;

package/dist/{react.core-IyFy2b_8.js → react.core-DMIhXHZF.js}

@@ -1,4 +1,4 @@
-import { a as ROOT_ATTR, o as ROOT_CLASS, s as ROOT_INSTANT_ATTR, t as BASE_CSS } from "./plate-DoE1HEXp.js";
+import { a as ROOT_ATTR, o as ROOT_CLASS, s as ROOT_INSTANT_ATTR, t as BASE_CSS } from "./plate-BRR6d8Se.js";
 import { t as escapeStyleText } from "./css-escape-N7bOusGW.js";
 import { Fragment, useEffect, useRef, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -74,6 +74,7 @@ function collectStitchNames(chunks) {
 	const walk = (cs) => {
 		for (const chunk of cs) {
 			if (typeof chunk === "string") continue;
+			if ("t" in chunk) continue;
 			if ("r" in chunk) names.push(chunk.r);
 			else walk(chunk.k);
 		}
@@ -256,6 +257,10 @@ function renderChunks(chunks, resolveStitch) {
 			style: DISPLAY_CONTENTS,
 			dangerouslySetInnerHTML: { __html: chunk }
 		}, i);
+		if ("t" in chunk) return /* @__PURE__ */ jsx("div", {
+			style: DISPLAY_CONTENTS,
+			dangerouslySetInnerHTML: { __html: chunk.t.repeat(chunk.n) }
+		}, i);
 		if ("r" in chunk) return /* @__PURE__ */ jsx(Fragment, { children: resolveStitch(chunk.r) }, i);
 		return /* @__PURE__ */ jsx("div", {
 			className: chunk.c,

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { t as SkeletonProps } from "./react.core-BzMG_cDy.js";
+import { t as SkeletonProps } from "./react.core-BUj8ziwh.js";
 
 //#region src/react.d.ts
 /**

package/dist/react.dev.d.ts

@@ -1,4 +1,4 @@
-import { t as SkeletonProps } from "./react.core-BzMG_cDy.js";
+import { t as SkeletonProps } from "./react.core-BUj8ziwh.js";
 
 //#region src/react.dev.d.ts
 /**

package/dist/react.dev.js

@@ -1,5 +1,5 @@
-import { n as BOUNDARY_ATTR } from "./plate-DoE1HEXp.js";
-import { a as renderPlate, i as markStitchesLive, n as isRenderProp, o as resolveContent, r as isStitchLive, s as useSkeletonTiming, t as collectStitchNames } from "./react.core-IyFy2b_8.js";
+import { n as BOUNDARY_ATTR } from "./plate-BRR6d8Se.js";
+import { a as renderPlate, i as markStitchesLive, n as isRenderProp, o as resolveContent, r as isStitchLive, s as useSkeletonTiming, t as collectStitchNames } from "./react.core-DMIhXHZF.js";
 import { Suspense, useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 //#region src/react.dev.tsx

package/dist/react.js

@@ -1,4 +1,4 @@
-import { a as renderPlate, i as markStitchesLive, o as resolveContent, r as isStitchLive, s as useSkeletonTiming, t as collectStitchNames } from "./react.core-IyFy2b_8.js";
+import { a as renderPlate, i as markStitchesLive, o as resolveContent, r as isStitchLive, s as useSkeletonTiming, t as collectStitchNames } from "./react.core-DMIhXHZF.js";
 import { Suspense, useEffect, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 //#region src/react.tsx

package/dist/serialize-Cs7hUxmK.d.ts

@@ -0,0 +1,107 @@
+import { t as LeafKind } from "./plate-BIr62u7l.js";
+
+//#region src/serialize.d.ts
+/**
+ * Browser-side capture: walk a live rendered subtree into a Plate — one node
+ * tree plus one self-contained, scoped CSS string (ADR 0003). The CSS is
+ * lifted from the author rules that matched each node, rewritten to
+ * plate-local selectors — it carries `@media` for free and keeps layout live
+ * (the M1 bake-off winner; ADR 0005).
+ */
+interface CaptureOptions {
+  /** Plate name; comes from the virtual-module specifier. */
+  name: string;
+  /**
+   * Optional programmable capture walker (ADR 0018). The declarative `data-xr-*`
+   * annotations cover the 90%; this is the escape hatch for the 10% a markup
+   * attribute cannot express. Capture-only: it shapes the resulting `PlateNode`
+   * tree but is never persisted into the Plate, and the production adapter never
+   * captures so it ignores this entirely.
+   */
+  walker?: XrayCaptureWalker;
+  /**
+   * Whether the top-level capture roots ARE this plate's own boundary, so the
+   * stitch guard must be SKIPPED for them (ADR 0006/0014, finding #6). True ONLY
+   * for a MANUAL root: there `site.el` is the consumer's own element and its
+   * `data-xr-boundary` marks the boundary of THIS plate, so the root must be
+   * serialized as a real Entry (its box/classes/padding/border) rather than a
+   * stitch-to-itself. Defaults to `false` — the auto path, where the top-level
+   * roots are the wrapper's CHILDREN and any boundary marker on a direct-child
+   * root is a NESTED `<Skeleton>` that MUST stitch (the capture-leak guard).
+   */
+  captureRootIsBoundary?: boolean;
+}
+/**
+ * What a capture walker decides for one element (ADR 0018; ADR 0022 §5). The
+ * `applyWalker` PASS reads the decision and applies it to the measured IR node —
+ * a walker NEVER hand-builds a `PlateNode`, so xray keeps ownership of the Plate
+ * format. `ignore` drops the element + its subtree; `bone` collapses it to one
+ * Bone leaf (inferring the kind when omitted); `keep` defers to the default
+ * classifier (`markInk`).
+ */
+type WalkerDecision = {
+  type: 'ignore';
+} | {
+  type: 'bone';
+  kind?: LeafKind;
+} | {
+  type: 'keep';
+};
+/**
+ * The context handed to a capture walker's `element` hook (ADR 0018). The
+ * helpers are PURE — each returns a `WalkerDecision` the `applyWalker` pass
+ * applies; they do NOT mutate. `el` is the element under consideration.
+ */
+interface CaptureWalkerContext {
+  /** The element currently being classified. */
+  el: Element;
+  /** Drop this element AND its whole subtree (no bone). */
+  ignore(): WalkerDecision;
+  /**
+   * Collapse this element's subtree into ONE Bone leaf. `kind` omitted shares
+   * the default classifier's kind-inference heuristic (`inferLeafKind`; ADR 0018,
+   * Q4 — ONE code path).
+   */
+  bone(opts?: {
+    kind?: LeafKind;
+  }): WalkerDecision;
+  /** Defer to the default classifier (`markInk`) — recurse into the subtree. */
+  keep(): WalkerDecision;
+}
+/**
+ * The programmable capture walker (ADR 0018; ADR 0022 §5). `element` is offered
+ * each non-boundary element TOP-DOWN over the measured IR (the `applyWalker`
+ * pass, NOT the DOM walk) and returns a `WalkerDecision` the pass applies. The
+ * declarative `data-xr-*` annotations cover the 90%; this is the 10% escape
+ * hatch for what a markup attribute cannot express.
+ */
+interface XrayCaptureWalker {
+  /**
+   * Called for every non-boundary element node (a stitch carries no element and
+   * is skipped — ADR 0006 — so a boundary never reaches here). Return one of
+   * `ctx.ignore()`, `ctx.bone()`, or `ctx.keep()`. An `ignore`/`bone` decision
+   * stops the descent (the subtree lowers); `keep` recurses.
+   */
+  element?(ctx: CaptureWalkerContext): WalkerDecision;
+}
+/**
+ * Typed identity wrapper for authoring a capture walker (ADR 0018) — the
+ * `defineConfig` pattern. It returns its argument unchanged at runtime; its only
+ * job is to infer and check the `XrayCaptureWalker` shape at the call site so an
+ * author gets completion and a typo in a hook name is caught.
+ */
+declare function defineXrayCaptureWalker(walker: XrayCaptureWalker): XrayCaptureWalker;
+/**
+ * Thrown when a subtree has more nodes than the capture limit — almost always
+ * a `<Skeleton>` sitting too high in the tree. Raised after the cheap walk and
+ * before the O(rules × nodes) CSS extraction, so an oversized capture is
+ * refused without freezing the main thread on it.
+ */
+declare class CaptureTooLargeError extends Error {
+  readonly nodeCount: number;
+  /** Folds the oversized-capture warning into the shared diagnostics vocabulary (diagnostics.ts). */
+  readonly code: "too-large";
+  constructor(nodeCount: number);
+}
+//#endregion
+export { XrayCaptureWalker as a, WalkerDecision as i, CaptureTooLargeError as n, defineXrayCaptureWalker as o, CaptureWalkerContext as r, CaptureOptions as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hueest/xray",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Auto-captured skeleton loading screens for Vite — capture the structure, ship the plate.",
   "keywords": [
     "loading",
@@ -58,6 +58,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@chenglou/pretext": "0.0.8",
     "devalue": "5.8.1",
     "valibot": "1.4.1"
   },