@arcfusionz/arc-analytic-ui 0.0.0

package/dist/components/ProfileCard/ProfileCard.model.d.ts

@@ -0,0 +1,279 @@
+//#region src/components/ProfileCard/ProfileCard.model.d.ts
+/** What the consumer's transport reports. */
+type ProfileCardStatus = "loading" | "ready" | "error";
+/**
+ * What the card actually shows, derived from `status`, the data and
+ * `filtered`. Stamped on the root as `data-state`.
+ */
+type ProfileCardState = "loading" | "refreshing" | "ready" | "empty" | "no-match" | "error";
+type ProfileCardSize = "sm" | "md" | "lg";
+/**
+ * The form the plot draws.
+ *
+ * - `radar` (default): each item is a closed polygon over the metric axes.
+ *   The card exists for the question a radar answers — *what SHAPE is this
+ *   item across these measures* — and the literature is otherwise hostile to
+ *   the form, so the card enforces what makes it defensible: the axis order
+ *   is the consumer's `metrics` order and never sorted, the readings are
+ *   brought onto one radial scale, the polygon is a stroke with no area fill
+ *   unless `fill` is asked for, and the caps below are stamped and warned
+ *   about rather than silently exceeded.
+ * - `grouped`: one bar per item inside each metric's band. The accurate
+ *   form — length on a shared baseline — and the right answer whenever the
+ *   reader must compare VALUES rather than recognise a shape.
+ * - `parallel`: one path per item across parallel metric axes. Scales past
+ *   the radar's series cap and never asks the reader to judge an area; the
+ *   form the FT Visual Vocabulary names as radar's alternative.
+ *
+ * Stamped as `data-mark`.
+ */
+type ProfileMark = "radar" | "grouped" | "parallel";
+/**
+ * How readings on different measures are brought onto one axis.
+ *
+ * - `shared` (default): one scale across every metric, from zero to the
+ *   highest reading. Honest only when the metrics are COMMENSURABLE — five
+ *   0–100 scores, five 1–5 ratings, five rates. It is the only mode that
+ *   keeps "further out means more" true in the same units on every axis.
+ * - `max`: each metric is divided by its own ceiling — `ProfileMetric.max`
+ *   when declared, the highest observed reading otherwise. Use it when the
+ *   measures have different units but each has a meaningful maximum.
+ * - `minmax`: each metric is rescaled from its own observed min to its own
+ *   observed max. Readable, and the most misleading: the axes stop being
+ *   comparable, the lowest item always sits at the centre however good it
+ *   is, and adding or removing an item moves every other item's shape. Reach
+ *   for it last, and never when a reader might read the enclosed area as a
+ *   score.
+ *
+ * Stamped as `data-normalize`.
+ */
+type ProfileNormalize = "shared" | "max" | "minmax";
+/** A row's part in the comparison — the subject, or another item. */
+type ProfileRole = "focus" | "item";
+/**
+ * The caps that keep a radar readable, from the form's own literature
+ * (Highcharts' "when they fail"; data-to-viz). Past them the card stamps
+ * `data-over-cap` and the docs point at `parallel` or `grouped`; it never
+ * silently drops data.
+ */
+declare const RADAR_MAX_AXES = 8;
+declare const RADAR_MAX_SERIES = 3;
+/** Below three axes a polygon is a line or a point — there is no shape to read. */
+declare const RADAR_MIN_AXES = 3;
+/**
+ * One measure — an axis. The ORDER of the `metrics` array is the axis order
+ * and the card never sorts it, because a radar's shape changes when the axes
+ * are reordered: the enclosed area is a sum of products of ADJACENT readings,
+ * so the same numbers in a different order enclose a different area. A stable,
+ * semantic order is what makes the shape mean anything.
+ */
+interface ProfileMetric {
+  key?: string;
+  label: string;
+  /** The measure's ceiling for `normalize="max"`. Falls back to the highest observed reading. */
+  max?: number;
+  /** The measure's floor for `normalize="minmax"`. Falls back to the lowest observed reading. */
+  min?: number;
+  /** `arcNumber` grammar for this measure alone, when it does not share the card's `format` (`percent:1`, `currency:THB`). */
+  format?: string;
+}
+/** One thing being profiled — a plan, a team, a vendor, a segment. */
+interface ProfileItem {
+  key?: string;
+  label: string;
+  /** Reading per metric key. A metric this item has no reading for is a gap, not a zero — omit it or pass `null`. */
+  values: Readonly<Record<string, number | null>>;
+}
+/** A metric after normalisation, with the scaling the plot applies. */
+interface ProfileMetricInfo {
+  key: string;
+  label: string;
+  /** Position on the axis ring / the parallel axes — the consumer's order, always. */
+  index: number;
+  format?: string;
+  /** The low and high this metric's readings are mapped from; equal for a metric with one distinct reading. */
+  low: number;
+  high: number;
+  /** Highest reading across the items, or `null` when nobody reported this metric. */
+  best: number | null;
+  /** The item key holding `best`; `null` when nobody reported it or two items tie. */
+  leader: string | null;
+}
+/** An item after normalisation, with its readings aligned to `metrics`. */
+interface ProfileSeries {
+  key: string;
+  label: string;
+  /** Index in the consumer's order — the identity slot, never the rank, so a filter cannot repaint the survivors. */
+  index: number;
+  /** The paintable colour, baked in so the spec stays structural and hiding a series never repaints a survivor. */
+  color: string;
+  role: ProfileRole;
+  /** Readings aligned to `ProfileSummary.metrics`; `null` for a gap. */
+  values: (number | null)[];
+  /** The same readings mapped to 0–1 by `normalize`; `null` for a gap. */
+  normalized: (number | null)[];
+  /** Metrics with a finite reading. */
+  count: number;
+  /** Metrics where this item holds the highest reading. */
+  leads: number;
+}
+/** One long-form cell the plot reads: metric index, series key, and the colour the path paints with. */
+interface ProfileCell {
+  /** Metric index — the ANGLE of a radar vertex and the path order of a parallel line. Numeric, because `order` is path order. */
+  i: number;
+  /** Metric key. */
+  m: string;
+  /** Metric label, for the tooltip and the axis ring. */
+  ml: string;
+  /** Series key. */
+  s: string;
+  /** Series label. */
+  sl: string;
+  /** The reading as it arrived. */
+  raw: number | null;
+  /** The reading mapped to 0–1 by `normalize` — what the plot positions. */
+  n: number | null;
+  /** The paintable colour for this series. */
+  c: string;
+  /** This cell belongs to the focused series. */
+  f: boolean;
+}
+interface ProfileSummary {
+  metrics: ProfileMetricInfo[];
+  series: ProfileSeries[];
+  /** Long-form cells for the visible series, in series × metric order. Only cells with a finite reading. */
+  cells: ProfileCell[];
+  /** The subject, when one resolved. */
+  focus: ProfileSeries | null;
+  /** Readings with a finite value across every visible series. */
+  count: number;
+  /** More axes than a radar can carry, or more series than it can overlay. */
+  overCap: boolean;
+  /** Fewer than three axes — a radar has no shape to draw. */
+  underCap: boolean;
+}
+/** Every string the card renders or announces, so a product can localise it. Sentences are functions. */
+interface ProfileCardLabels {
+  noData: string;
+  noMatch: string;
+  clearFilters: string;
+  error: string;
+  retry: string;
+  stale: string;
+  asOf: string;
+  tableMetric: string;
+  /** Header of the popover table's leader column. */
+  tableLeader: string;
+  showTable: (name: string) => string;
+  hideTable: (name: string) => string;
+  about: (name: string) => string;
+  loading: (name: string) => string;
+  tableCaption: (name: string) => string;
+  /** Accessible name of the series legend — a group of toggles. */
+  seriesGroup: (name: string) => string;
+  /** Toggle a series in or out of the plot. */
+  hideSeries: (series: string) => string;
+  showSeries: (series: string) => string;
+  /** Read out after the focus item's label. */
+  highlighted: string;
+  /** How each mark names itself at the start of the plot's `aria-label`. */
+  markNames: Record<ProfileMark, string>;
+  /** Says how the readings were brought onto one axis, so a reader is never misled by a rescaled axis. */
+  normalizeNote: Record<ProfileNormalize, string>;
+  /** Sentence naming where the subject leads and where it trails. */
+  profileSentence: (input: {
+    name: string;
+    strongest: string;
+    strongestValue: string;
+    weakest: string;
+    weakestValue: string;
+  }) => string;
+  /** Lists the items on the plot. */
+  seriesSummary: (count: number, list: string) => string;
+  /** The plot's own `aria-label`. */
+  chartDescription: (input: {
+    mark: string;
+    name: string;
+    metrics: number;
+    series: number;
+    metricList: string;
+    focus: string | null;
+    normalize: string;
+  }) => string;
+  /** Accessible name of the AI mark beside the insight sentence. */
+  insightMark: string;
+}
+declare const DEFAULT_PROFILE_LABELS: ProfileCardLabels;
+declare function resolveProfileLabels(overrides?: Partial<ProfileCardLabels>): ProfileCardLabels;
+interface DeriveProfileStateInput {
+  status: ProfileCardStatus;
+  /** At least one item has a finite reading on at least one metric. */
+  hasValue: boolean;
+  /** Anything is on screen already, so a reload is a refresh rather than a first load. */
+  hasData: boolean;
+  filtered: boolean;
+}
+/**
+ * The state machine. Error wins; loading over existing data 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.
+ */
+declare function deriveProfileState({ status, hasValue, hasData, filtered }: DeriveProfileStateInput): ProfileCardState;
+interface NormalizeProfileOptions {
+  /** Key of the subject. `undefined` takes the first item; `null` designates none. */
+  focus?: string | null;
+  normalize?: ProfileNormalize;
+  /** Series keys the reader has hidden through the legend. */
+  hidden?: readonly string[];
+  /** Identity slots in fixed order — a colour per item, assigned by position and never by rank. */
+  palette: readonly string[];
+  /** The one hue a single-item profile draws with. */
+  emphasis: string;
+}
+/**
+ * Normalises `metrics` and `items` for the plot, the legend, the table and
+ * the text equivalents: keys default to labels (a repeat is suffixed), the
+ * axis order is the consumer's order and is never sorted, hidden series drop
+ * out of the plot but keep their colour slot, every reading is mapped to 0–1
+ * by `normalize`, and the leader of each metric is resolved (`null` on a tie,
+ * because "joint best" is not a leader). Returns `null` when there is nothing
+ * to speak of.
+ */
+declare function normalizeProfile(metrics: readonly ProfileMetric[] | undefined, items: readonly ProfileItem[] | undefined, { focus, normalize, hidden, palette, emphasis }: NormalizeProfileOptions): ProfileSummary | null;
+interface ProfileTextFormatters {
+  /** Formats a reading with its metric's own grammar when it has one. */
+  formatValue: (value: number | null | undefined, metric?: ProfileMetricInfo) => string;
+}
+declare function createProfileFormatters({ format, locale, formatValue }: {
+  format: string;
+  locale?: string;
+  formatValue?: (value: number, metric?: ProfileMetricInfo) => string;
+}): ProfileTextFormatters;
+/** Where the subject leads and where it trails — the takeaway a profile exists to deliver. */
+declare function deriveProfileHighlights(summary: ProfileSummary | null, formatters: ProfileTextFormatters): {
+  strongest: ProfileMetricInfo;
+  strongestValue: string;
+  weakest: ProfileMetricInfo;
+  weakestValue: string;
+} | null;
+interface BuildProfileDescriptionInput {
+  name: string;
+  state: ProfileCardState;
+  summary: ProfileSummary | null;
+  formatters: ProfileTextFormatters;
+  normalize: ProfileNormalize;
+  asOfText?: string | null;
+  labels: ProfileCardLabels;
+}
+/** The figure's generated description: what is plotted, where the subject leads and trails, every item, and the as-of. */
+declare function buildProfileDescription({ name, state, summary, formatters, normalize, asOfText, labels }: BuildProfileDescriptionInput): string;
+/** The plot's own `aria-label` — the form, what is on it, and how the axes were scaled. */
+declare function buildProfileChartDescription({ mark, name, summary, normalize, labels }: {
+  mark: ProfileMark;
+  name: string;
+  summary: ProfileSummary;
+  normalize: ProfileNormalize;
+  labels: ProfileCardLabels;
+}): string;
+//#endregion
+export { BuildProfileDescriptionInput, DEFAULT_PROFILE_LABELS, DeriveProfileStateInput, NormalizeProfileOptions, ProfileCardLabels, ProfileCardSize, ProfileCardState, ProfileCardStatus, ProfileCell, ProfileItem, ProfileMark, ProfileMetric, ProfileMetricInfo, ProfileNormalize, ProfileRole, ProfileSeries, ProfileSummary, ProfileTextFormatters, RADAR_MAX_AXES, RADAR_MAX_SERIES, RADAR_MIN_AXES, buildProfileChartDescription, buildProfileDescription, createProfileFormatters, deriveProfileHighlights, deriveProfileState, normalizeProfile, resolveProfileLabels };

