@arcfusionz/arc-analytic-ui 0.0.0

package/dist/lib/vega/time.d.ts

@@ -0,0 +1,45 @@
+//#region src/lib/vega/time.d.ts
+/** An instant read as a wall-clock date and time in a time zone. */
+interface ZonedParts {
+  year: number;
+  /** 1–12, the way a calendar names a month. */
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+}
+/**
+ * An instant's wall-clock parts in the zone. Without a zone — or with one the
+ * runtime does not know — the runtime's own zone applies, the way `Intl`
+ * itself would default.
+ */
+declare function zonedParts(utcMs: number, timeZone?: string): ZonedParts;
+/**
+ * The zone's offset from UTC at an instant, in milliseconds — positive east of
+ * Greenwich. Without a zone (or with an unknown one) the runtime's own offset
+ * applies, the way `Intl` itself would default.
+ */
+declare function timeZoneOffsetMs(utcMs: number, timeZone?: string): number;
+/**
+ * Midnight at the start of a calendar date in the zone, as an instant — the
+ * date named by its parts. Two passes absorb a daylight-saving shift on the
+ * day itself.
+ */
+declare function zonedMidnight(year: number, monthIndex: number, day: number, timeZone?: string): number;
+/**
+ * Midnight at the start of the calendar day an instant falls in, in the zone —
+ * the boundary `zonedMidnight` names, reached from an instant rather than from
+ * calendar parts. Two passes absorb a daylight-saving shift on the day itself.
+ */
+declare function zonedDayStart(utcMs: number, timeZone?: string): number;
+/**
+ * An instant from a `Date`, a timestamp, or an ISO string. `Date`s and
+ * timestamps pass through; a date-only string is that calendar day's midnight
+ * in the zone (`"2026-09-01"` in `Asia/Bangkok` is 31 August 17:00 UTC), so a
+ * card's readings land on the calendar dates the product means rather than on
+ * UTC days.
+ */
+declare function resolveInstant(value: Date | string | number, timeZone?: string): number;
+//#endregion
+export { ZonedParts, resolveInstant, timeZoneOffsetMs, zonedDayStart, zonedMidnight, zonedParts };

package/dist/lib/vega/time.js

