@arcfusionz/arc-analytic-ui 0.0.0

package/dist/components/AnomalyCard/AnomalyCard.model.js

@@ -0,0 +1,553 @@
+import { formatDate, formatDateRange, formatDelta, formatNumber } from "../../lib/vega/formatters.js";
+//#region src/components/AnomalyCard/AnomalyCard.model.ts
+const DEFAULT_ANOMALY_LABELS = {
+	high: "Above range",
+	low: "Below range",
+	mixed: "Both directions",
+	inRange: "In range",
+	percentagePoints: " pp",
+	noData: "No data",
+	noMatch: "No matching data",
+	clearFilters: "Clear filters",
+	error: "Couldn't load this metric",
+	retry: "Try again",
+	insufficient: "Not enough data to judge",
+	unjudged: "No expected range supplied — readings are plotted but not judged",
+	stale: "Stale",
+	asOf: "As of",
+	verdicts: {
+		clear: "In range",
+		watch: "Recovered",
+		breach: "Out of range"
+	},
+	seriesKey: "Actual",
+	bandKey: "Expected range",
+	expectedKey: "Expected",
+	flagKey: "Anomaly",
+	tablePeriod: "Period",
+	tableValue: "Value",
+	tableExpected: "Expected",
+	tableRange: "Range",
+	tableDeviation: "Deviation",
+	tableFlag: "Flag",
+	score: "Score",
+	episodes: "Excursions",
+	episodeGroup: (name) => `Excursions in ${name}`,
+	openEpisode: ({ range, direction, periods, deviation, score, ongoing }) => `Open the ${range} excursion — ${direction}, ${periods}` + (deviation ? `, ${deviation}` : "") + (score ? `, score ${score}` : "") + (ongoing ? ", ongoing" : ""),
+	ongoing: "ongoing",
+	periodCount: (count) => `${count} ${count === 1 ? "period" : "periods"}`,
+	moreEpisodes: (count) => `${count} more`,
+	noEpisodes: "No excursions in this window",
+	showTable: (name) => `Show the data behind ${name}`,
+	hideTable: (name) => `Hide the data behind ${name}`,
+	about: (name) => `About ${name}`,
+	loading: (name) => `Loading ${name}`,
+	tableCaption: (name) => `Data behind ${name}`,
+	standingGroup: (name) => `${name} against its expected range`,
+	explanation: ({ periodText, valueText, expectedText, rangeText, deviationText, secondaryText, scoreText, direction }) => {
+		const rows = [["Period", periodText], ["Value", valueText]];
+		if (expectedText) rows.push(["Expected", expectedText]);
+		rows.push(["Range", rangeText]);
+		rows.push([direction === "high" ? "Above range" : direction === "low" ? "Below range" : "Deviation", deviationText]);
+		if (secondaryText) rows.push(["Deviation %", secondaryText]);
+		if (scoreText) rows.push(["Score", scoreText]);
+		return rows;
+	},
+	expectedRange: (range) => `Expected ${range}`,
+	ofJudged: (count) => `of ${count} periods judged`,
+	verdictSentence: ({ verdict, name, count, range, latest }) => {
+		if (verdict === "clear") return `${name} stayed inside its expected range across ${range}.`;
+		if (verdict === "breach") return count === 1 ? `${name} is outside its expected range now, at ${latest}.` : `${name} is outside its expected range now, at ${latest}, after ${count} excursions across ${range}.`;
+		return count === 1 ? `${name} left its expected range once across ${range} and is back inside, at ${latest}.` : `${name} left its expected range ${count} times across ${range} and is back inside, at ${latest}.`;
+	},
+	worstSentence: ({ period, value, deviation, bound, direction }) => `Furthest out on ${period}: ${value}, ${deviation} ${direction.toLowerCase()} the expected ${bound}.`,
+	scoreSentence: (score) => `Peak score ${score}.`,
+	markNames: {
+		line: "Line",
+		area: "Area"
+	},
+	chartDescription: ({ mark, name, periodCount, range, min, max, flagged, band }) => `${mark} chart of ${name} against its expected range: ${periodCount} periods, ${range}, ranging ${min} to ${max}.` + (band ? ` ${band}.` : "") + (flagged === 0 ? " No periods outside the range." : ` ${flagged} ${flagged === 1 ? "period" : "periods"} marked outside the range.`),
+	insightMark: "Insight",
+	insight: ({ name, verdict, count, range, worstAt, worstValue, worstDeviation, worstBound, direction, ongoing }) => {
+		if (verdict === "clear") return [`${name} held inside its expected range across ${range}.`];
+		const segments = [
+			`${name} left its expected range `,
+			{ value: count === 1 ? "once" : `${count} times` },
+			` across ${range}`
+		];
+		if (worstAt && worstValue && worstDeviation && worstBound && direction) segments.push(`, furthest on ${worstAt} at `, { value: worstValue }, ` — `, { value: worstDeviation }, ` ${direction.toLowerCase()} the expected ${worstBound}`);
+		segments.push(ongoing ? ". It is still outside the range." : ". It is back inside the range.");
+		return segments;
+	}
+};
+function resolveAnomalyLabels(overrides) {
+	return overrides ? {
+		...DEFAULT_ANOMALY_LABELS,
+		...overrides
+	} : DEFAULT_ANOMALY_LABELS;
+}
+/**
+* The state machine. Error wins; loading over existing readings is a refresh
+* (the previous render stays under the veil); no readings is `no-match` when
+* the consumer's filter caused it and `empty` otherwise.
+*/
+function deriveAnomalyState({ status, hasValue, hasData, filtered }) {
+	if (status === "error") return "error";
+	if (status === "loading") return hasData ? "refreshing" : "loading";
+	if (hasValue) return "ready";
+	return filtered ? "no-match" : "empty";
+}
+const isFinite = (value) => typeof value === "number" && Number.isFinite(value);
+const DAY_MS = 864e5;
+const ISO_DATE = /^\d{4}-\d{2}(-\d{2})?([T ].*)?$/;
+function inferXType(points) {
+	const sample = points.find((point) => point.x != null);
+	if (!sample) return "ordinal";
+	const { x } = sample;
+	if (x instanceof Date) return "temporal";
+	if (typeof x === "number") return "quantitative";
+	return ISO_DATE.test(x) ? "temporal" : "ordinal";
+}
+function inferGranularity(periods) {
+	const xs = periods.filter((x) => typeof x === "number");
+	if (xs.length < 2) return "day";
+	const gaps = [];
+	for (let index = 1; index < xs.length; index += 1) gaps.push(Math.abs(xs[index] - xs[index - 1]));
+	gaps.sort((a, b) => a - b);
+	const median = gaps[Math.floor(gaps.length / 2)];
+	if (median < DAY_MS) return "time";
+	if (median >= 360 * DAY_MS) return "year";
+	if (median >= 27 * DAY_MS) return "month";
+	return "day";
+}
+/**
+* The granularity an x axis labels its ticks at: the tooltip and the table
+* keep the full form (`Sep 8, 2026`); an axis has room for `Sep 8`. Duplicated
+* per component rather than shared, so a card's text grammar is readable in
+* one file.
+*/
+function anomalyAxisGranularity(granularity) {
+	switch (granularity) {
+		case "day": return "day-short";
+		case "month": return "month-short";
+		case "datetime": return "time";
+		default: return granularity;
+	}
+}
+function normalizeX(x, xType) {
+	if (xType === "temporal") {
+		const time = x instanceof Date ? x.getTime() : new Date(x).getTime();
+		return Number.isNaN(time) ? null : time;
+	}
+	if (xType === "quantitative") return isFinite(x) ? x : null;
+	return String(x);
+}
+/**
+* How an excursion reads once the product says which way is good.
+*
+* `none` — the default — is the honest answer for a detector: leaving the
+* expected range is UNEXPECTED, which is not the same as bad. A product that
+* knows (revenue up, latency down) gets the polarity, and with it the
+* diverging hues; a product that does not gets the attention hue for both
+* directions, and the direction is read from the mark's shape and its word.
+*/
+function anomalyPolarityFor(direction, goodDirection) {
+	if (direction == null || goodDirection === "none") return "neutral";
+	return direction === "high" === (goodDirection === "up") ? "positive" : "negative";
+}
+/**
+* The colour one excursion paints with — colour's ONE job here is polarity.
+* A neutral excursion takes the attention hue rather than a diverging end,
+* because saying "good" or "bad" about a move nobody has assigned a direction
+* to is exactly the lie rule 6 exists to prevent. This is one of the two
+* places the reserved status hues belong on a mark: the encoded value IS
+* "this needs a look".
+*/
+function anomalyColorFor(polarity, tokens) {
+	if (polarity === "positive") return tokens.divergingPositive;
+	if (polarity === "negative") return tokens.divergingNegative;
+	return tokens.status.degraded;
+}
+/** Direction as SHAPE, so a flag never depends on hue alone (WCAG 1.4.1). */
+function anomalyShapeFor(direction) {
+	if (direction === "high") return "triangle-up";
+	if (direction === "low") return "triangle-down";
+	return "circle";
+}
+/**
+* Normalises the readings onto one period domain, resolves each period's
+* expected range (its own bounds, else the flat `bounds`), decides the flag
+* (the detector's `anomaly` first, the bounds second), measures how far past
+* the bound each excursion went, and groups consecutive excursions into
+* episodes.
+*
+* The plot's extent spans the readings AND the band, so a cropped `auto`
+* scale can never hide the range the readings are being judged against.
+*
+* Returns `null` when there are no readings to speak of.
+*/
+function normalizeAnomalies(points, { granularity, bounds, goodDirection, tokens }) {
+	if (!points) return null;
+	const xType = inferXType(points);
+	const flatLower = isFinite(bounds?.lower) ? bounds.lower : null;
+	const flatUpper = isFinite(bounds?.upper) ? bounds.upper : null;
+	const byPeriod = /* @__PURE__ */ new Map();
+	const order = [];
+	for (const point of points) {
+		const x = normalizeX(point.x, xType);
+		if (x == null) continue;
+		const id = String(x);
+		if (!byPeriod.has(id)) order.push(id);
+		byPeriod.set(id, {
+			x,
+			point
+		});
+	}
+	if (xType !== "ordinal") order.sort((a, b) => byPeriod.get(a).x - byPeriod.get(b).x);
+	const periods = order.map((id) => byPeriod.get(id).x);
+	const rows = order.map((id) => {
+		const { x, point } = byPeriod.get(id);
+		const y = isFinite(point.y) ? point.y : null;
+		const lo = isFinite(point.lower) ? point.lower : flatLower;
+		const hi = isFinite(point.upper) ? point.upper : flatUpper;
+		const ex = isFinite(point.expected) ? point.expected : null;
+		const sc = isFinite(point.score) ? point.score : null;
+		let dir = null;
+		let d = null;
+		if (y != null) {
+			if (hi != null && y > hi) {
+				dir = "high";
+				d = y - hi;
+			} else if (lo != null && y < lo) {
+				dir = "low";
+				d = y - lo;
+			}
+		}
+		let a = point.anomaly ?? dir != null;
+		if (y == null) a = false;
+		if (!a) {
+			dir = null;
+			d = null;
+		}
+		const polarity = anomalyPolarityFor(dir, goodDirection);
+		return {
+			x,
+			y,
+			lo,
+			hi,
+			ex,
+			d,
+			a,
+			dir,
+			c: anomalyColorFor(polarity, tokens),
+			sh: anomalyShapeFor(dir),
+			e: -1,
+			sc
+		};
+	});
+	const episodes = [];
+	let run = [];
+	const closeRun = () => {
+		if (run.length === 0) return;
+		const index = episodes.length;
+		const members = run.map((at) => rows[at]);
+		for (const at of run) rows[at].e = index;
+		let peak = null;
+		let sawHigh = false;
+		let sawLow = false;
+		for (const row of members) {
+			if (row.dir === "high") sawHigh = true;
+			if (row.dir === "low") sawLow = true;
+			if (row.d == null || row.y == null || row.dir == null) continue;
+			const bound = row.dir === "high" ? row.hi : row.lo;
+			if (bound == null) continue;
+			if ((bound === 0 ? Math.abs(row.d) : Math.abs(row.d / bound)) > (peak == null ? -1 : peak.bound === 0 ? Math.abs(peak.deviation) : Math.abs(peak.deviation / peak.bound))) peak = {
+				x: row.x,
+				y: row.y,
+				deviation: row.d,
+				bound,
+				direction: row.dir,
+				score: row.sc
+			};
+		}
+		const direction = peak?.direction ?? (sawHigh ? "high" : sawLow ? "low" : null);
+		const polarity = anomalyPolarityFor(direction, goodDirection);
+		episodes.push({
+			key: String(members[0].x),
+			index,
+			start: members[0].x,
+			end: members[members.length - 1].x,
+			count: members.length,
+			direction,
+			mixed: sawHigh && sawLow,
+			polarity,
+			color: anomalyColorFor(polarity, tokens),
+			peak,
+			ongoing: run[run.length - 1] === rows.length - 1
+		});
+		run = [];
+	};
+	rows.forEach((row, at) => {
+		if (row.a) run.push(at);
+		else closeRun();
+	});
+	closeRun();
+	const readings = rows.map((row) => row.y).filter((y) => y != null);
+	const extents = [
+		...readings,
+		...rows.map((row) => row.lo).filter((value) => value != null),
+		...rows.map((row) => row.hi).filter((value) => value != null),
+		...rows.map((row) => row.ex).filter((value) => value != null)
+	];
+	const finiteRows = rows.filter((row) => row.y != null);
+	const latest = finiteRows[finiteRows.length - 1] ?? null;
+	const current = latest && latest.a && latest.e >= 0 ? episodes[latest.e] : null;
+	let worst = null;
+	for (const episode of episodes) {
+		if (!episode.peak) continue;
+		if ((episode.peak.bound === 0 ? Math.abs(episode.peak.deviation) : Math.abs(episode.peak.deviation / episode.peak.bound)) > (worst?.peak == null ? -1 : worst.peak.bound === 0 ? Math.abs(worst.peak.deviation) : Math.abs(worst.peak.deviation / worst.peak.bound))) worst = episode;
+	}
+	if (!worst && episodes.length > 0) worst = episodes[0];
+	return {
+		xType,
+		granularity: granularity ?? (xType === "temporal" ? inferGranularity(periods) : "day"),
+		periods,
+		rows,
+		count: readings.length,
+		min: extents.length > 0 ? Math.min(...extents) : null,
+		max: extents.length > 0 ? Math.max(...extents) : null,
+		hasBand: rows.some((row) => row.lo != null || row.hi != null),
+		hasExpected: rows.some((row) => row.ex != null),
+		hasScore: rows.some((row) => row.sc != null),
+		judged: rows.filter((row) => row.y != null && (row.lo != null || row.hi != null)).length,
+		flagged: rows.filter((row) => row.a).length,
+		episodes,
+		latest,
+		current,
+		worst
+	};
+}
+/** The periods the crosshair reads — one row each, so the hover lands on the period. */
+function buildAnomalyPeriodRows(summary) {
+	return summary.periods.map((x) => ({ x }));
+}
+/**
+* The washed span of the selected episode. A wash in the brush role means
+* SELECTION here, which is exactly what this is: the reader picked an
+* excursion and the plot says which one.
+*
+* Always one row while the window has periods — a selection turns `on`, it
+* does not add a row. An empty dataset would contribute an empty extent to
+* the shared `x` scale (`Infinite extent for field "start"`), and gating the
+* layer on the selection instead would re-embed the view every time the
+* reader picked a different excursion.
+*/
+function buildAnomalySpanRows(summary, selectedKey) {
+	if (!summary || summary.periods.length === 0) return [];
+	const episode = selectedKey == null ? void 0 : summary.episodes.find((entry) => entry.key === selectedKey);
+	if (!episode) return [{
+		start: summary.periods[0],
+		end: summary.periods[0],
+		on: false
+	}];
+	return [{
+		start: episode.start,
+		end: episode.end,
+		on: true
+	}];
+}
+/**
+* `breach` when the latest reading is outside its range, `watch` when the
+* window holds excursions but the latest reading is inside, `clear` when
+* nothing left the range. A window with nothing to judge against is `clear`
+* only in the sense that nothing was flagged, and the card says so in its
+* caption rather than in the verdict.
+*/
+function deriveAnomalyStanding(summary) {
+	if (!summary || summary.episodes.length === 0) return {
+		verdict: "clear",
+		polarity: "neutral"
+	};
+	if (summary.current) return {
+		verdict: "breach",
+		polarity: summary.current.polarity
+	};
+	return {
+		verdict: "watch",
+		polarity: "neutral"
+	};
+}
+/** The formatters every text surface shares — headline, rows, table, tooltip, descriptions. */
+function createAnomalyFormatters({ format, locale, timeZone, formatValue, xType, granularity, deltaMode = "absolute", percentagePoints = " pp", scoreFormat = "number:1" }) {
+	const formatX = (x) => {
+		if (xType === "temporal" && typeof x === "number") return formatDate(x, {
+			granularity,
+			locale,
+			timeZone
+		});
+		if (xType === "quantitative" && typeof x === "number") return formatNumber(x, "number", locale);
+		return String(x);
+	};
+	const value = (input) => isFinite(input) ? formatValue ? formatValue(input) : formatNumber(input, format, locale) : "—";
+	const deviationIn = (mode) => (deviation, bound) => {
+		if (!isFinite(deviation) || !isFinite(bound)) return null;
+		return formatDelta(bound + deviation, bound, {
+			mode,
+			format,
+			locale,
+			pointsSuffix: percentagePoints
+		});
+	};
+	return {
+		formatValue: value,
+		formatDeviation: (deviation, bound, mode = deltaMode) => deviationIn(mode)(deviation, bound)?.text ?? null,
+		formatDeviationSecondary: (deviation, bound, mode = deltaMode) => {
+			const primary = deviationIn(mode)(deviation, bound);
+			if (!primary) return null;
+			const other = deviationIn(primary.renderedMode === "percent" ? "absolute" : "percent")(deviation, bound);
+			return !other || other.renderedMode === primary.renderedMode ? null : other.text;
+		},
+		formatRange: (lo, hi) => {
+			const hasLo = isFinite(lo);
+			const hasHi = isFinite(hi);
+			if (hasLo && hasHi) return `${value(lo)} – ${value(hi)}`;
+			if (hasHi) return `≤ ${value(hi)}`;
+			if (hasLo) return `≥ ${value(lo)}`;
+			return "—";
+		},
+		formatScore: (score) => isFinite(score) ? formatNumber(score, scoreFormat, locale) : null,
+		formatX,
+		formatXRange: (start, end) => {
+			if (String(start) === String(end)) return formatX(start);
+			return xType === "temporal" && typeof start === "number" && typeof end === "number" ? formatDateRange(start, end, {
+				granularity,
+				locale,
+				timeZone
+			}) : `${formatX(start)} – ${formatX(end)}`;
+		}
+	};
+}
+const stripSign = (text) => text.replace(/^[+\-−]/, "");
+/** The label/value rows one excursion explains itself with — shared by the flag tooltip, the headline tooltip and the episode rows. */
+function buildAnomalyExplanation({ row, formatters, labels }) {
+	const bound = row.dir === "high" ? row.hi : row.dir === "low" ? row.lo : null;
+	const deviation = formatters.formatDeviation(row.d, bound);
+	return {
+		periodText: formatters.formatX(row.x),
+		valueText: formatters.formatValue(row.y),
+		expectedText: row.ex != null ? formatters.formatValue(row.ex) : null,
+		rangeText: formatters.formatRange(row.lo, row.hi),
+		deviationText: deviation ?? labels.inRange,
+		secondaryText: formatters.formatDeviationSecondary(row.d, bound),
+		scoreText: formatters.formatScore(row.sc),
+		direction: row.dir
+	};
+}
+/**
+* The generated insight — what the card shows beside the AI mark when the
+* consumer passes no `insight`. Values come back as `{ value }` segments so
+* the card can set them in bold; the words come from `labels.insight`.
+*/
+function buildAnomalyInsight({ name, summary, standing, formatters, labels }) {
+	const first = summary.periods[0];
+	const last = summary.periods[summary.periods.length - 1];
+	const peak = summary.worst?.peak ?? null;
+	return labels.insight({
+		name,
+		verdict: standing.verdict,
+		count: summary.episodes.length,
+		range: first != null && last != null ? formatters.formatXRange(first, last) : "—",
+		worstAt: peak ? formatters.formatX(peak.x) : null,
+		worstValue: peak ? formatters.formatValue(peak.y) : null,
+		worstDeviation: peak ? stripSign(formatters.formatDeviation(peak.deviation, peak.bound) ?? "") || null : null,
+		worstBound: peak ? formatters.formatValue(peak.bound) : null,
+		direction: peak ? peak.direction === "high" ? labels.high : labels.low : null,
+		ongoing: standing.verdict === "breach"
+	});
+}
+/**
+* The hover chip's contents for one period — pure, so the reading is
+* unit-tested rather than only reachable through a pointer event (Vega's own
+* hit-testing needs a visible document, which a hidden frame does not give).
+* Returns `null` for a period the card does not have.
+*/
+function buildAnomalyTooltip({ summary, x, formatters, labels }) {
+	if (x == null || !summary) return null;
+	const row = summary.rows.find((entry) => String(entry.x) === String(x));
+	if (!row) return null;
+	return {
+		explanation: buildAnomalyExplanation({
+			row,
+			formatters,
+			labels
+		}),
+		flagged: row.a,
+		directionText: row.dir === "high" ? labels.high : row.dir === "low" ? labels.low : null,
+		color: row.c,
+		shape: row.sh
+	};
+}
+/**
+* The card's text equivalent (Amy Cesal's alt-text formula: what it is, what
+* it shows, why it is here, when it was true) — the figure's accessible
+* description, and the summary a screen reader gets before the parts. Every
+* excursion is named with its span, so nothing lives only in the marks.
+*/
+function buildAnomalyDescription({ name, state, summary, standing, formatters, asOfText, labels }) {
+	if (state === "loading") return `${labels.loading(name)}.`;
+	if (state === "error") return `${name}: ${labels.error}.`;
+	if (state === "empty") return `${name}: ${labels.noData}.`;
+	if (state === "no-match") return `${name}: ${labels.noMatch}.`;
+	const sentences = [];
+	const first = summary?.periods[0];
+	const last = summary?.periods[summary.periods.length - 1];
+	const range = summary && first != null && last != null ? formatters.formatXRange(first, last) : "—";
+	sentences.push(`${name}: ${labels.verdicts[standing.verdict]}.`);
+	if (summary) {
+		sentences.push(labels.verdictSentence({
+			verdict: standing.verdict,
+			name,
+			count: summary.episodes.length,
+			range,
+			latest: formatters.formatValue(summary.latest?.y)
+		}));
+		if (summary.latest && (summary.latest.lo != null || summary.latest.hi != null)) sentences.push(`${labels.expectedRange(formatters.formatRange(summary.latest.lo, summary.latest.hi))}.`);
+		const peak = summary.worst?.peak;
+		if (peak) {
+			sentences.push(labels.worstSentence({
+				period: formatters.formatX(peak.x),
+				value: formatters.formatValue(peak.y),
+				deviation: stripSign(formatters.formatDeviation(peak.deviation, peak.bound) ?? ""),
+				bound: formatters.formatValue(peak.bound),
+				direction: peak.direction === "high" ? labels.high : labels.low
+			}));
+			const score = formatters.formatScore(peak.score);
+			if (score) sentences.push(labels.scoreSentence(score));
+		}
+		for (const episode of summary.episodes) {
+			const span = formatters.formatXRange(episode.start, episode.end);
+			const direction = episode.mixed ? labels.mixed : episode.direction === "high" ? labels.high : episode.direction === "low" ? labels.low : labels.flagKey;
+			sentences.push(`${span}: ${direction}, ${labels.periodCount(episode.count)}${episode.ongoing ? `, ${labels.ongoing}` : ""}.`);
+		}
+		if (!summary.hasBand) sentences.push(`${labels.unjudged}.`);
+	}
+	if (asOfText) sentences.push(`${labels.asOf} ${asOfText}.`);
+	return sentences.join(" ");
+}
+/** The plot's own `description` — the `aria-label` Vega stamps on the `graphics-document`. */
+function buildAnomalyChartDescription({ name, mark, summary, formatters, labels }) {
+	const first = summary.periods[0];
+	const last = summary.periods[summary.periods.length - 1];
+	return labels.chartDescription({
+		mark: labels.markNames[mark],
+		name,
+		periodCount: summary.periods.length,
+		range: first != null && last != null ? formatters.formatXRange(first, last) : "—",
+		min: formatters.formatValue(summary.min),
+		max: formatters.formatValue(summary.max),
+		flagged: summary.flagged,
+		band: summary.hasBand ? labels.bandKey : null
+	});
+}
+//#endregion
+export { DEFAULT_ANOMALY_LABELS, anomalyAxisGranularity, anomalyColorFor, anomalyPolarityFor, anomalyShapeFor, buildAnomalyChartDescription, buildAnomalyDescription, buildAnomalyExplanation, buildAnomalyInsight, buildAnomalyPeriodRows, buildAnomalySpanRows, buildAnomalyTooltip, createAnomalyFormatters, deriveAnomalyStanding, deriveAnomalyState, normalizeAnomalies, resolveAnomalyLabels };

