@hueest/xray 0.1.0 → 0.2.0

package/dist/react.core-CqnDjfAJ.js

@@ -1,59 +0,0 @@
-import { a as ROOT_ATTR, o as ROOT_CLASS, t as BASE_CSS } from "./plate-BuzRMPx4.js";
-import { Fragment } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
-//#region src/react.core.tsx
-/** Layout-neutral wrapper for an HTML island sitting beside React stitch nodes —
-* its children participate in the grandparent's flow, so grid/flex item counts
-* are unchanged. */
-const DISPLAY_CONTENTS = { display: "contents" };
-/**
-* Render a shipped plate's skeleton. `resolveStitch` turns a child plate name
-* into the node that mounts it (static `refs` in prod, a store-subscribed
-* component in dev). `nested` is true for a stitch-mounted child, which skips
-* BASE_CSS — the outermost view already emitted it (ADR 0007). Returns null
-* when the plate has no capture yet; the caller renders the fallback.
-*/
-function renderPlate(plate, resolveStitch, nested) {
-	if (!plate.chunks) return null;
-	const className = plate.rootCls ? `${ROOT_CLASS} ${plate.rootCls}` : ROOT_CLASS;
-	const rootAttrs = {
-		[ROOT_ATTR]: plate.name,
-		className,
-		"aria-hidden": true,
-		"aria-busy": true
-	};
-	const css = nested ? plate.css : `${BASE_CSS}\n${plate.css}`;
-	const chunks = plate.chunks;
-	if (chunks.length === 1 && typeof chunks[0] === "string") {
-		const html = `<style>${css}</style>${chunks[0]}`;
-		return /* @__PURE__ */ jsx("div", {
-			...rootAttrs,
-			dangerouslySetInnerHTML: { __html: html }
-		});
-	}
-	return /* @__PURE__ */ jsxs("div", {
-		...rootAttrs,
-		children: [/* @__PURE__ */ jsx("style", { children: css }), renderChunks(chunks, resolveStitch)]
-	});
-}
-/**
-* Each `string` chunk is injected as a display:contents innerHTML island; each
-* `{ r }` stitch resolves through `resolveStitch`; a `{ c, k }` node stays a
-* real element and recurses (it holds a stitch deeper). No per-node tree walk —
-* the strings are already serialized.
-*/
-function renderChunks(chunks, resolveStitch) {
-	return chunks.map((chunk, i) => {
-		if (typeof chunk === "string") return /* @__PURE__ */ jsx("div", {
-			style: DISPLAY_CONTENTS,
-			dangerouslySetInnerHTML: { __html: chunk }
-		}, i);
-		if ("r" in chunk) return /* @__PURE__ */ jsx(Fragment, { children: resolveStitch(chunk.r) }, i);
-		return /* @__PURE__ */ jsx("div", {
-			className: chunk.c,
-			children: renderChunks(chunk.k, resolveStitch)
-		}, i);
-	});
-}
-//#endregion
-export { renderPlate as t };

package/dist/react.core-fgWG_svU.d.ts

@@ -1,21 +0,0 @@
-import { r as Plate } from "./plate-DboxMKg-.js";
-import { ReactNode } from "react";
-
-//#region src/react.core.d.ts
-/** Props accepted by the React `<Skeleton>` component. */
-interface SkeletonProps {
-  /** The plate to render while loading, imported from `virtual:xray/plates/<name>`. */
-  plate: Plate;
-  /** Explicit readiness mode: render the Skeleton while true, then render children and capture them in dev when false. */
-  loading?: boolean;
-  /** Suspense mode: make `<Skeleton>` the Suspense boundary and use the Plate as the fallback until children resolve. */
-  suspense?: boolean;
-  /** Shown while loading when the plate has no capture yet. */
-  fallback?: ReactNode;
-  /** Override the plugin's settle delay before this site is captured (dev only). */
-  delay?: number;
-  /** Real content. In dev, these children are also the capture source once ready. */
-  children?: ReactNode;
-}
-//#endregion
-export { SkeletonProps as t };

package/dist/serialize.d.ts

@@ -1,88 +0,0 @@
-import { n as MergedPlate, s as ViewCapture, t as LeafKind } from "./plate-DboxMKg-.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;
-}
-/**
- * Capture the rendered subtree(s) under a Skeleton into a Plate. `roots` are
- * the component's top-level elements (the children of the layout-neutral
- * wrapper); the synthetic root node (id 0) stands in for the wrapper itself.
- */
-declare function capture(roots: readonly Element[], options: CaptureOptions): MergedPlate;
-/**
- * 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;
-  constructor(nodeCount: number);
-}
-interface CaptureRegimeOptions {
-  /** Refuse (throw `CaptureTooLargeError`) before CSS extraction if the walk exceeds this. */
-  maxNodes?: number;
-}
-/**
- * Capture one view's worth of a component: the tree plus id-form rules,
- * with the viewport width it was taken at. The caller (the dev client)
- * derives the view interval and ships it off; `capture` is the
- * single-view convenience on top.
- */
-declare function captureRegime(roots: readonly Element[], options?: CaptureRegimeOptions): ViewCapture;
-/** One measurement per walked node, ids matching what `capture` assigns. */
-interface AuditEntry {
-  id: number;
-  tag: string;
-  leaf?: LeafKind;
-  w: number;
-  h: number;
-}
-/**
- * Walk a live subtree exactly like `capture` does, but return per-node
- * geometry instead of a plate. Rendering the captured plate and auditing both
- * sides gives an id-aligned fidelity diff (used by the M1 bake-off).
- */
-declare function audit(roots: readonly Element[]): AuditEntry[];
-/**
- * Shrink a text run's measured box to what's actually painted. A `Range`'s
- * rect is the text's full geometry and ignores ancestor clipping, so a
- * `-webkit-line-clamp` box (fewer lines than the text fills) or a single-line
- * `text-overflow: ellipsis` (`white-space: nowrap; overflow: hidden`) makes the
- * bar over-measure — a 2-line title bone rendered at its unclamped 5-line
- * height. Painted text can't exceed any clipping ancestor's content box, so we
- * intersect with each: per axis the ancestor clips (`overflow !== visible`),
- * clamp to its content box. A non-clipping or larger ancestor leaves it be, so
- * unclamped text is untouched. Walks to the root since the clamp may sit a few
- * inline wrappers up from the text node.
- */
-interface ClippingStyle {
-  overflowX: string;
-  overflowY: string;
-  paddingTop: string;
-  paddingBottom: string;
-  paddingLeft: string;
-  paddingRight: string;
-  borderTopWidth: string;
-  borderBottomWidth: string;
-  borderLeftWidth: string;
-  borderRightWidth: string;
-}
-interface ClippingWindow {
-  getComputedStyle(element: Element): ClippingStyle;
-}
-declare function clampToClipping(width: number, height: number, fromParent: Element | null, win: ClippingWindow): {
-  width: number;
-  height: number;
-};
-//#endregion
-export { AuditEntry, CaptureOptions, CaptureRegimeOptions, CaptureTooLargeError, audit, capture, captureRegime, clampToClipping };

package/dist/serialize.js

@@ -1,2 +0,0 @@
-import { a as clampToClipping, i as captureRegime, n as audit, r as capture, t as CaptureTooLargeError } from "./serialize-Bq6yJnNV.js";
-export { CaptureTooLargeError, audit, capture, captureRegime, clampToClipping };