@@ -0,0 +1,105 @@
+//#region src/lib/vega/time.ts
+const SECOND_MS = 1e3;
+const MINUTE_MS = 6e4;
+const DAY_MS = 864e5;
+const DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+const offsetFormatCache = /* @__PURE__ */ new Map();
+function offsetFormat(timeZone) {
+	const cached = offsetFormatCache.get(timeZone);
+	if (cached !== void 0) return cached;
+	let formatter = null;
+	try {
+		formatter = new Intl.DateTimeFormat("en-US-u-ca-gregory", {
+			timeZone,
+			hourCycle: "h23",
+			year: "numeric",
+			month: "numeric",
+			day: "numeric",
+			hour: "numeric",
+			minute: "numeric",
+			second: "numeric"
+		});
+	} catch {
+		formatter = null;
+	}
+	offsetFormatCache.set(timeZone, formatter);
+	return formatter;
+}
+/**
+* An instant's wall-clock parts in the zone. Without a zone — or with one the
+* runtime does not know — the runtime's own zone applies, the way `Intl`
+* itself would default.
+*/
+function zonedParts(utcMs, timeZone) {
+	const formatter = timeZone ? offsetFormat(timeZone) : null;
+	if (!formatter) {
+		const local = new Date(utcMs);
+		return {
+			year: local.getFullYear(),
+			month: local.getMonth() + 1,
+			day: local.getDate(),
+			hour: local.getHours(),
+			minute: local.getMinutes(),
+			second: local.getSeconds()
+		};
+	}
+	const parts = {};
+	for (const part of formatter.formatToParts(new Date(utcMs))) if (part.type !== "literal") parts[part.type] = Number(part.value);
+	return {
+		year: parts.year ?? 1970,
+		month: parts.month ?? 1,
+		day: parts.day ?? 1,
+		hour: (parts.hour ?? 0) % 24,
+		minute: parts.minute ?? 0,
+		second: parts.second ?? 0
+	};
+}
+/**
+* The zone's offset from UTC at an instant, in milliseconds — positive east of
+* Greenwich. Without a zone (or with an unknown one) the runtime's own offset
+* applies, the way `Intl` itself would default.
+*/
+function timeZoneOffsetMs(utcMs, timeZone) {
+	if (!timeZone || !offsetFormat(timeZone)) return -new Date(utcMs).getTimezoneOffset() * MINUTE_MS;
+	const { year, month, day, hour, minute, second } = zonedParts(utcMs, timeZone);
+	return Date.UTC(year, month - 1, day, hour, minute, second) - Math.floor(utcMs / SECOND_MS) * SECOND_MS;
+}
+/**
+* Midnight at the start of a calendar date in the zone, as an instant — the
+* date named by its parts. Two passes absorb a daylight-saving shift on the
+* day itself.
+*/
+function zonedMidnight(year, monthIndex, day, timeZone) {
+	const guess = Date.UTC(year, monthIndex, day);
+	return guess - timeZoneOffsetMs(guess - timeZoneOffsetMs(guess, timeZone), timeZone);
+}
+/**
+* Midnight at the start of the calendar day an instant falls in, in the zone —
+* the boundary `zonedMidnight` names, reached from an instant rather than from
+* calendar parts. Two passes absorb a daylight-saving shift on the day itself.
+*/
+function zonedDayStart(utcMs, timeZone) {
+	const offset = timeZoneOffsetMs(utcMs, timeZone);
+	const local = utcMs + offset;
+	const midnightLocal = Math.floor(local / DAY_MS) * DAY_MS;
+	return midnightLocal - timeZoneOffsetMs(midnightLocal - offset, timeZone);
+}
+/**
+* An instant from a `Date`, a timestamp, or an ISO string. `Date`s and
+* timestamps pass through; a date-only string is that calendar day's midnight
+* in the zone (`"2026-09-01"` in `Asia/Bangkok` is 31 August 17:00 UTC), so a
+* card's readings land on the calendar dates the product means rather than on
+* UTC days.
+*/
+function resolveInstant(value, timeZone) {
+	if (value instanceof Date) return value.getTime();
+	if (typeof value === "number") return value;
+	const match = DATE_ONLY.exec(value);
+	if (!match) return new Date(value).getTime();
+	if (!timeZone) return (/* @__PURE__ */ new Date(`${value}T00:00:00`)).getTime();
+	const [, year, month, day] = match.map(Number);
+	const guess = Date.UTC(year ?? 1970, (month ?? 1) - 1, day ?? 1);
+	return guess - timeZoneOffsetMs(guess - timeZoneOffsetMs(guess, timeZone), timeZone);
+}
+//#endregion
+export { resolveInstant, timeZoneOffsetMs, zonedDayStart, zonedMidnight, zonedParts };

package/dist/lib/vega/tokens.d.ts

@@ -0,0 +1,73 @@
+import { RefObject } from "react";
+//#region src/lib/vega/tokens.d.ts
+/**
+ * The chart token group from `colors.css`, resolved to paintable values.
+ *
+ * Vega draws computed colors into SVG/canvas and cannot read `var()`, so the
+ * bridge reads every `--color-chart-*` token (plus the text and surface roles
+ * Vega text and halos borrow, and the two font stacks) from the component's
+ * own node at runtime — subtree-scoped themes therefore resolve correctly —
+ * and rebuilds the Vega config when the theme changes.
+ */
+interface ChartTokens {
+  /** Categorical identity slots in fixed order (`chart-1…N`). Only the slots the theme defines are present. */
+  category: string[];
+  /** The one hue a single-series chart draws with (`chart-emphasis`). */
+  emphasis: string;
+  /** The gray that recedes behind the emphasis series (`chart-context`). */
+  context: string;
+  /** Magnitude ramp, low → high (`chart-sequential-1…7`). */
+  sequential: string[];
+  /** Polarity scale ends and midpoint (`chart-diverging-*`). */
+  divergingNegative: string;
+  divergingMid: string;
+  divergingPositive: string;
+  /** Delta text steps (`chart-positive` / `chart-negative`) — the same values `text-success-700` / `text-error-700` resolve to. */
+  positive: string;
+  negative: string;
+  /**
+   * The severity ladder for state marks (`chart-status-*`) — the one place the
+   * reserved status hues belong on a mark, because there the encoded value IS
+   * good or bad. `maintenance` (planned) and `unknown` (nobody was watching)
+   * sit outside the ladder. Keyed by `StatusLevel`.
+   */
+  status: {
+    operational: string;
+    degraded: string;
+    down: string;
+    maintenance: string;
+    unknown: string;
+  };
+  /** Guides. */
+  grid: string;
+  axis: string;
+  axisLabel: string;
+  reference: string;
+  selection: string;
+  brush: string;
+  /** Page roles: text Vega draws, the surface used for halos and gaps between touching fills, and the muted fill a guide track borrows (the Meter's own track colour). */
+  foreground: string;
+  mutedForeground: string;
+  background: string;
+  surface: string;
+  muted: string;
+  /** Font stacks (`--font-sans`, `--font-heading`); the Thai fallback rides the stack string. */
+  fontSans: string;
+  fontHeading: string;
+}
+/**
+ * Reads the chart token group as computed on `el`. Call from an effect (the
+ * node must be attached and styled); prefer `useChartTokens`, which re-reads
+ * when the theme flips.
+ */
+declare function readChartTokens(el: Element): ChartTokens;
+/**
+ * Chart tokens for the element behind `ref`, re-read when `class`, `data-theme`
+ * or `style` change on `<html>` (the theme toggle) or when `theme` changes (an
+ * explicit theme prop on a subtree). `null` until the first read completes
+ * after mount; the returned object keeps its identity while the values are
+ * unchanged, so a spec memoized on it does not rebuild for nothing.
+ */
+declare function useChartTokens(ref: RefObject<Element | null>, theme?: string): ChartTokens | null;
+//#endregion
+export { ChartTokens, readChartTokens, useChartTokens };