package/dist/components/AnomalyCard/index.d.ts

@@ -0,0 +1,4 @@
+import { AnomalyBounds, AnomalyCardLabels, AnomalyCardSize, AnomalyCardState, AnomalyCardStatus, AnomalyDeltaMode, AnomalyDirection, AnomalyEpisode, AnomalyExplanation, AnomalyFlagShape, AnomalyGoodDirection, AnomalyHeadline, AnomalyInsightSegment, AnomalyMark, AnomalyPeak, AnomalyPeriodRow, AnomalyPoint, AnomalyPolarity, AnomalyRow, AnomalyScale, AnomalySpanRow, AnomalyStanding, AnomalySummary, AnomalyTextFormatters, AnomalyTooltipModel, AnomalyVerdict, AnomalyXType, BuildAnomalyDescriptionInput, DEFAULT_ANOMALY_LABELS, DeriveAnomalyStateInput, NormalizeAnomalyOptions, anomalyAxisGranularity, anomalyColorFor, anomalyPolarityFor, anomalyShapeFor, buildAnomalyChartDescription, buildAnomalyDescription, buildAnomalyExplanation, buildAnomalyInsight, buildAnomalyPeriodRows, buildAnomalySpanRows, buildAnomalyTooltip, createAnomalyFormatters, deriveAnomalyStanding, deriveAnomalyState, normalizeAnomalies, resolveAnomalyLabels } from "./AnomalyCard.model.js";
+import { AnomalyCard, AnomalyCardProps } from "./AnomalyCard.js";
+import { ANOMALY_HOVER_PARAM, ANOMALY_PERIODS_DATASET, ANOMALY_SPAN_DATASET, ANOMALY_TABLE_DATASET, ANOMALY_X_TICKS_PARAM, AnomalyPlotSpecOptions, buildAnomalyPlotSpec } from "./AnomalyCard.chart.js";
+export { ANOMALY_HOVER_PARAM, ANOMALY_PERIODS_DATASET, ANOMALY_SPAN_DATASET, ANOMALY_TABLE_DATASET, ANOMALY_X_TICKS_PARAM, type AnomalyBounds, AnomalyCard, type AnomalyCardLabels, type AnomalyCardProps, type AnomalyCardSize, type AnomalyCardState, type AnomalyCardStatus, type AnomalyDeltaMode, type AnomalyDirection, type AnomalyEpisode, type AnomalyExplanation, type AnomalyFlagShape, type AnomalyGoodDirection, type AnomalyHeadline, type AnomalyInsightSegment, type AnomalyMark, type AnomalyPeak, type AnomalyPeriodRow, type AnomalyPlotSpecOptions, type AnomalyPoint, type AnomalyPolarity, type AnomalyRow, type AnomalyScale, type AnomalySpanRow, type AnomalyStanding, type AnomalySummary, type AnomalyTextFormatters, type AnomalyTooltipModel, type AnomalyVerdict, type AnomalyXType, type BuildAnomalyDescriptionInput, DEFAULT_ANOMALY_LABELS, type DeriveAnomalyStateInput, type NormalizeAnomalyOptions, anomalyAxisGranularity, anomalyColorFor, anomalyPolarityFor, anomalyShapeFor, buildAnomalyChartDescription, buildAnomalyDescription, buildAnomalyExplanation, buildAnomalyInsight, buildAnomalyPeriodRows, buildAnomalyPlotSpec, buildAnomalySpanRows, buildAnomalyTooltip, createAnomalyFormatters, deriveAnomalyStanding, deriveAnomalyState, normalizeAnomalies, resolveAnomalyLabels };