package/dist/components/ProfileCard/ProfileCard.model.js

@@ -0,0 +1,244 @@
+import { formatNumber } from "../../lib/vega/formatters.js";
+//#region src/components/ProfileCard/ProfileCard.model.ts
+/**
+* The caps that keep a radar readable, from the form's own literature
+* (Highcharts' "when they fail"; data-to-viz). Past them the card stamps
+* `data-over-cap` and the docs point at `parallel` or `grouped`; it never
+* silently drops data.
+*/
+const RADAR_MAX_AXES = 8;
+const RADAR_MAX_SERIES = 3;
+/** Below three axes a polygon is a line or a point — there is no shape to read. */
+const RADAR_MIN_AXES = 3;
+const DEFAULT_PROFILE_LABELS = {
+	noData: "No data",
+	noMatch: "No matching data",
+	clearFilters: "Clear filters",
+	error: "Couldn't load this profile",
+	retry: "Try again",
+	stale: "Stale",
+	asOf: "As of",
+	tableMetric: "Metric",
+	tableLeader: "Leader",
+	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} profile`,
+	seriesGroup: (name) => `Choose which items ${name} plots`,
+	hideSeries: (series) => `Hide ${series}`,
+	showSeries: (series) => `Show ${series}`,
+	highlighted: "highlighted",
+	markNames: {
+		radar: "Radar",
+		grouped: "Grouped bar",
+		parallel: "Parallel coordinates"
+	},
+	normalizeNote: {
+		shared: "All metrics share one scale.",
+		max: "Each metric is scaled to its own maximum.",
+		minmax: "Each metric is scaled to its own range, so the axes are not comparable."
+	},
+	profileSentence: ({ name, strongest, strongestValue, weakest, weakestValue }) => `${name} is strongest on ${strongest} (${strongestValue}) and weakest on ${weakest} (${weakestValue}).`,
+	seriesSummary: (count, list) => `${count} ${count === 1 ? "item" : "items"}: ${list}.`,
+	chartDescription: ({ mark, name, metrics, series, metricList, focus, normalize }) => `${mark} profile of ${name}: ${series} ${series === 1 ? "item" : "items"} across ${metrics} ${metrics === 1 ? "metric" : "metrics"} — ${metricList}.` + (focus ? ` ${focus} highlighted.` : "") + ` ${normalize}`,
+	insightMark: "Insight"
+};
+function resolveProfileLabels(overrides) {
+	return overrides ? {
+		...DEFAULT_PROFILE_LABELS,
+		...overrides
+	} : DEFAULT_PROFILE_LABELS;
+}
+/**
+* The state machine. Error wins; loading over existing data 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 deriveProfileState({ 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);
+/** Suffix a repeated key so two entries never share an axis or a colour slot. */
+function uniqueKeys(entries, read) {
+	const seen = /* @__PURE__ */ new Map();
+	return entries.map((entry) => {
+		const base = read(entry);
+		const repeats = seen.get(base) ?? 0;
+		seen.set(base, repeats + 1);
+		return repeats === 0 ? base : `${base}·${repeats + 1}`;
+	});
+}
+/**
+* Normalises `metrics` and `items` for the plot, the legend, the table and
+* the text equivalents: keys default to labels (a repeat is suffixed), the
+* axis order is the consumer's order and is never sorted, hidden series drop
+* out of the plot but keep their colour slot, every reading is mapped to 0–1
+* by `normalize`, and the leader of each metric is resolved (`null` on a tie,
+* because "joint best" is not a leader). Returns `null` when there is nothing
+* to speak of.
+*/
+function normalizeProfile(metrics, items, { focus, normalize = "shared", hidden, palette, emphasis }) {
+	if (!metrics || !items) return null;
+	const metricKeys = uniqueKeys(metrics, (metric) => metric.key ?? metric.label);
+	const itemKeys = uniqueKeys(items, (item) => item.key ?? item.label);
+	const hiddenSet = new Set(hidden ?? []);
+	const visible = items.map((_, index) => !hiddenSet.has(itemKeys[index]));
+	const readingsFor = (metricKey) => items.map((item, index) => visible[index] ? item.values[metricKey] : void 0).filter((value) => isFinite(value));
+	const metricInfos = metrics.map((metric, index) => {
+		const key = metricKeys[index];
+		const readings = readingsFor(key);
+		const observedHigh = readings.length > 0 ? Math.max(...readings) : 0;
+		const observedLow = readings.length > 0 ? Math.min(...readings) : 0;
+		const best = readings.length > 0 ? observedHigh : null;
+		const holders = items.map((item, i) => visible[i] && best != null && item.values[key] === best ? itemKeys[i] : null).filter((k) => k != null);
+		return {
+			key,
+			label: metric.label,
+			index,
+			format: metric.format,
+			low: normalize === "minmax" ? metric.min ?? observedLow : 0,
+			high: normalize === "shared" ? 0 : Math.max(metric.max ?? observedHigh, normalize === "minmax" ? metric.min ?? observedLow : 0),
+			best,
+			leader: holders.length === 1 ? holders[0] : null
+		};
+	});
+	if (normalize === "shared") {
+		const all = metricInfos.flatMap((metric) => readingsFor(metric.key));
+		const declared = metrics.map((metric) => metric.max).filter(isFinite);
+		const high = Math.max(0, ...all, ...declared);
+		for (const metric of metricInfos) {
+			metric.low = 0;
+			metric.high = high;
+		}
+	}
+	const scaleOne = (metric, value) => {
+		const span = metric.high - metric.low;
+		if (span <= 0) return metric.high > 0 || value > 0 ? 1 : 0;
+		return Math.min(1, Math.max(0, (value - metric.low) / span));
+	};
+	const series = [];
+	const cells = [];
+	const focusKey = focus === null ? null : focus === void 0 ? itemKeys[0] ?? null : itemKeys.includes(focus) ? focus : null;
+	const single = items.length - hiddenSet.size <= 1;
+	items.forEach((item, index) => {
+		const key = itemKeys[index];
+		if (hiddenSet.has(key)) return;
+		const color = single ? emphasis : palette[index % Math.max(1, palette.length)] ?? emphasis;
+		const isFocus = key === focusKey;
+		const values = [];
+		const normalized = [];
+		let count = 0;
+		metricInfos.forEach((metric) => {
+			const raw = item.values[metric.key];
+			const value = isFinite(raw) ? raw : null;
+			values.push(value);
+			const n = value == null ? null : scaleOne(metric, value);
+			normalized.push(n);
+			if (value == null) return;
+			count += 1;
+			cells.push({
+				i: metric.index,
+				m: metric.key,
+				ml: metric.label,
+				s: key,
+				sl: item.label,
+				raw: value,
+				n,
+				c: color,
+				f: isFocus
+			});
+		});
+		series.push({
+			key,
+			label: item.label,
+			index,
+			color,
+			role: isFocus ? "focus" : "item",
+			values,
+			normalized,
+			count,
+			leads: metricInfos.filter((metric) => metric.leader === key).length
+		});
+	});
+	return {
+		metrics: metricInfos,
+		series,
+		cells,
+		focus: series.find((entry) => entry.role === "focus") ?? null,
+		count: cells.length,
+		overCap: metricInfos.length > 8 || series.length > 3,
+		underCap: metricInfos.length < 3
+	};
+}
+function createProfileFormatters({ format, locale, formatValue }) {
+	return { formatValue: (value, metric) => isFinite(value) ? formatValue ? formatValue(value, metric) : formatNumber(value, metric?.format ?? format, locale) : "—" };
+}
+/** Where the subject leads and where it trails — the takeaway a profile exists to deliver. */
+function deriveProfileHighlights(summary, formatters) {
+	const focus = summary?.focus;
+	if (!summary || !focus || focus.count < 2) return null;
+	let strongest = null;
+	let weakest = null;
+	let high = -Infinity;
+	let low = Infinity;
+	summary.metrics.forEach((metric, index) => {
+		const n = focus.normalized[index];
+		if (n == null) return;
+		if (n > high) {
+			high = n;
+			strongest = metric;
+		}
+		if (n < low) {
+			low = n;
+			weakest = metric;
+		}
+	});
+	if (!strongest || !weakest || strongest === weakest) return null;
+	const s = strongest;
+	const w = weakest;
+	return {
+		strongest: s,
+		strongestValue: formatters.formatValue(focus.values[s.index], s),
+		weakest: w,
+		weakestValue: formatters.formatValue(focus.values[w.index], w)
+	};
+}
+/** The figure's generated description: what is plotted, where the subject leads and trails, every item, and the as-of. */
+function buildProfileDescription({ name, state, summary, formatters, normalize, 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}`;
+	if (!summary) return name;
+	const parts = [`${name}.`];
+	const highlights = deriveProfileHighlights(summary, formatters);
+	if (highlights && summary.focus) parts.push(labels.profileSentence({
+		name: summary.focus.label,
+		strongest: highlights.strongest.label,
+		strongestValue: highlights.strongestValue,
+		weakest: highlights.weakest.label,
+		weakestValue: highlights.weakestValue
+	}));
+	parts.push(labels.seriesSummary(summary.series.length, summary.series.map((entry) => entry.label).join(", ")));
+	parts.push(labels.normalizeNote[normalize]);
+	if (asOfText) parts.push(`${labels.asOf} ${asOfText}.`);
+	return parts.join(" ");
+}
+/** The plot's own `aria-label` — the form, what is on it, and how the axes were scaled. */
+function buildProfileChartDescription({ mark, name, summary, normalize, labels }) {
+	return labels.chartDescription({
+		mark: labels.markNames[mark],
+		name,
+		metrics: summary.metrics.length,
+		series: summary.series.length,
+		metricList: summary.metrics.map((metric) => metric.label).join(", ") || "—",
+		focus: summary.focus?.label ?? null,
+		normalize: labels.normalizeNote[normalize]
+	});
+}
+//#endregion
+export { DEFAULT_PROFILE_LABELS, RADAR_MAX_AXES, RADAR_MAX_SERIES, RADAR_MIN_AXES, buildProfileChartDescription, buildProfileDescription, createProfileFormatters, deriveProfileHighlights, deriveProfileState, normalizeProfile, resolveProfileLabels };

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

