@arcfusionz/arc-analytic-ui 0.0.0

package/dist/components/TableCard/TableCard.model.js

@@ -0,0 +1,475 @@
+import { formatDate, formatDelta, formatNumber } from "../../lib/vega/formatters.js";
+//#region src/components/TableCard/TableCard.model.ts
+const DEFAULT_TABLE_LABELS = {
+	sortBy: (header) => `Sort by ${header}`,
+	sortDescending: (header) => `Sort by ${header}, descending`,
+	sortAscending: (header) => `Sort by ${header}, ascending`,
+	sortedBy: (header, direction) => `Sorted by ${header}, ${direction === "asc" ? "ascending" : "descending"}`,
+	ascending: "ascending",
+	descending: "descending",
+	rank: (place) => `Rank ${place}`,
+	total: "Total",
+	showingTopOf: (shown, total) => `Showing top ${shown} of ${total}`,
+	showAll: "Show all",
+	insightAboveMedian: (leader, header, value, share, rows) => `${leader} leads ${header} at ${value} — ${share} above the median of these ${rows} rows.`,
+	insightBelowMedian: (leader, header, value, share, rows) => `${leader} leads ${header} at ${value} — ${share} below the median of these ${rows} rows.`,
+	insightAtMedian: (leader, header, value, rows) => `${leader} leads ${header} at ${value}, at the median of these ${rows} rows.`,
+	trendSentence: (first, last, change) => `${first} to ${last}, ${change}`,
+	trendInsufficient: "Not enough readings for a trend",
+	shareOf: (share) => `${share} of the column`,
+	increase: "increase",
+	decrease: "decrease",
+	unchanged: "unchanged",
+	percentagePoints: " pp",
+	noData: "No data",
+	noMatch: "No rows match the filters",
+	clearFilters: "Clear filters",
+	error: "Could not load this table",
+	retry: "Retry",
+	insufficient: "Only one row — not enough to rank",
+	stale: "Stale",
+	asOf: "As of",
+	about: (name) => `About ${name}`,
+	openRow: (label) => `Open ${label}`,
+	caption: (name) => name
+};
+/** Merges a partial override over the defaults. */
+function resolveTableLabels(labels) {
+	return labels ? {
+		...DEFAULT_TABLE_LABELS,
+		...labels
+	} : DEFAULT_TABLE_LABELS;
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+/** Coerces a field value to a number, treating anything unparseable as missing rather than as zero (rule 14). */
+function toNumber(value) {
+	if (isFiniteNumber(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+}
+function toText(value) {
+	if (value == null) return null;
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return Number.isFinite(value) ? String(value) : null;
+	if (typeof value === "boolean") return String(value);
+	return null;
+}
+/**
+* Normalises a trend field: a bare array of readings becomes indexed points,
+* `{ x, y }` records pass through, and anything else becomes an empty series.
+* Nulls survive as nulls — a gap is not a zero.
+*/
+function normalizeTrendPoints(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((entry, index) => {
+		if (entry != null && typeof entry === "object" && !Array.isArray(entry)) {
+			const record = entry;
+			return {
+				x: record.x ?? index,
+				y: toNumber(record.y)
+			};
+		}
+		return {
+			x: index,
+			y: toNumber(entry)
+		};
+	});
+}
+/** What a trend cell's series says: its ends, its extremes, its gaps, and the change across it. */
+function summarizeTrend(points) {
+	const values = points.map((point) => point.y).filter(isFiniteNumber);
+	const withValue = points.filter((point) => isFiniteNumber(point.y));
+	const first = withValue.length > 0 ? withValue[0].y : null;
+	const last = withValue.length > 0 ? withValue[withValue.length - 1].y : null;
+	const change = first != null && last != null && withValue.length > 1 ? last - first : null;
+	return {
+		first,
+		last,
+		min: values.length > 0 ? Math.min(...values) : null,
+		max: values.length > 0 ? Math.max(...values) : null,
+		count: values.length,
+		gaps: points.length - values.length,
+		change,
+		direction: change == null ? null : change > 0 ? "up" : change < 0 ? "down" : "flat"
+	};
+}
+/** How a change reads once `goodDirection` is applied: up is not always good. */
+function deltaPolarity(direction, goodDirection) {
+	if (direction === "flat" || goodDirection === "none") return "neutral";
+	return goodDirection === "up" === (direction === "up") ? "positive" : "negative";
+}
+const DEFAULT_ALIGN = {
+	text: "start",
+	number: "end",
+	bar: "end",
+	delta: "end",
+	trend: "start",
+	badge: "start"
+};
+/** A column's identity: its own `id`, else the field it reads. */
+function columnId(column) {
+	return column.id ?? column.field;
+}
+function columnFormat(column) {
+	if (column.kind === "bar" || column.kind === "trend") return column.format ?? "compact";
+	if (column.kind === "number" || column.kind === "delta") return column.format ?? "number";
+	return "number";
+}
+function buildCell(column, row, context, domainMax) {
+	const { locale, labels } = context;
+	const raw = row[column.field];
+	const base = {
+		id: columnId(column),
+		field: column.field,
+		kind: column.kind,
+		value: null,
+		share: null,
+		delta: null,
+		points: null,
+		trend: null,
+		tone: null,
+		caption: null,
+		detail: null
+	};
+	switch (column.kind) {
+		case "text": {
+			const text = toText(raw);
+			return {
+				...base,
+				text: text ?? "—",
+				sortValue: text,
+				caption: column.captionField ? toText(row[column.captionField]) : null
+			};
+		}
+		case "badge": {
+			const text = toText(raw);
+			return {
+				...base,
+				text: text ?? "—",
+				sortValue: text,
+				tone: (text != null ? column.tones?.[text] : null) ?? "neutral"
+			};
+		}
+		case "number": {
+			const value = toNumber(raw);
+			return {
+				...base,
+				value,
+				text: formatNumber(value, columnFormat(column), locale),
+				sortValue: value
+			};
+		}
+		case "bar": {
+			const value = toNumber(raw);
+			const format = columnFormat(column);
+			const share = value != null && value >= 0 && domainMax != null && domainMax > 0 ? Math.min(1, value / domainMax) : null;
+			return {
+				...base,
+				value,
+				text: formatNumber(value, format, locale),
+				sortValue: value,
+				share,
+				detail: share != null ? labels.shareOf(formatNumber(share, "percent:0", locale)) : null
+			};
+		}
+		case "delta": {
+			const format = columnFormat(column);
+			const mode = column.mode ?? "percent";
+			const goodDirection = column.goodDirection ?? "up";
+			if (column.previousField) {
+				const current = toNumber(raw);
+				const previous = toNumber(row[column.previousField]);
+				if (current == null || previous == null) return {
+					...base,
+					text: "—",
+					sortValue: null
+				};
+				const formatted = formatDelta(current, previous, {
+					mode,
+					format,
+					locale,
+					pointsSuffix: labels.percentagePoints
+				});
+				const polarity = deltaPolarity(formatted.direction, goodDirection);
+				const sortValue = formatted.renderedMode === "percent" ? formatted.percent ?? formatted.absolute : formatted.absolute;
+				return {
+					...base,
+					value: formatted.absolute,
+					text: formatted.text,
+					sortValue,
+					delta: {
+						direction: formatted.direction,
+						polarity,
+						text: formatted.text,
+						renderedMode: formatted.renderedMode,
+						value: sortValue
+					}
+				};
+			}
+			const value = toNumber(raw);
+			if (value == null) return {
+				...base,
+				text: "—",
+				sortValue: null
+			};
+			const direction = value > 0 ? "up" : value < 0 ? "down" : "flat";
+			const text = mode === "percent" ? formatNumber(value, "percent:1", locale, { signDisplay: "exceptZero" }) : formatNumber(value, format, locale, { signDisplay: "exceptZero" });
+			return {
+				...base,
+				value,
+				text,
+				sortValue: value,
+				delta: {
+					direction,
+					polarity: deltaPolarity(direction, goodDirection),
+					text,
+					renderedMode: mode,
+					value
+				}
+			};
+		}
+		case "trend": {
+			const points = normalizeTrendPoints(raw);
+			const trend = summarizeTrend(points);
+			const format = columnFormat(column);
+			const changeText = trend.change != null && trend.first != null ? formatDelta(trend.last, trend.first, {
+				mode: "percent",
+				format,
+				locale,
+				pointsSuffix: labels.percentagePoints
+			}).text : null;
+			const detail = trend.count > 1 && changeText != null ? labels.trendSentence(formatNumber(trend.first, format, locale), formatNumber(trend.last, format, locale), changeText) : labels.trendInsufficient;
+			return {
+				...base,
+				text: formatNumber(trend.last, format, locale),
+				sortValue: trend.change,
+				value: trend.last,
+				points,
+				trend,
+				detail
+			};
+		}
+	}
+}
+function aggregate(kind, values) {
+	if (values.length === 0) return null;
+	switch (kind) {
+		case "sum": return values.reduce((total, value) => total + value, 0);
+		case "mean": return values.reduce((total, value) => total + value, 0) / values.length;
+		case "max": return Math.max(...values);
+		case "min": return Math.min(...values);
+	}
+}
+/**
+* Turns the consumer's columns and records into the model the card renders:
+* every column resolved (alignment, sortability, its own length scale and its
+* footer aggregate), every cell formatted once and given the single number it
+* sorts by, the rows ordered, capped and ranked.
+*
+* Missing readings sort last in both directions — "no reading" is not the
+* smallest reading — and a capped tail is reported in `truncated` rather than
+* folded into an "Other" row: a table's columns are not all additive, so
+* summing them would invent numbers.
+*/
+function normalizeTable(input) {
+	const { columns, rows, rowKey, sort, maxRows, totalRows, showRank, locale, timeZone } = input;
+	const context = {
+		locale,
+		timeZone,
+		labels: input.labels ?? DEFAULT_TABLE_LABELS
+	};
+	const labelField = rowKey ?? columns.find((column) => column.kind === "text")?.field;
+	const domains = /* @__PURE__ */ new Map();
+	for (const column of columns) {
+		if (column.kind !== "bar") continue;
+		const values = rows.map((row) => toNumber(row[column.field])).filter(isFiniteNumber);
+		if (typeof column.domain === "number") domains.set(columnId(column), column.domain);
+		else if (column.domain === "total") {
+			const sum = values.reduce((total, value) => total + value, 0);
+			domains.set(columnId(column), sum > 0 ? sum : null);
+		} else domains.set(columnId(column), values.length > 0 ? Math.max(...values) : null);
+	}
+	const built = rows.map((row, index) => {
+		const cells = columns.map((column) => buildCell(column, row, context, domains.get(columnId(column)) ?? null));
+		const byField = {};
+		for (const cell of cells) byField[cell.id] = cell;
+		const identity = labelField != null ? toText(row[labelField]) : null;
+		const firstText = cells.find((cell) => cell.kind === "text" && cell.sortValue != null);
+		return {
+			key: identity ?? `row-${index}`,
+			label: (typeof firstText?.sortValue === "string" ? firstText.sortValue : identity) ?? `row-${index}`,
+			rank: null,
+			cells,
+			byField
+		};
+	});
+	const sortColumnDefinition = sort ? columns.find((column) => columnId(column) === sort.field) : void 0;
+	const sortColumnResolved = sortColumnDefinition && (sortColumnDefinition.sortable ?? true) ? sortColumnDefinition : void 0;
+	let ordered = built;
+	if (sort && sortColumnResolved) {
+		const factor = sort.direction === "asc" ? 1 : -1;
+		const collator = new Intl.Collator(locale, {
+			numeric: true,
+			sensitivity: "base"
+		});
+		ordered = built.map((row, index) => ({
+			row,
+			index
+		})).sort((left, right) => {
+			const a = left.row.byField[sort.field]?.sortValue ?? null;
+			const b = right.row.byField[sort.field]?.sortValue ?? null;
+			if (a == null && b == null) return left.index - right.index;
+			if (a == null) return 1;
+			if (b == null) return -1;
+			const compared = typeof a === "string" || typeof b === "string" ? collator.compare(String(a), String(b)) : a - b;
+			return compared !== 0 ? compared * factor : left.index - right.index;
+		}).map((entry) => entry.row);
+	}
+	const shown = maxRows != null && maxRows > 0 ? ordered.slice(0, maxRows) : ordered;
+	const total = totalRows ?? rows.length;
+	let ranked = shown;
+	if (showRank && sort && sortColumnResolved) {
+		const out = [];
+		let previousValue;
+		let previousRank = 0;
+		shown.forEach((row, index) => {
+			const value = row.byField[sort.field]?.sortValue ?? null;
+			const rank = index > 0 && value === previousValue ? previousRank : index + 1;
+			previousValue = value;
+			previousRank = rank;
+			out.push({
+				...row,
+				rank
+			});
+		});
+		ranked = out;
+	}
+	const columnModels = columns.map((column) => {
+		const id = columnId(column);
+		const cells = ranked.map((row) => row.byField[id]).filter((cell) => cell != null);
+		const values = cells.map((cell) => cell.value).filter(isFiniteNumber);
+		const totalValue = column.total ? aggregate(column.total, values) : null;
+		const format = columnFormat(column);
+		return {
+			column,
+			id,
+			field: column.field,
+			kind: column.kind,
+			header: column.header,
+			align: column.align ?? DEFAULT_ALIGN[column.kind],
+			sortable: column.sortable ?? true,
+			domainMax: domains.get(id) ?? null,
+			totalValue,
+			totalText: column.total ? formatNumber(totalValue, format, locale) : null,
+			hasMissing: cells.some((cell) => cell.sortValue == null)
+		};
+	});
+	return {
+		rows: ranked,
+		columns: columnModels,
+		count: ranked.length,
+		total,
+		truncated: Math.max(0, total - ranked.length),
+		sortColumn: sortColumnResolved ? columnModels.find((model) => model.id === sort?.field) ?? null : null,
+		leader: ranked[0] ?? null,
+		trailer: ranked.length > 1 ? ranked[ranked.length - 1] ?? null : null,
+		hasTrend: columns.some((column) => column.kind === "trend"),
+		insufficient: ranked.length === 1 && total === 1
+	};
+}
+/**
+* The state machine: `loading` with nothing to show, `refreshing` when a
+* reload arrives over a rendered table (the previous render stays under the
+* veil rather than collapsing to a skeleton), `error`, then `empty` or
+* `no-match` — different messages, because "there is no data" and "your
+* filters exclude all of it" call for different actions (Cloudscape's
+* `empty` / `noMatch` split).
+*/
+function deriveTableState({ status, rowCount, filtered }) {
+	if (status === "error") return "error";
+	if (status === "loading") return rowCount > 0 ? "refreshing" : "loading";
+	if (rowCount === 0) return filtered ? "no-match" : "empty";
+	return "ready";
+}
+/**
+* The card's accessible description (Amy Cesal's alt-text formula: what form,
+* what data, why it is here, as of when) — what the table holds, how it is
+* ordered, which measures it carries, and whether it is capped.
+*/
+function buildTableDescription({ name, summary, labels, sort, updatedAt, updatedAtFormat = "day", locale, timeZone }) {
+	const parts = [];
+	const measures = summary.columns.filter((column) => column.kind !== "text").map((column) => column.header);
+	const rowNoun = summary.count === 1 ? "row" : "rows";
+	parts.push(`${name}: a table of ${summary.count} ${rowNoun}`);
+	if (sort && summary.sortColumn) parts.push(`ordered by ${summary.sortColumn.header} ${sort.direction === "asc" ? labels.ascending : labels.descending}`);
+	if (measures.length > 0) parts.push(`with ${measures.join(", ")}`);
+	const sentences = [`${parts.join(", ")}.`];
+	if (summary.truncated > 0) sentences.push(`${labels.showingTopOf(summary.count, summary.total)}.`);
+	if (summary.leader != null && summary.sortColumn != null) {
+		const cell = summary.leader.byField[summary.sortColumn.id];
+		if (cell != null) sentences.push(`${summary.leader.label} leads at ${cell.text}.`);
+	}
+	if (summary.columns.some((column) => column.hasMissing)) sentences.push("Cells with no reading are marked with a dash.");
+	if (updatedAt != null) sentences.push(`${labels.asOf} ${formatDate(updatedAt, {
+		granularity: updatedAtFormat,
+		locale,
+		timeZone
+	})}.`);
+	return sentences.join(" ");
+}
+/**
+* The takeaway, as one visible sentence (Chartability's "title, summary,
+* context"): how far the leader stands above the middle of the sorted column,
+* because "who is on top" is already visible and "by how much" is the part a
+* reader has to compute. `null` when the table is unsorted or too short for
+* the comparison to mean anything.
+*/
+function buildTableInsight({ summary, labels, locale }) {
+	const column = summary.sortColumn;
+	const leader = summary.leader;
+	if (column == null || leader == null || summary.count < 3) return null;
+	if (column.kind === "text" || column.kind === "badge") return null;
+	const values = summary.rows.map((row) => row.byField[column.id]?.sortValue).filter((value) => typeof value === "number" && Number.isFinite(value));
+	if (values.length < 3) return null;
+	const leaderValue = leader.byField[column.id]?.sortValue;
+	if (typeof leaderValue !== "number" || !Number.isFinite(leaderValue)) return null;
+	const sorted = [...values].sort((a, b) => a - b);
+	const middle = sorted.length % 2 === 1 ? sorted[(sorted.length - 1) / 2] : (sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2;
+	if (middle === 0) return null;
+	const ratio = (leaderValue - middle) / Math.abs(middle);
+	const share = formatNumber(Math.abs(ratio), "percent:0", locale);
+	const leaderText = leader.byField[column.id]?.text ?? "—";
+	if (ratio === 0) return labels.insightAtMedian(leader.label, column.header, leaderText, summary.count);
+	return (ratio > 0 ? labels.insightAboveMedian : labels.insightBelowMedian)(leader.label, column.header, leaderText, share, summary.count);
+}
+/** The `arcTime` grammar string for a trend cell's tooltip x, built from the card's locale and zone. */
+function trendTimeFormat(granularity, locale, timeZone) {
+	return [
+		granularity ?? "day",
+		locale ?? "",
+		timeZone ?? ""
+	].join("@").replace(/@+$/, "");
+}
+/** The `arcNumber` grammar string for a column, with the card's locale appended. */
+function columnValueFormat(column, locale) {
+	const format = columnFormat(column);
+	return locale ? `${format}@${locale}` : format;
+}
+/** Flips a column's order: a fresh click on a numeric column leads with the largest, on a name with A. */
+function nextSort(current, column) {
+	if (current?.field === column.id) return {
+		field: column.id,
+		direction: current.direction === "asc" ? "desc" : "asc"
+	};
+	return {
+		field: column.id,
+		direction: column.kind === "text" || column.kind === "badge" ? "asc" : "desc"
+	};
+}
+//#endregion
+export { DEFAULT_TABLE_LABELS, buildTableDescription, buildTableInsight, columnId, columnValueFormat, deltaPolarity, deriveTableState, nextSort, normalizeTable, normalizeTrendPoints, resolveTableLabels, summarizeTrend, trendTimeFormat };

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

@@ -0,0 +1,4 @@
+import { BuildTableDescriptionInput, BuildTableInsightInput, DEFAULT_TABLE_LABELS, DeriveTableStateInput, NormalizeTableInput, TableCardAlign, TableCardBadgeColumn, TableCardBarColumn, TableCardCell, TableCardCellDelta, TableCardColumn, TableCardColumnKind, TableCardColumnModel, TableCardDeltaColumn, TableCardGoodDirection, TableCardLabels, TableCardNumberColumn, TableCardPolarity, TableCardRow, TableCardRowModel, TableCardSize, TableCardSort, TableCardSortDirection, TableCardState, TableCardStatus, TableCardSummary, TableCardTextColumn, TableCardTone, TableCardTotal, TableCardTrendColumn, TableCardTrendMark, TableCardTrendPoint, TableCardTrendSummary, buildTableDescription, buildTableInsight, columnId, columnValueFormat, deltaPolarity, deriveTableState, nextSort, normalizeTable, normalizeTrendPoints, resolveTableLabels, summarizeTrend, trendTimeFormat } from "./TableCard.model.js";
+import { TableCard, TableCardBaseProps, TableCardLabelProps, TableCardProps } from "./TableCard.js";
+import { TABLE_TREND_DATASET, TABLE_TREND_HOVER_PARAM, TABLE_TREND_LATEST_DATASET, TableTrendSpecOptions, buildTableTrendSpec } from "./TableCard.chart.js";
+export { type BuildTableDescriptionInput, type BuildTableInsightInput, DEFAULT_TABLE_LABELS, type DeriveTableStateInput, type NormalizeTableInput, TABLE_TREND_DATASET, TABLE_TREND_HOVER_PARAM, TABLE_TREND_LATEST_DATASET, TableCard, type TableCardAlign, type TableCardBadgeColumn, type TableCardBarColumn, type TableCardBaseProps, type TableCardCell, type TableCardCellDelta, type TableCardColumn, type TableCardColumnKind, type TableCardColumnModel, type TableCardDeltaColumn, type TableCardGoodDirection, type TableCardLabelProps, type TableCardLabels, type TableCardNumberColumn, type TableCardPolarity, type TableCardProps, type TableCardRow, type TableCardRowModel, type TableCardSize, type TableCardSort, type TableCardSortDirection, type TableCardState, type TableCardStatus, type TableCardSummary, type TableCardTextColumn, type TableCardTone, type TableCardTotal, type TableCardTrendColumn, type TableCardTrendMark, type TableCardTrendPoint, type TableCardTrendSummary, type TableTrendSpecOptions, buildTableDescription, buildTableInsight, buildTableTrendSpec, columnId, columnValueFormat, deltaPolarity, deriveTableState, nextSort, normalizeTable, normalizeTrendPoints, resolveTableLabels, summarizeTrend, trendTimeFormat };

package/dist/components/TableCard/index.js

@@ -0,0 +1,4 @@
+import { TABLE_TREND_DATASET, TABLE_TREND_HOVER_PARAM, TABLE_TREND_LATEST_DATASET, buildTableTrendSpec } from "./TableCard.chart.js";
+import { DEFAULT_TABLE_LABELS, buildTableDescription, buildTableInsight, columnId, columnValueFormat, deltaPolarity, deriveTableState, nextSort, normalizeTable, normalizeTrendPoints, resolveTableLabels, summarizeTrend, trendTimeFormat } from "./TableCard.model.js";
+import { TableCard } from "./TableCard.js";
+export { DEFAULT_TABLE_LABELS, TABLE_TREND_DATASET, TABLE_TREND_HOVER_PARAM, TABLE_TREND_LATEST_DATASET, TableCard, buildTableDescription, buildTableInsight, buildTableTrendSpec, columnId, columnValueFormat, deltaPolarity, deriveTableState, nextSort, normalizeTable, normalizeTrendPoints, resolveTableLabels, summarizeTrend, trendTimeFormat };

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

@@ -0,0 +1,52 @@
+import { ChartTokens } from "../../lib/vega/tokens.js";
+import { TopLevelSpec } from "vega-lite";
+//#region src/components/TargetCard/TargetCard.chart.d.ts
+/** One row `{ value, zero, ratio, tone }` — the reading, drawn as the bar from zero. */
+declare const TARGET_ACTUAL_DATASET = "table";
+/** One row `{ min, max, target }` — the x domain (always spanning zero, the target and every marker) and the target's position for the label layout. */
+declare const TARGET_BOUNDS_DATASET = "bounds";
+/** One or two rows `{ value, ratio, role }` with `role` `target` or `pace` — the ticks and their words. */
+declare const TARGET_MARKERS_DATASET = "markers";
+/** Zero or one row `{ from, to, ratio, tone }` — the projected extension beyond the reading. */
+declare const TARGET_PROJECTION_DATASET = "projection";
+/** The x domain's ends, read from the `bounds` dataset. */
+declare const TARGET_MIN_PARAM = "target_x_min";
+declare const TARGET_MAX_PARAM = "target_x_max";
+/** The target's value, read from the `bounds` dataset — the pace word yields to the target word when the two would collide. */
+declare const TARGET_MARKER_PARAM = "target_marker";
+declare const TARGET_LABEL_ROW_PX = 16;
+interface TargetBulletSpecOptions {
+  /** Bar and track thickness in pixels (≤ 24). */
+  barHeight: number;
+  /** Plot height in pixels — the bar row plus, with `labels`, the word row. */
+  height: number;
+  /** Write the marker words (`Target`, `Pace`) under their ticks. */
+  labels: boolean;
+  /** Wire the tooltip channel on the bar, the extension and the ticks. */
+  tooltip: boolean;
+  /** Localised words for the two markers. */
+  targetLabel: string;
+  paceLabel: string;
+  /** `arcNumber` grammar for values (`currency:THB:compact@en-US`). */
+  valueFormat: string;
+  /** Localised tooltip titles. */
+  valueTitle: string;
+  targetTitle: string;
+  paceTitle: string;
+  projectionTitle: string;
+  locale?: string;
+}
+/**
+ * Builds the bullet graph: a muted track across the whole domain, the reading
+ * as a bar from zero (length on a shared zero-based scale — Cleveland &
+ * McGill's channel for magnitude, Wilke's proportional ink), a lighter
+ * extension to the projection, a thin gray tick where the plan expects the
+ * reading to be by now and a heavier tick at the target, each with its word
+ * underneath — the pace word yielding when the two would collide — and a
+ * tooltip on every mark. The domain is explicit (`bounds`), so a reading past
+ * its target extends the scale rather than clipping, and a negative reading
+ * grows the track to the left of zero.
+ */
+declare function buildTargetBulletSpec(options: TargetBulletSpecOptions, tokens: ChartTokens): TopLevelSpec;
+//#endregion
+export { TARGET_ACTUAL_DATASET, TARGET_BOUNDS_DATASET, TARGET_LABEL_ROW_PX, TARGET_MARKERS_DATASET, TARGET_MARKER_PARAM, TARGET_MAX_PARAM, TARGET_MIN_PARAM, TARGET_PROJECTION_DATASET, TargetBulletSpecOptions, buildTargetBulletSpec };