package/dist/components/AnomalyCard/index.js

@@ -0,0 +1,4 @@
+import { ANOMALY_HOVER_PARAM, ANOMALY_PERIODS_DATASET, ANOMALY_SPAN_DATASET, ANOMALY_TABLE_DATASET, ANOMALY_X_TICKS_PARAM, buildAnomalyPlotSpec } from "./AnomalyCard.chart.js";
+import { DEFAULT_ANOMALY_LABELS, anomalyAxisGranularity, anomalyColorFor, anomalyPolarityFor, anomalyShapeFor, buildAnomalyChartDescription, buildAnomalyDescription, buildAnomalyExplanation, buildAnomalyInsight, buildAnomalyPeriodRows, buildAnomalySpanRows, buildAnomalyTooltip, createAnomalyFormatters, deriveAnomalyStanding, deriveAnomalyState, normalizeAnomalies, resolveAnomalyLabels } from "./AnomalyCard.model.js";
+import { AnomalyCard } from "./AnomalyCard.js";
+export { ANOMALY_HOVER_PARAM, ANOMALY_PERIODS_DATASET, ANOMALY_SPAN_DATASET, ANOMALY_TABLE_DATASET, ANOMALY_X_TICKS_PARAM, AnomalyCard, DEFAULT_ANOMALY_LABELS, anomalyAxisGranularity, anomalyColorFor, anomalyPolarityFor, anomalyShapeFor, buildAnomalyChartDescription, buildAnomalyDescription, buildAnomalyExplanation, buildAnomalyInsight, buildAnomalyPeriodRows, buildAnomalyPlotSpec, buildAnomalySpanRows, buildAnomalyTooltip, createAnomalyFormatters, deriveAnomalyStanding, deriveAnomalyState, normalizeAnomalies, resolveAnomalyLabels };