@@ -0,0 +1,4 @@
+import { BuildProfileDescriptionInput, DEFAULT_PROFILE_LABELS, DeriveProfileStateInput, NormalizeProfileOptions, ProfileCardLabels, ProfileCardSize, ProfileCardState, ProfileCardStatus, ProfileCell, ProfileItem, ProfileMark, ProfileMetric, ProfileMetricInfo, ProfileNormalize, ProfileRole, ProfileSeries, ProfileSummary, ProfileTextFormatters, RADAR_MAX_AXES, RADAR_MAX_SERIES, RADAR_MIN_AXES, buildProfileChartDescription, buildProfileDescription, createProfileFormatters, deriveProfileHighlights, deriveProfileState, normalizeProfile, resolveProfileLabels } from "./ProfileCard.model.js";
+import { ProfileCard, ProfileCardProps } from "./ProfileCard.js";
+import { PROFILE_AXES_DATASET, PROFILE_CELLS_DATASET, PROFILE_HOVER_PARAM, PROFILE_RINGS_DATASET, ProfilePlotSpecOptions, buildProfilePlotSpec, profileNeedsRings } from "./ProfileCard.chart.js";
+export { type BuildProfileDescriptionInput, DEFAULT_PROFILE_LABELS, type DeriveProfileStateInput, type NormalizeProfileOptions, PROFILE_AXES_DATASET, PROFILE_CELLS_DATASET, PROFILE_HOVER_PARAM, PROFILE_RINGS_DATASET, ProfileCard, type ProfileCardLabels, type ProfileCardProps, type ProfileCardSize, type ProfileCardState, type ProfileCardStatus, type ProfileCell, type ProfileItem, type ProfileMark, type ProfileMetric, type ProfileMetricInfo, type ProfileNormalize, type ProfilePlotSpecOptions, type ProfileRole, type ProfileSeries, type ProfileSummary, type ProfileTextFormatters, RADAR_MAX_AXES, RADAR_MAX_SERIES, RADAR_MIN_AXES, buildProfileChartDescription, buildProfileDescription, buildProfilePlotSpec, createProfileFormatters, deriveProfileHighlights, deriveProfileState, normalizeProfile, profileNeedsRings, resolveProfileLabels };