package/dist/lib/vega/tokens.js

@@ -0,0 +1,137 @@
+import { useEffect, useState } from "react";
+//#region src/lib/vega/tokens.ts
+const MAX_CATEGORY_SLOTS = 12;
+const SEQUENTIAL_STEPS = 7;
+const FALLBACK_TOKENS = {
+	category: [
+		"#1848f3",
+		"#4b3dbf",
+		"#4a5878"
+	],
+	emphasis: "#1848f3",
+	context: "#647195",
+	sequential: [
+		"#dfeafd",
+		"#c2d4f9",
+		"#9bbaf8",
+		"#699ef7",
+		"#3b82f6",
+		"#1848f3",
+		"#143ad4"
+	],
+	divergingNegative: "#ee4540",
+	divergingMid: "#dee4ef",
+	divergingPositive: "#059b4e",
+	positive: "#077c41",
+	negative: "#b81d19",
+	status: {
+		operational: "#059b4e",
+		degraded: "#b36209",
+		down: "#db2723",
+		maintenance: "#3b82f6",
+		unknown: "#647195"
+	},
+	grid: "#dee4ef",
+	axis: "#93a2bd",
+	axisLabel: "#647195",
+	reference: "#647195",
+	selection: "#1848f3",
+	brush: "#c2d4f9",
+	foreground: "#111a30",
+	mutedForeground: "#647195",
+	background: "#ffffff",
+	surface: "#f7f9fc",
+	muted: "#eff2f8",
+	fontSans: "Inter, Sarabun, ui-sans-serif, system-ui, sans-serif",
+	fontHeading: "Inter, Sarabun, ui-sans-serif, system-ui, sans-serif"
+};
+/**
+* Reads the chart token group as computed on `el`. Call from an effect (the
+* node must be attached and styled); prefer `useChartTokens`, which re-reads
+* when the theme flips.
+*/
+function readChartTokens(el) {
+	const style = getComputedStyle(el);
+	const read = (name, fallback) => {
+		return style.getPropertyValue(name).trim() || fallback;
+	};
+	const category = [];
+	for (let slot = 1; slot <= MAX_CATEGORY_SLOTS; slot += 1) {
+		const value = style.getPropertyValue(`--color-chart-${slot}`).trim();
+		if (!value) break;
+		category.push(value);
+	}
+	const sequential = [];
+	for (let step = 1; step <= SEQUENTIAL_STEPS; step += 1) {
+		const value = style.getPropertyValue(`--color-chart-sequential-${step}`).trim();
+		if (!value) break;
+		sequential.push(value);
+	}
+	return {
+		category: category.length > 0 ? category : FALLBACK_TOKENS.category,
+		emphasis: read("--color-chart-emphasis", FALLBACK_TOKENS.emphasis),
+		context: read("--color-chart-context", FALLBACK_TOKENS.context),
+		sequential: sequential.length > 0 ? sequential : FALLBACK_TOKENS.sequential,
+		divergingNegative: read("--color-chart-diverging-negative", FALLBACK_TOKENS.divergingNegative),
+		divergingMid: read("--color-chart-diverging-mid", FALLBACK_TOKENS.divergingMid),
+		divergingPositive: read("--color-chart-diverging-positive", FALLBACK_TOKENS.divergingPositive),
+		positive: read("--color-chart-positive", FALLBACK_TOKENS.positive),
+		negative: read("--color-chart-negative", FALLBACK_TOKENS.negative),
+		status: {
+			operational: read("--color-chart-status-operational", FALLBACK_TOKENS.status.operational),
+			degraded: read("--color-chart-status-degraded", FALLBACK_TOKENS.status.degraded),
+			down: read("--color-chart-status-down", FALLBACK_TOKENS.status.down),
+			maintenance: read("--color-chart-status-maintenance", FALLBACK_TOKENS.status.maintenance),
+			unknown: read("--color-chart-status-unknown", FALLBACK_TOKENS.status.unknown)
+		},
+		grid: read("--color-chart-grid", FALLBACK_TOKENS.grid),
+		axis: read("--color-chart-axis", FALLBACK_TOKENS.axis),
+		axisLabel: read("--color-chart-axis-label", FALLBACK_TOKENS.axisLabel),
+		reference: read("--color-chart-reference", FALLBACK_TOKENS.reference),
+		selection: read("--color-chart-selection", FALLBACK_TOKENS.selection),
+		brush: read("--color-chart-brush", FALLBACK_TOKENS.brush),
+		foreground: read("--color-foreground", FALLBACK_TOKENS.foreground),
+		mutedForeground: read("--color-muted-foreground", FALLBACK_TOKENS.mutedForeground),
+		background: read("--color-background", FALLBACK_TOKENS.background),
+		surface: read("--color-surface", FALLBACK_TOKENS.surface),
+		muted: read("--color-muted", FALLBACK_TOKENS.muted),
+		fontSans: read("--font-sans", FALLBACK_TOKENS.fontSans),
+		fontHeading: read("--font-heading", FALLBACK_TOKENS.fontHeading)
+	};
+}
+function sameTokens(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+/**
+* Chart tokens for the element behind `ref`, re-read when `class`, `data-theme`
+* or `style` change on `<html>` (the theme toggle) or when `theme` changes (an
+* explicit theme prop on a subtree). `null` until the first read completes
+* after mount; the returned object keeps its identity while the values are
+* unchanged, so a spec memoized on it does not rebuild for nothing.
+*/
+function useChartTokens(ref, theme) {
+	const [tokens, setTokens] = useState(null);
+	useEffect(() => {
+		const el = ref.current;
+		if (!el) return;
+		const read = () => {
+			const next = readChartTokens(el);
+			setTokens((prev) => prev && sameTokens(prev, next) ? prev : next);
+		};
+		read();
+		if (typeof MutationObserver === "undefined") return;
+		const observer = new MutationObserver(read);
+		observer.observe(document.documentElement, {
+			attributes: true,
+			attributeFilter: [
+				"class",
+				"data-theme",
+				"style"
+			]
+		});
+		return () => observer.disconnect();
+	}, [ref, theme]);
+	return tokens;
+}
+//#endregion
+export { readChartTokens, useChartTokens };

package/dist/lib/vega/tooltip.d.ts

@@ -0,0 +1,45 @@
+import { ReactNode } from "react";
+import { Item, TooltipHandler } from "vega";
+//#region src/lib/vega/tooltip.d.ts
+/** What the handler saw: the evaluated `tooltip` signal, the scenegraph item, and the pointer event. */
+interface ArcTooltipContext {
+  /** The evaluated tooltip value — a string, or an object of title → formatted value for the `tooltip` channel. */
+  value: unknown;
+  /** The hovered scenegraph item. For Vega-Lite's `nearest` voronoi cells the point's datum is `item.datum.datum`. */
+  item: Item;
+  event: MouseEvent;
+}
+interface UseArcTooltipHandlerOptions {
+  /**
+   * Renders the chip content from the hovered item. Return `null` to show
+   * nothing. Default: the tooltip value's title → value pairs, formatted by
+   * Vega. Format in React here when the chart's DOM text has its own
+   * formatter, so the two can never round differently.
+   */
+  content?: (context: ArcTooltipContext) => ReactNode;
+}
+interface ArcTooltipHandle {
+  /** Pass to `arcEmbedOptions({ tooltip })`. Stable for the life of the component. */
+  handler: TooltipHandler;
+  /** Render this once anywhere in the component tree; it portals the chip to `<body>`. */
+  tooltip: ReactNode;
+  open: boolean;
+}
+/** Title → value rows in the chip's own type. */
+declare function ArcTooltipRows({ rows }: {
+  rows: readonly (readonly [label: ReactNode, value: ReactNode])[];
+}): import("react").JSX.Element;
+/**
+ * A Vega tooltip handler that lifts the hovered value into React state and
+ * renders the Arc tooltip chip (`tooltipPopupVariants()`) at the pointer,
+ * flipped inside the viewport, text only (React children — never
+ * `innerHTML`), dismissed on Escape. It replaces vega-tooltip's injected
+ * `#vg-tooltip-element` and stylesheet.
+ *
+ * The chip is `aria-hidden`: like the `Tooltip` primitive's popup it is a
+ * redundant visual hint — every value it shows must also be reachable through
+ * labels, the summary sentence, or the table twin.
+ */
+declare function useArcTooltipHandler({ content }?: UseArcTooltipHandlerOptions): ArcTooltipHandle;
+//#endregion
+export { ArcTooltipContext, ArcTooltipHandle, ArcTooltipRows, UseArcTooltipHandlerOptions, useArcTooltipHandler };

package/dist/lib/vega/tooltip.js

@@ -0,0 +1,124 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { tooltipPopupVariants } from "@arcfusionz/arc-primitive-ui";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { createPortal } from "react-dom";
+//#region src/lib/vega/tooltip.tsx
+const OFFSET_PX = 12;
+const VIEWPORT_MARGIN_PX = 8;
+/** Title → value rows in the chip's own type. */
+function ArcTooltipRows({ rows }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex flex-col gap-0.5",
+		children: rows.map(([label, value], index) => /* @__PURE__ */ jsxs("div", {
+			className: "flex items-baseline justify-between gap-3",
+			children: [/* @__PURE__ */ jsx("span", {
+				className: "text-background/70",
+				children: label
+			}), /* @__PURE__ */ jsx("span", {
+				className: "font-medium tabular-nums",
+				children: value
+			})]
+		}, index))
+	});
+}
+function defaultContent(value) {
+	if (value !== null && typeof value === "object") {
+		const rows = Object.entries(value).map(([label, entry]) => [label, String(entry)]);
+		return /* @__PURE__ */ jsx(ArcTooltipRows, { rows });
+	}
+	return String(value);
+}
+function ArcTooltipChip({ x, y, onDismiss, children }) {
+	const ref = useRef(null);
+	const [position, setPosition] = useState({
+		left: x + OFFSET_PX,
+		top: y + OFFSET_PX
+	});
+	useLayoutEffect(() => {
+		const el = ref.current;
+		if (!el) return;
+		const rect = el.getBoundingClientRect();
+		let left = x + OFFSET_PX;
+		let top = y + OFFSET_PX;
+		if (left + rect.width > window.innerWidth - VIEWPORT_MARGIN_PX) left = x - OFFSET_PX - rect.width;
+		if (top + rect.height > window.innerHeight - VIEWPORT_MARGIN_PX) top = y - OFFSET_PX - rect.height;
+		setPosition({
+			left: Math.max(VIEWPORT_MARGIN_PX, left),
+			top: Math.max(VIEWPORT_MARGIN_PX, top)
+		});
+	}, [
+		x,
+		y,
+		children
+	]);
+	useEffect(() => {
+		const onKeyDown = (event) => {
+			if (event.key === "Escape") onDismiss();
+		};
+		window.addEventListener("keydown", onKeyDown);
+		return () => window.removeEventListener("keydown", onKeyDown);
+	}, [onDismiss]);
+	if (typeof document === "undefined") return null;
+	return createPortal(/* @__PURE__ */ jsx("div", {
+		ref,
+		role: "presentation",
+		"aria-hidden": "true",
+		"data-part": "chart-tooltip",
+		className: tooltipPopupVariants({ className: "pointer-events-none fixed z-50 whitespace-nowrap" }),
+		style: {
+			left: position.left,
+			top: position.top
+		},
+		children
+	}), document.body);
+}
+/**
+* A Vega tooltip handler that lifts the hovered value into React state and
+* renders the Arc tooltip chip (`tooltipPopupVariants()`) at the pointer,
+* flipped inside the viewport, text only (React children — never
+* `innerHTML`), dismissed on Escape. It replaces vega-tooltip's injected
+* `#vg-tooltip-element` and stylesheet.
+*
+* The chip is `aria-hidden`: like the `Tooltip` primitive's popup it is a
+* redundant visual hint — every value it shows must also be reachable through
+* labels, the summary sentence, or the table twin.
+*/
+function useArcTooltipHandler({ content } = {}) {
+	const [state, setState] = useState(null);
+	const contentRef = useRef(content);
+	contentRef.current = content;
+	const handler = useCallback((_handler, event, item, value) => {
+		if (value == null || value === "") {
+			setState(null);
+			return;
+		}
+		const render = contentRef.current;
+		const node = render ? render({
+			value,
+			item,
+			event
+		}) : defaultContent(value);
+		if (node == null) {
+			setState(null);
+			return;
+		}
+		setState({
+			x: event.clientX,
+			y: event.clientY,
+			node
+		});
+	}, []);
+	const dismiss = useCallback(() => setState(null), []);
+	return {
+		handler,
+		tooltip: state ? /* @__PURE__ */ jsx(ArcTooltipChip, {
+			x: state.x,
+			y: state.y,
+			onDismiss: dismiss,
+			children: state.node
+		}) : null,
+		open: state != null
+	};
+}
+//#endregion
+export { ArcTooltipRows, useArcTooltipHandler };

