@arcfusionz/arc-analytic-ui 0.0.0

package/dist/components/ForecastCard/ForecastCard.model.js

@@ -0,0 +1,554 @@
+import { formatDate, formatDateRange, formatDelta, formatNumber } from "../../lib/vega/formatters.js";
+//#region src/components/ForecastCard/ForecastCard.model.ts
+const DEFAULT_FORECAST_LABELS = {
+	increase: "Up",
+	decrease: "Down",
+	unchanged: "No change",
+	percentagePoints: " pp",
+	noData: "No data",
+	noMatch: "No matching data",
+	clearFilters: "Clear filters",
+	error: "Couldn't load this forecast",
+	retry: "Try again",
+	insufficient: "Not enough data for a forecast",
+	noForecast: "No forecast for this period — measured readings only",
+	stale: "Stale",
+	asOf: "As of",
+	actual: "Actual",
+	forecast: "Forecast",
+	interval: "Interval",
+	target: "Target",
+	boundary: "Forecast starts",
+	tablePeriod: "Period",
+	tableValue: "Value",
+	tableKind: "Kind",
+	tableInterval: "Interval",
+	headlineSentence: ({ name, value, caption }) => `${name}: ${value} (${caption}).`,
+	landingCaption: (period) => `Projected for ${period}`,
+	latestCaption: (period) => `Actual, ${period}`,
+	intervalCaption: (range, level) => level ? `${range} (${level})` : range,
+	intervalKey: (level) => level ? `${level} interval` : "Interval",
+	levelText: (level) => `${Math.round(level * 100)}%`,
+	outlook: {
+		likely: "Likely to hit target",
+		uncertain: "Too close to call",
+		unlikely: "Unlikely to hit target"
+	},
+	outlookExplanation: ({ outlook, target, landing, range, horizon }) => {
+		const head = `Projected ${landing} by ${horizon} against a ${target} target`;
+		if (outlook === "uncertain") return `${head}. The target falls inside the ${range} interval, so the forecast does not decide it.`;
+		if (outlook === "likely") return range ? `${head}. The whole ${range} interval reaches it.` : `${head}.`;
+		return range ? `${head}. No part of the ${range} interval reaches it.` : `${head}.`;
+	},
+	crossesAt: (period) => `Reaches the target in ${period}`,
+	noCrossing: "Does not reach the target inside the horizon",
+	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 the ${name} forecast`,
+	changeGroup: (name) => `${name} projected change`,
+	deltaExplanation: ({ fromLabel, fromText, toLabel, toText, changeText, secondaryText, renderedMode, direction, rangeText }) => {
+		const rows = [
+			[fromLabel, fromText],
+			[toLabel, toText],
+			[direction === "up" ? "Increase" : direction === "down" ? "Decrease" : "No change", changeText]
+		];
+		if (secondaryText) rows.push([renderedMode === "percent" ? "Change" : "Change %", secondaryText]);
+		if (rangeText) rows.push(["Interval", rangeText]);
+		return rows;
+	},
+	projectionSentence: ({ word, primary, secondary, from, to, horizon }) => primary ? `Projected ${word.toLowerCase()} ${primary}${secondary ? ` (${secondary})` : ""} from ${from} to ${to} by ${horizon}.` : `Projected to hold at ${from} through ${horizon}.`,
+	intervalSentence: ({ low, high, level, horizon }) => `Between ${low} and ${high} by ${horizon}${level ? `, ${level} interval` : ""}.`,
+	historySentence: ({ count, range, latest }) => `Based on ${count} measured periods, ${range}, latest ${latest}.`,
+	partialIntervalSentence: ({ with: withInterval, total }) => `${withInterval} of ${total} projected periods carry an interval.`,
+	markNames: {
+		line: "Line",
+		area: "Area"
+	},
+	chartDescription: ({ mark, name, actualCount, forecastCount, range, min, max, boundary, interval, target }) => `${mark} chart of ${name}: ${actualCount} measured periods followed by ${forecastCount} projected, ${range}, ranging ${min} to ${max}.` + (boundary ? ` The forecast starts after ${boundary}.` : "") + (interval ? ` ${interval}.` : "") + (target ? ` Reference line at the ${target} target.` : ""),
+	insightMark: "Insight",
+	insight: ({ name, direction, from, to, change, horizon, low, high, level, outlook, target, crossesAt }) => {
+		const segments = direction === "flat" ? [
+			`${name} is projected to hold at `,
+			{ value: to },
+			` through ${horizon}.`
+		] : [
+			`${name} is projected to ${direction === "up" ? "reach" : "fall to"} `,
+			{ value: to },
+			` by ${horizon}, ${direction === "up" ? "up" : "down"} `,
+			{ value: change },
+			` from `,
+			{ value: from },
+			"."
+		];
+		if (low && high) segments.push(` The ${level ? `${level} ` : ""}interval runs `, { value: low }, " to ", { value: high }, ".");
+		if (target && outlook !== "none") {
+			if (outlook === "uncertain") segments.push(` The ${target} target sits inside that range, so it is too close to call.`);
+			else if (crossesAt) segments.push(` It reaches the ${target} target in ${crossesAt}.`);
+			else if (outlook === "likely") segments.push(` That clears the ${target} target.`);
+			else segments.push(` That misses the ${target} target.`);
+		}
+		return segments;
+	}
+};
+function resolveForecastLabels(overrides) {
+	return overrides ? {
+		...DEFAULT_FORECAST_LABELS,
+		...overrides
+	} : DEFAULT_FORECAST_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 deriveForecastState({ 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 — the same reason each card owns its own state machine.
+*/
+function forecastAxisGranularity(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);
+}
+/**
+* Lays the measured and the projected readings onto one period domain.
+*
+* The two halves stay distinguishable at every level: each period carries its
+* `kind`, the projected half is the only one with interval bounds, and the plot
+* rows repeat the last measured reading as the projected path's ANCHOR so the
+* solid and dashed paths meet — the interval opens from that anchor at zero
+* width, which is what makes a fan read as growing uncertainty rather than as a
+* band that appears from nowhere. `readings` carries the anchor once, so the
+* table and the description never double-count it.
+*
+* A projected period that repeats a measured one is dropped: a forecast cannot
+* overwrite a reading. Returns `null` when there is nothing at all to show.
+*/
+function normalizeForecast(actual, forecast, { granularity, name, color }) {
+	const actualPoints = actual ?? [];
+	const forecastPoints = forecast ?? [];
+	if (actualPoints.length === 0 && forecastPoints.length === 0) return null;
+	const xType = inferXType([...actualPoints, ...forecastPoints]);
+	const measured = /* @__PURE__ */ new Map();
+	for (const point of actualPoints) {
+		const x = normalizeX(point.x, xType);
+		if (x == null) continue;
+		measured.set(String(x), {
+			x,
+			y: isFinite(point.y) ? point.y : null,
+			lower: null,
+			upper: null,
+			kind: "actual"
+		});
+	}
+	const projected = /* @__PURE__ */ new Map();
+	for (const point of forecastPoints) {
+		const x = normalizeX(point.x, xType);
+		if (x == null) continue;
+		if (measured.has(String(x))) continue;
+		const lower = isFinite(point.lower) ? point.lower : null;
+		const upper = isFinite(point.upper) ? point.upper : null;
+		const hasInterval = lower != null && upper != null;
+		projected.set(String(x), {
+			x,
+			y: isFinite(point.y) ? point.y : null,
+			lower: hasInterval ? Math.min(lower, upper) : null,
+			upper: hasInterval ? Math.max(lower, upper) : null,
+			kind: "forecast"
+		});
+	}
+	const sortReadings = (entries) => xType === "ordinal" ? entries : [...entries].sort((a, b) => a.x - b.x);
+	const measuredReadings = sortReadings([...measured.values()]);
+	const projectedReadings = sortReadings([...projected.values()]);
+	const readings = [...measuredReadings, ...projectedReadings];
+	const periods = readings.map((reading) => reading.x);
+	const finiteMeasured = measuredReadings.filter((reading) => reading.y != null);
+	const finiteProjected = projectedReadings.filter((reading) => reading.y != null);
+	const lastMeasured = finiteMeasured[finiteMeasured.length - 1] ?? null;
+	const lastProjected = finiteProjected[finiteProjected.length - 1] ?? null;
+	const rows = readings.map((reading) => ({
+		x: reading.x,
+		y: reading.y,
+		lo: reading.lower,
+		hi: reading.upper,
+		k: reading.kind,
+		c: color,
+		n: name
+	}));
+	const anchor = lastMeasured && finiteProjected.length > 0 ? lastMeasured : null;
+	if (anchor) {
+		const at = rows.findIndex((row) => String(row.x) === String(anchor.x) && row.k === "actual");
+		const anchorRow = {
+			x: anchor.x,
+			y: anchor.y,
+			lo: anchor.y,
+			hi: anchor.y,
+			k: "forecast",
+			c: color,
+			n: name
+		};
+		rows.splice(at + 1, 0, anchorRow);
+	}
+	const interval = [];
+	if (anchor) interval.push({
+		x: anchor.x,
+		lo: anchor.y,
+		hi: anchor.y
+	});
+	for (const reading of projectedReadings) {
+		if (reading.lower == null || reading.upper == null) continue;
+		interval.push({
+			x: reading.x,
+			lo: reading.lower,
+			hi: reading.upper
+		});
+	}
+	const extent = [];
+	for (const reading of readings) {
+		if (reading.y != null) extent.push(reading.y);
+		if (reading.lower != null) extent.push(reading.lower);
+		if (reading.upper != null) extent.push(reading.upper);
+	}
+	const moment = (reading) => reading && reading.y != null ? {
+		x: reading.x,
+		y: reading.y,
+		lower: reading.lower,
+		upper: reading.upper
+	} : null;
+	return {
+		xType,
+		granularity: granularity ?? (xType === "temporal" ? inferGranularity(periods) : "day"),
+		periods,
+		readings,
+		rows,
+		interval,
+		boundary: lastMeasured?.x ?? null,
+		latest: moment(lastMeasured),
+		landing: moment(lastProjected),
+		actualCount: finiteMeasured.length,
+		forecastCount: finiteProjected.length,
+		intervalCount: projectedReadings.filter((reading) => reading.lower != null && reading.upper != null).length,
+		min: extent.length > 0 ? Math.min(...extent) : null,
+		max: extent.length > 0 ? Math.max(...extent) : null,
+		hasNegative: extent.some((value) => value < 0)
+	};
+}
+/** The periods the crosshair reads — one row each, so it lands on the period rather than on a mark. */
+function buildForecastPeriodRows(summary) {
+	return summary.periods.map((x) => ({ x }));
+}
+/**
+* The projected stretch as one washed rect, from the last measured period to
+* the horizon — the ground under everything the card did not measure. Empty
+* when nothing is projected, so a card with history alone draws no wash.
+*/
+function buildForecastRegionRows(summary) {
+	const projected = summary.readings.filter((reading) => reading.kind === "forecast");
+	if (projected.length === 0) return [];
+	return [{
+		start: summary.boundary ?? projected[0].x,
+		end: projected[projected.length - 1].x
+	}];
+}
+/** Zero or one row — the rule at the last measured period. */
+function buildForecastBoundaryRows(summary) {
+	const hasProjection = summary.readings.some((reading) => reading.kind === "forecast");
+	return summary.boundary != null && hasProjection ? [{ x: summary.boundary }] : [];
+}
+/** Zero or one row — where the landing label sits. */
+function buildForecastLandingRows(summary, text) {
+	if (!summary.landing) return [];
+	return [{
+		x: summary.landing.x,
+		y: summary.landing.y,
+		n: text,
+		c: summary.rows[0]?.c ?? ""
+	}];
+}
+/** Whether a value reaches the target, given which direction is good. `null` when reaching is undefined. */
+function reachesTarget(value, target, goodDirection) {
+	if (goodDirection === "none") return null;
+	return goodDirection === "down" ? value <= target : value >= target;
+}
+/**
+* The verdict the interval supports, and nothing more: `likely` when the WHOLE
+* interval reaches the target, `unlikely` when none of it does, `uncertain`
+* when the target falls inside it — the honest answer a point estimate cannot
+* give. Without an interval the point estimate decides between `likely` and
+* `unlikely` (the card says so in its explanation); without a target, a landing
+* or a direction, there is no verdict at all.
+*/
+function deriveForecastOutlook({ landing, target, goodDirection }) {
+	if (!landing || target == null || !isFinite(target)) return "none";
+	const point = reachesTarget(landing.y, target, goodDirection);
+	if (point == null) return "none";
+	if (landing.lower == null || landing.upper == null) return point ? "likely" : "unlikely";
+	const lowReaches = reachesTarget(landing.lower, target, goodDirection);
+	if (lowReaches === reachesTarget(landing.upper, target, goodDirection)) return lowReaches ? "likely" : "unlikely";
+	return "uncertain";
+}
+/**
+* The first projected period whose reading reaches the target — the "when" a
+* forecast is really asked for. `null` when the last measured reading already
+* reaches it (there is nothing to wait for), when the path never gets there, or
+* when reaching is undefined.
+*/
+function deriveForecastCrossing(summary, target, goodDirection) {
+	if (!summary || target == null || !isFinite(target) || goodDirection === "none") return null;
+	if (summary.latest && reachesTarget(summary.latest.y, target, goodDirection)) return null;
+	for (const reading of summary.readings) {
+		if (reading.kind !== "forecast" || reading.y == null) continue;
+		if (reachesTarget(reading.y, target, goodDirection)) return {
+			x: reading.x,
+			y: reading.y,
+			lower: reading.lower,
+			upper: reading.upper
+		};
+	}
+	return null;
+}
+/** A change between two readings, with polarity resolved through `goodDirection`. */
+function deriveForecastDelta(value, previous, { deltaMode, goodDirection, format, locale, percentagePoints }) {
+	if (!isFinite(value) || !isFinite(previous)) return null;
+	const delta = formatDelta(value, previous, {
+		mode: deltaMode,
+		format,
+		locale,
+		pointsSuffix: percentagePoints
+	});
+	const other = formatDelta(value, previous, {
+		mode: delta.renderedMode === "percent" ? "absolute" : "percent",
+		format,
+		locale,
+		pointsSuffix: percentagePoints
+	});
+	let polarity = "neutral";
+	if (delta.direction !== "flat" && goodDirection !== "none") polarity = delta.direction === "up" === (goodDirection === "up") ? "positive" : "negative";
+	return {
+		direction: delta.direction,
+		polarity,
+		text: delta.text,
+		renderedMode: delta.renderedMode,
+		secondaryText: other.renderedMode === delta.renderedMode ? null : other.text
+	};
+}
+/**
+* The move from the last measured reading to the landing. `null` unless the
+* card has both — a forecast with no history to leave from, or a history with
+* nothing projected, has no projected change to state.
+*/
+function deriveForecastProjection(summary, { formatters, ...deltaOptions }) {
+	if (!summary?.latest || !summary.landing) return null;
+	const delta = deriveForecastDelta(summary.landing.y, summary.latest.y, deltaOptions);
+	if (!delta) return null;
+	return {
+		from: summary.latest,
+		to: summary.landing,
+		rangeText: formatters.formatXRange(summary.latest.x, summary.landing.x),
+		delta
+	};
+}
+/** The formatters every text surface shares — headline, badge, table, tooltip, descriptions. */
+function createForecastFormatters({ format, locale, timeZone, formatValue, xType, granularity }) {
+	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) : "—";
+	return {
+		formatValue: value,
+		formatX,
+		formatXRange: (start, end) => xType === "temporal" && typeof start === "number" && typeof end === "number" ? formatDateRange(start, end, {
+			granularity,
+			locale,
+			timeZone
+		}) : `${formatX(start)} – ${formatX(end)}`,
+		formatInterval: (lower, upper) => isFinite(lower) && isFinite(upper) ? `${value(lower)} – ${value(upper)}` : null
+	};
+}
+const stripSign = (text) => text.replace(/^[+\-−]/, "");
+/**
+* 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 buildForecastTooltip({ summary, x, target, formatters, labels }) {
+	if (x == null || !summary) return null;
+	const reading = summary.readings.find((entry) => String(entry.x) === String(x));
+	if (!reading) return null;
+	return {
+		periodText: formatters.formatX(reading.x),
+		kind: reading.kind,
+		kindText: reading.kind === "actual" ? labels.actual : labels.forecast,
+		valueText: formatters.formatValue(reading.y),
+		intervalText: formatters.formatInterval(reading.lower, reading.upper),
+		targetText: target != null ? formatters.formatValue(target) : null
+	};
+}
+/**
+* The generated insight — what the card shows beside the AI mark when the
+* consumer passes no `insight`: where the measure lands, the move that takes it
+* there, the interval around it, and what that means for the target. Values
+* come back as `{ value }` segments so the card can set them in bold.
+*/
+function buildForecastInsight({ name, summary, projection, outlook, crossing, target, level, formatters, labels }) {
+	const landing = summary.landing;
+	if (!landing || !projection) return null;
+	return labels.insight({
+		name,
+		direction: projection.delta.direction,
+		from: formatters.formatValue(projection.from.y),
+		to: formatters.formatValue(landing.y),
+		change: stripSign(projection.delta.text),
+		horizon: formatters.formatX(landing.x),
+		low: landing.lower != null ? formatters.formatValue(landing.lower) : null,
+		high: landing.upper != null ? formatters.formatValue(landing.upper) : null,
+		level: level != null ? labels.levelText(level) : null,
+		outlook,
+		target: target != null ? formatters.formatValue(target) : null,
+		crossesAt: crossing ? formatters.formatX(crossing.x) : null
+	});
+}
+/**
+* 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. The
+* landing, its interval, the measured span behind it and the verdict are all
+* here, so nothing the plot says lives only in the marks.
+*/
+function buildForecastDescription({ name, state, headline, summary, projection, outlook, crossing, target, level, 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 landing = summary?.landing ?? null;
+	const latest = summary?.latest ?? null;
+	const levelText = level != null ? labels.levelText(level) : null;
+	if (headline === "landing" && landing) sentences.push(labels.headlineSentence({
+		name,
+		value: formatters.formatValue(landing.y),
+		caption: labels.landingCaption(formatters.formatX(landing.x))
+	}));
+	else if (headline === "latest" && latest) sentences.push(labels.headlineSentence({
+		name,
+		value: formatters.formatValue(latest.y),
+		caption: labels.latestCaption(formatters.formatX(latest.x))
+	}));
+	else if (headline === "change" && projection) sentences.push(`${name}: ${projection.delta.text} projected over ${projection.rangeText}.`);
+	else sentences.push(`${name}.`);
+	if (projection) {
+		const flat = projection.delta.direction === "flat";
+		const word = projection.delta.direction === "up" ? labels.increase : projection.delta.direction === "down" ? labels.decrease : labels.unchanged;
+		sentences.push(labels.projectionSentence({
+			word,
+			primary: flat ? "" : stripSign(projection.delta.text),
+			secondary: flat || !projection.delta.secondaryText ? null : stripSign(projection.delta.secondaryText),
+			from: formatters.formatValue(projection.from.y),
+			to: formatters.formatValue(projection.to.y),
+			horizon: formatters.formatX(projection.to.x)
+		}));
+	}
+	if (landing?.lower != null && landing.upper != null) sentences.push(labels.intervalSentence({
+		low: formatters.formatValue(landing.lower),
+		high: formatters.formatValue(landing.upper),
+		level: levelText,
+		horizon: formatters.formatX(landing.x)
+	}));
+	if (summary && summary.actualCount > 0) {
+		const measured = summary.readings.filter((reading) => reading.kind === "actual");
+		const first = measured[0];
+		const last = measured[measured.length - 1];
+		sentences.push(labels.historySentence({
+			count: summary.actualCount,
+			range: first && last ? formatters.formatXRange(first.x, last.x) : "—",
+			latest: formatters.formatValue(latest?.y)
+		}));
+	}
+	if (summary && summary.forecastCount > 0 && summary.intervalCount > 0 && summary.intervalCount < summary.forecastCount) sentences.push(labels.partialIntervalSentence({
+		with: summary.intervalCount,
+		total: summary.forecastCount
+	}));
+	if (target != null) {
+		sentences.push(`${labels.target} ${formatters.formatValue(target)}.`);
+		if (outlook !== "none") sentences.push(`${labels.outlook[outlook]}.` + (crossing ? ` ${labels.crossesAt(formatters.formatX(crossing.x))}.` : outlook === "unlikely" ? ` ${labels.noCrossing}.` : ""));
+	}
+	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 buildForecastChartDescription({ name, mark, summary, level, formatters, targetText, labels }) {
+	const first = summary.periods[0];
+	const last = summary.periods[summary.periods.length - 1];
+	const landing = summary.landing;
+	const intervalText = summary.intervalCount > 0 && landing?.lower != null && landing.upper != null ? labels.intervalSentence({
+		low: formatters.formatValue(landing.lower),
+		high: formatters.formatValue(landing.upper),
+		level: level != null ? labels.levelText(level) : null,
+		horizon: formatters.formatX(landing.x)
+	}).replace(/\.$/, "") : null;
+	return labels.chartDescription({
+		mark: labels.markNames[mark],
+		name,
+		actualCount: summary.actualCount,
+		forecastCount: summary.forecastCount,
+		range: first != null && last != null ? formatters.formatXRange(first, last) : "—",
+		min: formatters.formatValue(summary.min),
+		max: formatters.formatValue(summary.max),
+		boundary: summary.boundary != null && summary.forecastCount > 0 ? formatters.formatX(summary.boundary) : null,
+		interval: intervalText,
+		target: targetText ?? null
+	});
+}
+//#endregion
+export { DEFAULT_FORECAST_LABELS, buildForecastBoundaryRows, buildForecastChartDescription, buildForecastDescription, buildForecastInsight, buildForecastLandingRows, buildForecastPeriodRows, buildForecastRegionRows, buildForecastTooltip, createForecastFormatters, deriveForecastCrossing, deriveForecastDelta, deriveForecastOutlook, deriveForecastProjection, deriveForecastState, forecastAxisGranularity, normalizeForecast, reachesTarget, resolveForecastLabels };

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

@@ -0,0 +1,4 @@
+import { BuildForecastDescriptionInput, BuildForecastInsightInput, DEFAULT_FORECAST_LABELS, DeriveForecastDeltaOptions, DeriveForecastOutlookInput, DeriveForecastProjectionOptions, DeriveForecastStateInput, ForecastCardLabels, ForecastCardSize, ForecastCardState, ForecastCardStatus, ForecastDelta, ForecastDeltaExplanation, ForecastDeltaMode, ForecastGoodDirection, ForecastHeadline, ForecastInsightSegment, ForecastKind, ForecastMark, ForecastMoment, ForecastOutlook, ForecastPeriodRow, ForecastPoint, ForecastPolarity, ForecastProjection, ForecastReading, ForecastRegionRow, ForecastRow, ForecastScale, ForecastSummary, ForecastTextFormatters, ForecastTooltipModel, ForecastXType, NormalizeForecastOptions, buildForecastBoundaryRows, buildForecastChartDescription, buildForecastDescription, buildForecastInsight, buildForecastLandingRows, buildForecastPeriodRows, buildForecastRegionRows, buildForecastTooltip, createForecastFormatters, deriveForecastCrossing, deriveForecastDelta, deriveForecastOutlook, deriveForecastProjection, deriveForecastState, forecastAxisGranularity, normalizeForecast, reachesTarget, resolveForecastLabels } from "./ForecastCard.model.js";
+import { ForecastCard, ForecastCardProps } from "./ForecastCard.js";
+import { FORECAST_BOUNDARY_DATASET, FORECAST_HOVER_PARAM, FORECAST_INTERVAL_DATASET, FORECAST_LANDING_DATASET, FORECAST_PERIODS_DATASET, FORECAST_REFERENCE_DATASET, FORECAST_REGION_DATASET, FORECAST_REGION_END_PARAM, FORECAST_REGION_START_PARAM, FORECAST_TABLE_DATASET, FORECAST_X_TICKS_PARAM, ForecastPlotSpecOptions, buildForecastPlotSpec } from "./ForecastCard.chart.js";
+export { type BuildForecastDescriptionInput, type BuildForecastInsightInput, DEFAULT_FORECAST_LABELS, type DeriveForecastDeltaOptions, type DeriveForecastOutlookInput, type DeriveForecastProjectionOptions, type DeriveForecastStateInput, FORECAST_BOUNDARY_DATASET, FORECAST_HOVER_PARAM, FORECAST_INTERVAL_DATASET, FORECAST_LANDING_DATASET, FORECAST_PERIODS_DATASET, FORECAST_REFERENCE_DATASET, FORECAST_REGION_DATASET, FORECAST_REGION_END_PARAM, FORECAST_REGION_START_PARAM, FORECAST_TABLE_DATASET, FORECAST_X_TICKS_PARAM, ForecastCard, type ForecastCardLabels, type ForecastCardProps, type ForecastCardSize, type ForecastCardState, type ForecastCardStatus, type ForecastDelta, type ForecastDeltaExplanation, type ForecastDeltaMode, type ForecastGoodDirection, type ForecastHeadline, type ForecastInsightSegment, type ForecastKind, type ForecastMark, type ForecastMoment, type ForecastOutlook, type ForecastPeriodRow, type ForecastPlotSpecOptions, type ForecastPoint, type ForecastPolarity, type ForecastProjection, type ForecastReading, type ForecastRegionRow, type ForecastRow, type ForecastScale, type ForecastSummary, type ForecastTextFormatters, type ForecastTooltipModel, type ForecastXType, type NormalizeForecastOptions, buildForecastBoundaryRows, buildForecastChartDescription, buildForecastDescription, buildForecastInsight, buildForecastLandingRows, buildForecastPeriodRows, buildForecastPlotSpec, buildForecastRegionRows, buildForecastTooltip, createForecastFormatters, deriveForecastCrossing, deriveForecastDelta, deriveForecastOutlook, deriveForecastProjection, deriveForecastState, forecastAxisGranularity, normalizeForecast, reachesTarget, resolveForecastLabels };

package/dist/components/ForecastCard/index.js

@@ -0,0 +1,4 @@
+import { FORECAST_BOUNDARY_DATASET, FORECAST_HOVER_PARAM, FORECAST_INTERVAL_DATASET, FORECAST_LANDING_DATASET, FORECAST_PERIODS_DATASET, FORECAST_REFERENCE_DATASET, FORECAST_REGION_DATASET, FORECAST_REGION_END_PARAM, FORECAST_REGION_START_PARAM, FORECAST_TABLE_DATASET, FORECAST_X_TICKS_PARAM, buildForecastPlotSpec } from "./ForecastCard.chart.js";
+import { DEFAULT_FORECAST_LABELS, buildForecastBoundaryRows, buildForecastChartDescription, buildForecastDescription, buildForecastInsight, buildForecastLandingRows, buildForecastPeriodRows, buildForecastRegionRows, buildForecastTooltip, createForecastFormatters, deriveForecastCrossing, deriveForecastDelta, deriveForecastOutlook, deriveForecastProjection, deriveForecastState, forecastAxisGranularity, normalizeForecast, reachesTarget, resolveForecastLabels } from "./ForecastCard.model.js";
+import { ForecastCard } from "./ForecastCard.js";
+export { DEFAULT_FORECAST_LABELS, FORECAST_BOUNDARY_DATASET, FORECAST_HOVER_PARAM, FORECAST_INTERVAL_DATASET, FORECAST_LANDING_DATASET, FORECAST_PERIODS_DATASET, FORECAST_REFERENCE_DATASET, FORECAST_REGION_DATASET, FORECAST_REGION_END_PARAM, FORECAST_REGION_START_PARAM, FORECAST_TABLE_DATASET, FORECAST_X_TICKS_PARAM, ForecastCard, buildForecastBoundaryRows, buildForecastChartDescription, buildForecastDescription, buildForecastInsight, buildForecastLandingRows, buildForecastPeriodRows, buildForecastPlotSpec, buildForecastRegionRows, buildForecastTooltip, createForecastFormatters, deriveForecastCrossing, deriveForecastDelta, deriveForecastOutlook, deriveForecastProjection, deriveForecastState, forecastAxisGranularity, normalizeForecast, reachesTarget, resolveForecastLabels };