package/dist/components/ProfileCard/index.js

@@ -0,0 +1,4 @@
+import { PROFILE_AXES_DATASET, PROFILE_CELLS_DATASET, PROFILE_HOVER_PARAM, PROFILE_RINGS_DATASET, buildProfilePlotSpec, profileNeedsRings } from "./ProfileCard.chart.js";
+import { DEFAULT_PROFILE_LABELS, RADAR_MAX_AXES, RADAR_MAX_SERIES, RADAR_MIN_AXES, buildProfileChartDescription, buildProfileDescription, createProfileFormatters, deriveProfileHighlights, deriveProfileState, normalizeProfile, resolveProfileLabels } from "./ProfileCard.model.js";
+import { ProfileCard } from "./ProfileCard.js";
+export { DEFAULT_PROFILE_LABELS, PROFILE_AXES_DATASET, PROFILE_CELLS_DATASET, PROFILE_HOVER_PARAM, PROFILE_RINGS_DATASET, ProfileCard, RADAR_MAX_AXES, RADAR_MAX_SERIES, RADAR_MIN_AXES, buildProfileChartDescription, buildProfileDescription, buildProfilePlotSpec, createProfileFormatters, deriveProfileHighlights, deriveProfileState, normalizeProfile, profileNeedsRings, resolveProfileLabels };

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