package/dist/lib/vega/useArcVega.d.ts

@@ -0,0 +1,43 @@
+import { RefObject } from "react";
+import { TopLevelSpec } from "vega-lite";
+import { EmbedOptions, Result } from "vega-embed";
+//#region src/lib/vega/useArcVega.d.ts
+/** Named datasets pushed through the View API — `{ table: rows }` for a spec with `data: { name: "table" }`. */
+type ArcVegaDatasets = Readonly<Record<string, readonly object[]>>;
+interface UseArcVegaParams {
+  /** The element vega-embed renders into. */
+  ref: RefObject<HTMLDivElement | null>;
+  /**
+   * The structural spec: named datasets, no inline values, memoized. Any deep
+   * change re-embeds (react-vega compares with fast-deep-equal), so data,
+   * size and description must travel through the other params, not the spec.
+   */
+  spec: TopLevelSpec;
+  /** `arcEmbedOptions(...)`, memoized for the same reason. */
+  options: EmbedOptions;
+  /** Rows per named dataset. A new array for a dataset pushes it with `view.data` and runs the dataflow once; a name no layer of the spec reads is ignored. */
+  datasets?: ArcVegaDatasets;
+  /** The accessible description (`aria-label` of the `graphics-document`), set live with `view.description`. */
+  description?: string;
+  /** Plot width in pixels from the frame's ResizeObserver, applied with `view.width` — never through the spec. */
+  width?: number;
+  /** Plot height in pixels, applied with `view.height`. */
+  height?: number;
+  /** Variable params driven from Arc controls, applied with `view.signal`. */
+  signals?: Readonly<Record<string, unknown>>;
+  /** Selection params read back: listeners are attached once per view and always call the latest callback. */
+  onSignal?: Readonly<Record<string, (value: unknown) => void>>;
+  onEmbed?: (result: Result) => void;
+  onError?: (error: unknown) => void;
+}
+/**
+ * react-vega 8's `useVegaEmbed` plus the View API discipline the analytics
+ * package needs: one embed per mount (a re-embed only when the structural spec
+ * or the options change), and one `runAsync` per batch of data / size /
+ * description / signal changes. Listeners and callbacks go through
+ * latest-value refs, so they never go stale while the view lives; react-vega
+ * finalizes the view on unmount and before every re-embed.
+ */
+declare function useArcVega(params: UseArcVegaParams): Result | null;
+//#endregion
+export { ArcVegaDatasets, UseArcVegaParams, useArcVega };