package/dist/components/ChartCard/ChartCard.chart.d.ts

@@ -0,0 +1,72 @@
+import { ChartTokens } from "../../lib/vega/tokens.js";
+import { ChartAggregate, ChartExtent, ChartFieldType, ChartType } from "./ChartCard.model.js";
+import { TopLevelSpec } from "vega-lite";
+//#region src/components/ChartCard/ChartCard.chart.d.ts
+/** Long-form rows, one per reading — `ChartRow` from the model. */
+declare const CHART_TABLE_DATASET = "table";
+/** Distinct axis categories `{ x }` — the radar's spokes and labels. */
+declare const CHART_AXES_DATASET = "axes";
+/** The hover selection: nearest point, so a pointer anywhere near a mark reads it. */
+declare const CHART_HOVER_PARAM = "hover";
+/** Responsive x tick values, recomputed by Vega when the domain or the width changes. */
+declare const CHART_X_TICKS_PARAM = "chart_x_ticks";
+/** Series labels, pushed as a signal so a violin's category axis needs no spec rebuild. */
+declare const CHART_SERIES_NAMES_PARAM = "chart_series_names";
+interface ChartSpecOptions {
+  type: ChartType;
+  /** Resolved field types for the two positions. */
+  xType: ChartFieldType;
+  yType: ChartFieldType;
+  /** Plot height in pixels, axes included. */
+  height: number;
+  /** Draw the axes. `false` strips the plot to its marks — the table twin still carries every value. */
+  axes: boolean;
+  /** Draw grid lines behind the marks. */
+  grid: boolean;
+  /** Draw axis titles at all. `false` (the card's default) suppresses even the derived ones a counting or distribution form would otherwise name itself. */
+  axisTitles: boolean;
+  /** Axis titles, when `axisTitles` is on. `null` falls back to the form's own derived name. */
+  xTitle?: string | null;
+  yTitle?: string | null;
+  /** Plain-text names used in tooltips. */
+  valueTitle: string;
+  seriesTitle: string;
+  sizeTitle?: string;
+  /** `arcNumber` grammar for the measure axis and the tooltip (`compact@en-US`). */
+  valueFormat: string;
+  /** `arcTime` grammar for temporal values in tooltips (`day@en-US@Asia/Bangkok`). */
+  timeFormat: string;
+  /** `arcTime` grammar for tick labels — the axis-length form (`day-short@en-US`). */
+  axisTimeFormat: string;
+  /** Aggregation applied to the measure. Only the forms that let Vega aggregate read it. */
+  aggregate?: ChartAggregate;
+  /** Bin count ceiling for the binning forms. */
+  maxBins: number;
+  /** Whisker or band extent for `boxplot`, `errorbar` and `errorband`. */
+  extent?: ChartExtent;
+  /** Wire the hover selection and the tooltip channel. */
+  tooltip: boolean;
+  /**
+   * The consumer named an `x` field. Structural, not data: a strip plot with
+   * no grouping field draws one lane rather than a category axis with a single
+   * undefined band on it.
+   */
+  hasX: boolean;
+  /** Hole size of a `donut`, as a fraction of the outer radius. */
+  innerRadius?: number;
+  /** Number of ticks on the measure axis — the caller scales it to the plot's height. */
+  yTicks: number;
+  locale?: string;
+  timeZone?: string;
+}
+/**
+ * Builds the plot for one form. Every spec is a single or layered view — never
+ * a facet, concat or repeat — so `autosize: "fit"` applies and the width and
+ * height can come from the View API rather than from a rebuild.
+ *
+ * The Vega legend is always `null`: the legend is real Arc controls, because
+ * Vega offers no keyboard navigation of its own marks.
+ */
+declare function buildChartSpec(options: ChartSpecOptions, tokens: ChartTokens): TopLevelSpec;
+//#endregion
+export { CHART_AXES_DATASET, CHART_HOVER_PARAM, CHART_SERIES_NAMES_PARAM, CHART_TABLE_DATASET, CHART_X_TICKS_PARAM, ChartSpecOptions, buildChartSpec };