@@ -0,0 +1,73 @@
+import { ChartTokens } from "../../lib/vega/tokens.js";
+import { TopLevelSpec } from "vega-lite";
+//#region src/components/ProgressCard/ProgressCard.chart.d.ts
+/** The completion series: `{ t, y }` per reading, `y` null for a missed one. */
+declare const PROGRESS_COMPLETED_DATASET = "table";
+/** The scope at each reading: `{ t, y }`, drawn `step-after` — scope moves at moments, not gradually. */
+declare const PROGRESS_SCOPE_DATASET = "scope";
+/** The remaining band: `{ t, y, y2 }` per reading — completion up to the scope above it. */
+declare const PROGRESS_GAP_DATASET = "gap";
+/** The required pace: two rows `{ t, y }` from the run's start to the deadline. */
+declare const PROGRESS_IDEAL_DATASET = "ideal";
+/** The projection: two rows `{ t, y, tone }` from the last reading to where the rate crosses the scope. */
+declare const PROGRESS_PROJECTION_DATASET = "projection";
+/** Zero or one row `{ t }` — the deadline's vertical rule. */
+declare const PROGRESS_DUE_DATASET = "due";
+/** One row `{ t, y }` — the last reading, dotted. */
+declare const PROGRESS_LATEST_DATASET = "latest";
+/** Zero or one row `{ t, y, tone }` — where the projection meets the scope. */
+declare const PROGRESS_FINISH_DATASET = "finish";
+/** Responsive x tick values, recomputed by Vega when the domain or width changes. */
+declare const PROGRESS_X_TICKS_PARAM = "progress_x_ticks";
+/** The nearest-reading hover selection. */
+declare const PROGRESS_HOVER_PARAM = "hover";
+interface ProgressBurnUpSpecOptions {
+  /** Plot height in pixels, including the x-axis labels. */
+  height: number;
+  /** Draw the x and y axes. `false` for a sparkline-scale tile — the table still carries the figures. */
+  axes: boolean;
+  /** Draw the required-pace line (the `ideal` dataset carries its two ends). */
+  ideal: boolean;
+  /**
+   * Draw the projection to the crossing (the `projection` and `finish`
+   * datasets carry it). The card passes `false` when the run has no
+   * projection to draw: with the x domain unioned from the layers, an empty
+   * dataset would put an infinite extent into the shared scale and Vega would
+   * warn — so a series the run does not have is not declared. A run that
+   * stalls or recovers therefore re-embeds once, which is a change of
+   * encoding and not of data.
+   */
+  projection: boolean;
+  /** Draw the deadline's vertical rule. `false` when there is no due date, for the same reason as `projection`. */
+  due: boolean;
+  /** The word written at the deadline's rule — a direct label, so the rule needs no legend key of its own. */
+  dueLabel: string;
+  /** Shade the gap between completion and scope as the work remaining. */
+  gap: boolean;
+  /** Wire the nearest-reading hover selection and the tooltip channel. */
+  tooltip: boolean;
+  /** Localised tooltip titles. */
+  dateTitle: string;
+  completedTitle: string;
+  scopeTitle: string;
+  /** `arcNumber` grammar for counts (`integer@en-US`). */
+  valueFormat: string;
+  /** `arcTime` grammar for the tooltip's dates (`day@en-US@Asia/Bangkok`). */
+  timeFormat: string;
+  /** `arcTime` grammar for x-axis tick labels — the axis-length form (`day-short@…`). */
+  axisTimeFormat: string;
+  locale?: string;
+}
+/**
+ * Builds the burn-up: the work remaining as a quiet band between completion
+ * and scope, the scope as a stepped context line, the required pace as a
+ * dashed reference from the run's start to the deadline, cumulative completion
+ * as an area and a 2px line from zero (a count, so zero is meaningful and the
+ * ink stays proportional), the deadline as a vertical rule, the projection as
+ * a dashed continuation in its own polarity hue ending in a hollow dot at the
+ * crossing, and a nearest-reading hover carrying the tooltip. Gaps stay gaps:
+ * Vega-Lite's default `invalid` handling breaks the path at a null reading.
+ */
+declare function buildProgressBurnUpSpec(options: ProgressBurnUpSpecOptions, tokens: ChartTokens): TopLevelSpec;
+//#endregion
+export { PROGRESS_COMPLETED_DATASET, PROGRESS_DUE_DATASET, PROGRESS_FINISH_DATASET, PROGRESS_GAP_DATASET, PROGRESS_HOVER_PARAM, PROGRESS_IDEAL_DATASET, PROGRESS_LATEST_DATASET, PROGRESS_PROJECTION_DATASET, PROGRESS_SCOPE_DATASET, PROGRESS_X_TICKS_PARAM, ProgressBurnUpSpecOptions, buildProgressBurnUpSpec };