@arcfusionz/arc-analytic-ui 0.0.0

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

@@ -0,0 +1,521 @@
+import { ArcDeltaDirection, ArcDeltaMode, ArcTimeGranularity } from "../../lib/vega/formatters.js";
+//#region src/components/MetricCard/MetricCard.model.d.ts
+/** What the consumer's transport reports. */
+type MetricCardStatus = "loading" | "ready" | "error";
+/**
+ * What the card actually shows, derived from `status`, the value, the trend
+ * and `filtered`. Stamped on the root as `data-state`.
+ */
+type MetricCardState = "loading" | "refreshing" | "ready" | "empty" | "no-match" | "error";
+/** Which way is good: revenue goes up, churn goes down, headcount is neutral. */
+type MetricGoodDirection = "up" | "down" | "none";
+/** How a delta reads once `goodDirection` is applied. Stamped as `data-polarity`. */
+type MetricPolarity = "positive" | "negative" | "neutral";
+type MetricDeltaMode = ArcDeltaMode;
+type MetricTrendMark = "line" | "area" | "bar";
+type MetricTrendScale = "auto" | "zero";
+/** Which axes the sparkline draws. `none` is the sparkline convention; the others turn it into a small labelled chart. */
+type MetricTrendAxes = "none" | "x" | "y" | "both";
+type MetricTrendXType = "temporal" | "quantitative" | "ordinal";
+type MetricCardSize = "sm" | "md" | "lg";
+/** `default` is the metric tile; `highlight` is a card about one window of the trend. Stamped as `data-variant`. */
+type MetricCardVariant = "default" | "highlight";
+/**
+ * The window a `highlight` card is about, in the trend's own `x` type: `Date`s
+ * or ISO strings for a temporal trend, numbers for a quantitative one, the
+ * category labels for an ordinal one. Each bound snaps inward to the nearest
+ * finite reading, so a window may begin or end on a gap.
+ */
+interface MetricHighlightRange {
+  start: Date | string | number;
+  end: Date | string | number;
+  /**
+   * Names the window — `Steepest 2-day drop`. Shown under the delta badge in
+   * place of the formatted period and as the tooltip's title; the period
+   * itself stays on the axis, in the tooltip, the popover and the descriptions.
+   */
+  label?: string;
+}
+/** A finite reading the window snapped to, with its index in the normalised rows. */
+interface MetricHighlightReading {
+  x: number | string;
+  y: number;
+  index: number;
+}
+/** The resolved window: its two readings, the period as text, and the change between them in every form the card speaks. */
+interface MetricHighlightInfo {
+  start: MetricHighlightReading;
+  end: MetricHighlightReading;
+  label?: string;
+  /** The period, formatted with the card's locale — `Aug 7 – 9, 2026`, `Q2 – Q4`. */
+  rangeText: string;
+  /** The change from start to end in the card's `deltaMode` — what the badge shows; its polarity colours the highlighted marks. */
+  delta: MetricDelta;
+  /** The change in the value's own units — percentage points for a percent format. */
+  absoluteText: string;
+  /** The relative change, or `MISSING_VALUE` when the start reading is zero. */
+  percentText: string;
+}
+/** A trend row as the highlight sparkline reads it: `hl` marks the window, `tone` carries the window's polarity for the mark colour. */
+interface MetricHighlightTrendRow extends MetricTrendRow {
+  hl: boolean;
+  tone: MetricPolarity | null;
+}
+/** The readings outside the window, split so the context line stops at the window's edges instead of running under it. */
+interface MetricHighlightContextRow extends MetricTrendRow {
+  seg: "before" | "after";
+}
+interface MetricHighlightPoint {
+  x: number | string;
+  y: number;
+  role: "start" | "end";
+  tone: MetricPolarity;
+}
+/** One row spanning the window — the band behind a line and the source of the axis anchors. */
+interface MetricHighlightBand {
+  start: number | string;
+  end: number | string;
+  startY: number;
+  endY: number;
+  tone: MetricPolarity;
+}
+/** A piece of a generated insight sentence: plain text, or a value the card sets in bold. */
+type MetricInsightSegment = string | {
+  value: string;
+};
+/** Every named dataset the highlight sparkline reads. */
+interface MetricHighlightDatasets {
+  table: MetricHighlightTrendRow[];
+  context: MetricHighlightContextRow[];
+  highlightRows: MetricHighlightTrendRow[];
+  highlightPoints: MetricHighlightPoint[];
+  highlight: MetricHighlightBand[];
+}
+/**
+ * One reading of the trend. Cloudscape's `{ x, y }` point contract: `x` is a
+ * `Date`, an ISO string, a number or a category label; `y` is the value, or
+ * `null` for a period with no reading (drawn as a gap, never as zero).
+ */
+interface MetricTrendPoint {
+  x: Date | string | number;
+  y: number | null;
+}
+/** A trend point after normalisation: temporal `x` is epoch milliseconds, ordinal `x` a string. */
+interface MetricTrendRow {
+  x: number | string;
+  y: number | null;
+}
+interface MetricTrendSummary {
+  rows: MetricTrendRow[];
+  xType: MetricTrendXType;
+  /** Points with a finite `y`. */
+  count: number;
+  first: MetricTrendRow | null;
+  last: MetricTrendRow | null;
+  /** The last point with a finite `y` — what the endpoint dot marks. */
+  latest: MetricTrendRow | null;
+  min: number | null;
+  max: number | null;
+  granularity: ArcTimeGranularity;
+}
+interface MetricDelta {
+  direction: ArcDeltaDirection;
+  polarity: MetricPolarity;
+  /** Signed, formatted change: `+12.4%`, `-0.3 pp`, `+฿124K`. */
+  text: string;
+  renderedMode: ArcDeltaMode;
+  /**
+   * The same change in the other form — the absolute amount when `text` is a
+   * percent, the relative change when `text` is an amount. `null` when the
+   * other form does not exist (a zero baseline has no percent), so the delta
+   * tooltip drops the row rather than printing a dash.
+   */
+  secondaryText: string | null;
+}
+/**
+ * What the delta tooltip explains: the two readings behind the badge and the
+ * change between them, in both forms. `kind` is `window` on the highlight
+ * variant, whose badge compares a window's end against its start rather than
+ * the headline against the previous period.
+ */
+interface MetricDeltaExplanation {
+  kind: "period" | "window";
+  /** The reading compared against — the previous period, or the window's start. */
+  previousText: string;
+  /**
+   * The selected baseline's name when the card offers several (`last month`),
+   * so the row can name it; `null` when the badge compares against one
+   * previous reading, which the rows call `Previous`. Always `null` on the
+   * window kind.
+   */
+  previousLabel: string | null;
+  /** The headline reading — the current period, or the window's end. */
+  currentText: string;
+  /** The badge's own signed change. */
+  changeText: string;
+  /** `changeText`'s other form, or `null` when it has none. */
+  secondaryText: string | null;
+  /** Which form `changeText` is in, so the other form's row can name itself. */
+  renderedMode: ArcDeltaMode;
+  direction: ArcDeltaDirection;
+  /** What the card's comparison line already says — `vs last month`, or the window's name or period. */
+  comparisonText: string;
+  /** The window's period. `null` on the period kind, which has no window. */
+  periodText: string | null;
+}
+interface MetricTargetInfo {
+  /** `value / target`, unclamped — 1.1 is 110% of target. */
+  ratio: number;
+  percentText: string;
+  /** Formatted amount represented by the displayed whole percentage × target. */
+  progressAmountText: string;
+  targetText: string;
+  /** Signed relative variance against the target, e.g. `-4.2%`. */
+  varianceText: string;
+  /** Which side of the target the value sits on — the variance badge's arrow. */
+  direction: ArcDeltaDirection;
+  met: boolean;
+  /** Meter fill: `success` once met, `destructive` when a lower-is-better metric overshoots, else `primary`. */
+  variant: "primary" | "success" | "destructive";
+}
+/** Every string the card renders or announces, so a product can localise it. Sentences are functions. */
+interface MetricCardLabels {
+  /** Default comparison label when `comparisonLabel` is omitted. */
+  previousPeriod: string;
+  increase: string;
+  decrease: string;
+  unchanged: string;
+  ofTarget: string;
+  vsTarget: string;
+  /** Suffix for a percentage-point delta. */
+  percentagePoints: string;
+  noData: string;
+  noMatch: string;
+  clearFilters: string;
+  error: string;
+  retry: string;
+  insufficientTrend: string;
+  stale: string;
+  asOf: string;
+  tablePeriod: string;
+  tableValue: string;
+  /** Label for the dotted target reference line in chart details. */
+  target: string;
+  /** Highlight variant: the tooltip's start and end rows, its two change rows, the period row under a named window, and the marker read out on the table's highlighted rows. */
+  highlightStart: string;
+  highlightEnd: string;
+  highlightChange: string;
+  highlightChangePercent: string;
+  highlightRange: string;
+  highlighted: string;
+  /** Comparison line for the selected baseline when the card offers several — `vs last month`. */
+  versus: (baseline: string) => string;
+  /** Accessible name of the delta stack when it opens the compare-with menu — `Choose what Revenue is compared with`. */
+  chooseComparison: (name: string) => string;
+  /** Heading of the compare-with menu's options column, and the comparison line while no baseline is selected. */
+  compareWith: string;
+  /** The compare-with menu's one row on a tile given a single `previousValue` — the reading behind the badge. */
+  previous: string;
+  /** Column headers of the compare-with menu's changes — the relative move and the amount in the value's units. */
+  changePercent: string;
+  changeAmount: string;
+  /** Accessible name of the delta stack when it opens the highlight details popover — `Details of the Conversion rate highlight`. */
+  highlightDetails: (name: string) => string;
+  /** Caption of the details popover's table of the window's readings. */
+  highlightReadings: (name: string) => string;
+  /** The details popover's context rows: the stretch of the trend before the window, the stretch since it, and the latest reading. */
+  highlightBefore: string;
+  highlightSince: string;
+  highlightLatest: string;
+  markNames: Record<MetricTrendMark, string>;
+  showTable: (name: string) => string;
+  hideTable: (name: string) => string;
+  about: (name: string) => string;
+  loading: (name: string) => string;
+  tableCaption: (name: string) => string;
+  targetProgress: (name: string) => string;
+  /** Compact label/value rows explaining the target block's displayed values. */
+  targetExplanation: (target: MetricTargetInfo) => readonly (readonly [label: string, value: string])[];
+  /** Accessible name of the delta group beside the value. */
+  deltaComparison: (name: string) => string;
+  /** Compact label/value rows explaining the delta badge — the two readings behind it and the change in both forms. */
+  deltaExplanation: (delta: MetricDeltaExplanation) => readonly (readonly [label: string, value: string])[];
+  trendSummary: (count: number, first: string, last: string, min: string, max: string) => string;
+  chartDescription: (input: {
+    mark: string;
+    name: string;
+    count: number;
+    first: string;
+    last: string;
+    min: string;
+    max: string;
+    latest: string;
+    target: string | null;
+  }) => string;
+  /** The highlight variant's comparison sentence in the card description: `word` is the resolved direction word, `primary` the badge's unsigned change (empty when flat), `secondary` the other form or `null`. */
+  highlightSentence: (input: {
+    word: string;
+    primary: string;
+    secondary: string | null;
+    range: string;
+    label?: string;
+    from: string;
+    to: string;
+  }) => string;
+  /** Appended to the sparkline's `aria-label` for the highlight variant. */
+  highlightDescription: (input: {
+    range: string;
+    label?: string;
+    from: string;
+    to: string;
+    direction: ArcDeltaDirection;
+    primary: string;
+  }) => string;
+  /** Accessible name of the AI mark beside the insight sentence. */
+  insightMark: string;
+  /**
+   * The highlight variant's generated insight, as segments so the values —
+   * `from`, `to`, `change` and its other form `secondary` (unsigned; `null`
+   * when flat or undefined) — render in bold while the words stay plain.
+   */
+  highlightInsight: (input: {
+    name: string;
+    direction: ArcDeltaDirection;
+    from: string;
+    to: string;
+    change: string;
+    secondary: string | null;
+    range: string;
+    label?: string;
+  }) => MetricInsightSegment[];
+}
+declare const DEFAULT_METRIC_LABELS: MetricCardLabels;
+declare function resolveMetricLabels(overrides?: Partial<MetricCardLabels>): MetricCardLabels;
+interface DeriveMetricStateInput {
+  status: MetricCardStatus;
+  /** A finite headline value exists. */
+  hasValue: boolean;
+  /** Anything is on screen already — a value or trend rows — so a reload is a refresh, not 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); a missing value is `no-match` when
+ * the consumer's filter caused it and `empty` otherwise.
+ */
+declare function deriveMetricState({ status, hasValue, hasData, filtered }: DeriveMetricStateInput): MetricCardState;
+/**
+ * Normalises `trend` for Vega and the table: temporal `x` becomes epoch
+ * milliseconds (numbers are treated as quantitative; pass a `Date` or an ISO
+ * string for time), invalid dates are dropped, `null` readings are kept as
+ * gaps, and the range and the latest reading are summarised for the text
+ * equivalents. Returns `null` when there is no trend at all.
+ */
+declare function normalizeTrend(points: readonly MetricTrendPoint[] | undefined, granularity?: ArcTimeGranularity): MetricTrendSummary | null;
+interface DeriveDeltaOptions {
+  deltaMode: MetricDeltaMode;
+  goodDirection: MetricGoodDirection;
+  format: string;
+  locale?: string;
+  percentagePoints: string;
+}
+/** The comparison against the previous reading, with polarity resolved through `goodDirection`. */
+declare function deriveDelta(value: number | null | undefined, previousValue: number | null | undefined, { deltaMode, goodDirection, format, locale, percentagePoints }: DeriveDeltaOptions): MetricDelta | null;
+interface DeriveTargetOptions {
+  goodDirection: MetricGoodDirection;
+  format: string;
+  locale?: string;
+  formatValue?: (value: number) => string;
+}
+/** Progress against the target. `null` without a usable target (a zero target has no ratio). */
+declare function deriveTarget(value: number | null | undefined, target: number | null | undefined, { goodDirection, format, locale, formatValue }: DeriveTargetOptions): MetricTargetInfo | null;
+/**
+ * The granularity an x axis labels its ticks at: the tooltip and table keep
+ * the full form (`Sep 8, 2026`); a 250px axis has room for `Sep 8`.
+ */
+declare function axisGranularity(granularity: ArcTimeGranularity): ArcTimeGranularity;
+interface MetricTextFormatters {
+  formatY: (value: number | null | undefined) => string;
+  formatX: (x: number | string) => string;
+  /** A period between two `x` values — a collapsed date range for a temporal axis (`Aug 7 – 9, 2026`), `start – end` otherwise. */
+  formatXRange: (start: number | string, end: number | string) => string;
+}
+/** The two formatters every text surface shares — headline, delta, table, tooltip, descriptions. */
+declare function createMetricFormatters({ format, locale, timeZone, formatValue, xType, granularity }: {
+  format: string;
+  locale?: string;
+  timeZone?: string;
+  formatValue?: (value: number) => string;
+  xType: MetricTrendXType;
+  granularity: ArcTimeGranularity;
+}): MetricTextFormatters;
+interface ResolveHighlightOptions {
+  deltaMode: MetricDeltaMode;
+  goodDirection: MetricGoodDirection;
+  format: string;
+  locale?: string;
+  percentagePoints: string;
+  formatters: MetricTextFormatters;
+}
+/**
+ * Snaps a highlight window onto the trend and measures it. Each bound moves
+ * inward to the nearest finite reading (a temporal or quantitative bound need
+ * not hit a point exactly; an ordinal bound is a category label), the bounds
+ * may come in either order, and the result is `null` when the window does not
+ * hold two distinct finite readings — the card then draws the plain sparkline
+ * and stamps `data-highlight="unresolved"` rather than inventing a change.
+ */
+declare function resolveHighlight(summary: MetricTrendSummary | null | undefined, range: MetricHighlightRange | undefined, { deltaMode, goodDirection, format, locale, percentagePoints, formatters }: ResolveHighlightOptions): MetricHighlightInfo | null;
+/**
+ * The highlight variant's default insight sentence — what the card shows
+ * beside the AI mark when the consumer passes no `insight`. The window's start
+ * and end readings and its change (in the badge's form, with the other form
+ * in brackets) come back as `{ value }` segments so the card can set them in
+ * bold; the words come from `labels.highlightInsight`.
+ */
+declare function buildHighlightInsight({ name, highlight, formatters, labels }: {
+  name: string;
+  highlight: MetricHighlightInfo;
+  formatters: MetricTextFormatters;
+  labels: MetricCardLabels;
+}): MetricInsightSegment[];
+/** The plain-text reading of insight segments — for descriptions and tests. */
+declare function insightSegmentsToText(segments: readonly MetricInsightSegment[]): string;
+/**
+ * The datasets the highlight sparkline reads, derived once per trend or window
+ * change: every row flagged with `hl` (bars colour themselves from it, the
+ * hover dot too), the context readings split into a `before` and an `after`
+ * run so the gray line stops at the window's edges, the window's own readings
+ * for the coloured segment, its two endpoint dots, and the one-row band. A
+ * continuous axis decides membership by `x`, an ordinal one by position.
+ */
+declare function buildHighlightDatasets(summary: MetricTrendSummary, info: MetricHighlightInfo): MetricHighlightDatasets;
+/**
+ * One baseline the headline can be compared with — yesterday, last week, last
+ * month, last year. `key` identifies it for `comparison` (defaults to
+ * `label`); `value` is its reading, or `null` when the product has none for
+ * it yet — the baseline is then listed in the compare-with menu but cannot be
+ * chosen.
+ */
+interface MetricComparison {
+  key?: string;
+  label: string;
+  value: number | null;
+}
+/** The key of the one baseline a tile builds from `previousValue` for its compare-with menu. Never collides with a consumer's key. */
+declare const METRIC_PREVIOUS_KEY = "__previous__";
+/** A baseline after normalisation: a unique key, and a finite value or `null`. */
+interface MetricComparisonRow {
+  key: string;
+  label: string;
+  value: number | null;
+}
+/** What the compare-with menu shows for one baseline: its reading, and the change the headline would show against it in both forms, with the polarity of that change. */
+interface MetricComparisonCandidate {
+  row: MetricComparisonRow;
+  /** `null` when the baseline or the headline has no finite value. */
+  delta: MetricDelta | null;
+  polarity: MetricPolarity;
+  valueText: string;
+  /** The relative change, or `MISSING_VALUE` when it does not exist. */
+  percentText: string;
+  /** The change in the value's units, or `MISSING_VALUE`. */
+  amountText: string;
+}
+/**
+ * Normalises the baselines a metric tile offers: keys default to labels (a
+ * repeated key is suffixed so two options never collide), non-finite values
+ * become `null`. The consumer's order is kept — it is the menu's order.
+ */
+declare function normalizeComparisons(items: readonly MetricComparison[] | undefined): MetricComparisonRow[];
+/**
+ * The selected baseline. `null` designates none; a key names one — an absent
+ * key selects none rather than a substitute, so the card never compares
+ * against something the app did not ask for; `undefined` takes the first
+ * baseline with a value, else the first baseline.
+ */
+declare function resolveComparison(rows: readonly MetricComparisonRow[], key: string | null | undefined): MetricComparisonRow | null;
+interface DescribeComparisonsOptions extends DeriveDeltaOptions {
+  formatters: MetricTextFormatters;
+}
+/** The compare-with menu's table: every baseline with the change the headline would show against it, in percent and in the value's units. */
+declare function describeComparisons(rows: readonly MetricComparisonRow[], value: number | null | undefined, { formatters, ...options }: DescribeComparisonsOptions): MetricComparisonCandidate[];
+/** A reading as the details popover prints it. */
+interface MetricHighlightReadingText {
+  x: number | string;
+  xText: string;
+  yText: string;
+}
+/** One reading inside the highlighted window, with its change from the previous finite reading inside it. */
+interface MetricHighlightStep extends MetricHighlightReadingText {
+  /** The change from the previous finite reading in the window, in the card's `deltaMode`; `null` on the first reading and on a gap. */
+  changeText: string | null;
+  /** The polarity of that change through `goodDirection`; `neutral` without one. */
+  polarity: MetricPolarity;
+  role: "start" | "end" | "inside";
+}
+/** A stretch of the trend outside the window — from its first reading to the window's start, or from the window's end to its latest reading — measured end to end. */
+interface MetricHighlightStretch {
+  from: MetricHighlightReadingText;
+  to: MetricHighlightReadingText;
+  /** The stretch's period — `Jul 25 – Aug 7, 2026`. */
+  rangeText: string;
+  /** The change over the stretch in the card's `deltaMode`, and its other form. */
+  changeText: string;
+  secondaryText: string | null;
+  direction: ArcDeltaDirection;
+  polarity: MetricPolarity;
+}
+/** What the highlight details popover shows beyond the window's own change. */
+interface MetricHighlightDetails {
+  /** Every reading inside the window, in axis order, gaps included. */
+  steps: MetricHighlightStep[];
+  /** From the trend's first finite reading to the window's start; `null` when the window starts at the first reading. */
+  before: MetricHighlightStretch | null;
+  /** From the window's end to the trend's latest finite reading; `null` when the window ends at the latest reading. */
+  since: MetricHighlightStretch | null;
+}
+/**
+ * The detail behind a resolved window — what the sparkline cannot show at
+ * tile scale: the readings inside the window one by one, each with its step
+ * from the previous finite reading, and the trend's movement before the
+ * window and since it, so the reader can tell a step change from a slide and
+ * a recovery from a plateau. A continuous axis decides membership by `x`, an
+ * ordinal one by position.
+ */
+declare function buildHighlightDetails(summary: MetricTrendSummary, info: MetricHighlightInfo, { deltaMode, goodDirection, format, locale, percentagePoints, formatters }: ResolveHighlightOptions): MetricHighlightDetails;
+interface BuildMetricDescriptionInput {
+  name: string;
+  state: MetricCardState;
+  valueText: string;
+  unit?: string;
+  delta: MetricDelta | null;
+  comparisonText: string;
+  target: MetricTargetInfo | null;
+  trend: MetricTrendSummary | null;
+  formatters: MetricTextFormatters;
+  asOfText?: string;
+  labels: MetricCardLabels;
+  /** The highlight variant's resolved window; its change replaces the previous-period sentence. */
+  highlight?: MetricHighlightInfo | 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.
+ */
+declare function buildMetricDescription({ name, state, valueText, unit, delta, comparisonText, target, trend, formatters, asOfText, labels, highlight }: BuildMetricDescriptionInput): string;
+/** The sparkline's own `description` — the `aria-label` Vega stamps on the `graphics-document`. */
+declare function buildMetricChartDescription({ name, mark, trend, target, formatters, labels, highlight }: {
+  name: string;
+  mark: MetricTrendMark;
+  trend: MetricTrendSummary;
+  target: MetricTargetInfo | null;
+  formatters: MetricTextFormatters;
+  labels: MetricCardLabels;
+  /** The highlight variant's resolved window, described after the series. */
+  highlight?: MetricHighlightInfo | null;
+}): string;
+//#endregion
+export { BuildMetricDescriptionInput, DEFAULT_METRIC_LABELS, DeriveDeltaOptions, DeriveMetricStateInput, DeriveTargetOptions, DescribeComparisonsOptions, METRIC_PREVIOUS_KEY, MetricCardLabels, MetricCardSize, MetricCardState, MetricCardStatus, MetricCardVariant, MetricComparison, MetricComparisonCandidate, MetricComparisonRow, MetricDelta, MetricDeltaExplanation, MetricDeltaMode, MetricGoodDirection, MetricHighlightBand, MetricHighlightContextRow, MetricHighlightDatasets, MetricHighlightDetails, MetricHighlightInfo, MetricHighlightPoint, MetricHighlightRange, MetricHighlightReading, MetricHighlightReadingText, MetricHighlightStep, MetricHighlightStretch, MetricHighlightTrendRow, MetricInsightSegment, MetricPolarity, MetricTargetInfo, MetricTextFormatters, MetricTrendAxes, MetricTrendMark, MetricTrendPoint, MetricTrendRow, MetricTrendScale, MetricTrendSummary, MetricTrendXType, ResolveHighlightOptions, axisGranularity, buildHighlightDatasets, buildHighlightDetails, buildHighlightInsight, buildMetricChartDescription, buildMetricDescription, createMetricFormatters, deriveDelta, deriveMetricState, deriveTarget, describeComparisons, insightSegmentsToText, normalizeComparisons, normalizeTrend, resolveComparison, resolveHighlight, resolveMetricLabels };