@firestitch/report 18.6.1 → 18.8.0

package/esm2022/app/reports/option-builder.mjs

@@ -1,12 +1,21 @@
-import { format, isValid, parseISO } from 'date-fns';
-import { formatMeasureValue } from './format';
+import { addDays, addMonths, addQuarters, addWeeks, addYears, endOfMonth, formatISO, isLastDayOfMonth, isValid, max as latestOf, min as earliestOf, parseISO, startOfDay, } from 'date-fns';
+import { ReportChartColor } from './enums/report-chart-color.enum';
+import { ReportChartDataLabels } from './enums/report-chart-data-labels.enum';
+import { ReportChartDateLabel } from './enums/report-chart-date-label.enum';
+import { ReportChartLineStyle } from './enums/report-chart-line-style.enum';
+import { ReportChartMarkStat } from './enums/report-chart-mark-stat.enum';
+import { ReportListColumnFormat } from './enums/report-list-column-format.enum';
+import { ReportNumberUnits } from './enums/report-number-units.enum';
+import { ReportValueFormat } from './enums/report-value-format.enum';
+import { axisNumberFormat, chartValuePeak, comparisonOffsetLabel, DAY_SHORT, dateFormat, formatDayRange, formatDayWindow, formatLocalDate, formatNumber, formatOutputValue, formatPlainNumber, hasNumberFormat, laneOutputAlias, MONTH_DAY, MONTH_LONG, MONTH_YEAR, resolveChartNumberFormat, windowText, } from './format';
 import { GRANULARITY_OPTIONS, } from './interfaces/report.interface';
 import { escapeHtml } from './text';
-import { REPORT_WATERFALL_COLORS } from './theme/palette';
-import { REPORT_AXIS_LABEL_FONT_SIZE, REPORT_CHART_FONT_FAMILY } from './theme/typography';
-// Room for the category axis's title. ECharts 5's containLabel keeps the TICK
-// labels inside the grid but not the axis name, so without this a vertical
-// chart's title runs off the bottom edge or under a bottom legend.
+import { REPORT_CHART_COLOR_BY_NAME, REPORT_CHART_COLORS, REPORT_CHART_COLORS_CSS, REPORT_REFERENCE_COLOR, REPORT_WATERFALL_COLORS, } from './theme/palette';
+import { REPORT_AXIS_LABEL_FONT_SIZE, REPORT_CHART_FONT_FAMILY, REPORT_DATA_LABEL_FONT_SIZE } from './theme/typography';
+// Room for an axis title. ECharts 5's containLabel keeps the TICK labels inside
+// the grid but not the axis name, so without this a vertical chart's category
+// title runs off the bottom edge or under a bottom legend, and its value title
+// above the plot runs off the top or under a top legend.
 const AXIS_NAME_ROOM = 20;
 // ECharts' own default gap between the axis line and its tick labels.
 const AXIS_LABEL_MARGIN = 8;
@@ -22,6 +31,73 @@ const LABEL_ELLIPSIS = '…';
 // measured in it the way ECharts measures them for containLabel, so a
 // horizontal chart's title lands exactly beyond the widest label.
 const AXIS_LABEL_FONT = `${REPORT_AXIS_LABEL_FONT_SIZE}px ${REPORT_CHART_FONT_FAMILY}`;
+// The letter a quarter label starts with, by language subtag. French writes the
+// second quarter 'T2' (trimestre); every other language reads 'Q2'.
+const QUARTER_PREFIXES = new Map([['fr', 'T']]);
+const QUARTER_PREFIX = 'Q';
+// A 100% stacked chart's value axis: whole percentages, a gridline every 25%,
+// up to 100%. Its tooltip gives each share to one decimal.
+const PERCENT_AXIS_FORMAT = { format: ReportValueFormat.Percent, precision: 0 };
+const PERCENT_SHARE_FORMAT = { format: ReportValueFormat.Percent, precision: 1 };
+export const PERCENT_AXIS_MAX = 1;
+export const PERCENT_AXIS_INTERVAL = 0.25;
+// A reference band's fill: the reference slate, faint enough that the series
+// drawn across it stay readable.
+const REFERENCE_BAND_FILL = 'rgba(82, 96, 109, 0.08)';
+// A reference's or statistic line's label sits on a light box, so it stays
+// readable where it crosses a bar or a line.
+const MARK_LABEL_BOX = { backgroundColor: 'rgba(255, 255, 255, 0.85)', padding: [1, 3], borderRadius: 2 };
+// The room an axis stretched to a reference leaves above it, for its label:
+// the bound is the round number at or past the reference plus this share.
+const REFERENCE_HEADROOM = 1.05;
+// How a chart marks what the server says of its numbers (ComponentData's
+// comparison, outputs, windows and partialPeriod). The words are interface
+// text, English in every report locale.
+// - The heading of a period not over yet ('September 2026 (to date)').
+const PARTIAL_PERIOD_TEXT = 'to date';
+// - A compared series' name: its measure's, then its role and lane ('Revenue
+//   change (vs previous week)'). A prior keeps the measure's name alone.
+const ROLE_NAME_SUFFIXES = {
+    prior: '',
+    change: ' change',
+    percent_change: ' % change',
+};
+// - A prior series' bars: its current series' color, faded, with a dashed
+//   edge. Its line is dashed (PRIOR_LINE_STYLE) unless its measure names one.
+const PRIOR_BAR_OPACITY = 0.45;
+const PRIOR_LINE_STYLE = ReportChartLineStyle.Dashed;
+// - The period not over yet: its bar hatched in light stripes, its point on a
+//   line drawn larger with a dashed edge, and, when it is the last one, the
+//   line's last segment dashed.
+const PARTIAL_LINE_STYLE = ReportChartLineStyle.Dashed;
+const PARTIAL_BAR_DECAL = {
+    symbol: 'none',
+    dashArrayX: [1, 0],
+    dashArrayY: [3, 5],
+    rotation: -Math.PI / 4,
+    color: 'rgba(255, 255, 255, 0.6)',
+};
+const PARTIAL_POINT_MARK = { symbol: 'emptyCircle', symbolSize: 9, itemStyle: { borderType: 'dashed' } };
+// - A value axis of ranks only: rank 1 at the top, whole steps, from 1.
+const RANK_AXIS_FORMAT = { format: ReportValueFormat.Number, precision: 0 };
+// (Shared with the PowerPoint export, whose rank axes start there too.)
+export const RANK_AXIS_MIN = 1;
+// - A value axis of 0-1 fractions only (shares, percent changes) is a
+//   percent axis, its decimals decided by its peak.
+const FRACTION_AXIS_FORMAT = { format: ReportValueFormat.Percent };
+// - Between a tooltip value and what it covers.
+const TOOLTIP_DETAIL_SEPARATOR = ' · ';
+// - The prior a tooltip value is compared with, when the chart does not plot
+//   it ('vs 50% (Sep 1 – 2, 2026)').
+const COMPARED_PRIOR_PREFIX = 'vs';
+// The words a statistic line's label starts with. They are interface text,
+// English in every report locale; only the value after them follows it.
+export const STAT_LABEL = {
+    [ReportChartMarkStat.Average]: 'Average',
+    [ReportChartMarkStat.Median]: 'Median',
+    [ReportChartMarkStat.Min]: 'Minimum',
+    [ReportChartMarkStat.Max]: 'Maximum',
+};
 // colorBy applies only to single-dimension bar charts, and only when splitBy
 // isn't already driving multiple series: it colors each bar by its category and
 // shows a legend (one series per category, overlapped to full width).
@@ -36,9 +112,9 @@ const AXIS_LABEL_FONT = `${REPORT_AXIS_LABEL_FONT_SIZE}px ${REPORT_CHART_FONT_FA
 //
 // A TIME axis is excluded: consecutive periods are one series moving, not
 // categories being compared, and coloring each month differently reads as
-// unrelated groups. Explicitly opting out — colorBy: {column: ''} or a
-// config.legend of 'hidden' — still wins, so a caller that wants one flat color
-// can say so.
+// unrelated groups. Explicitly opting out — colorBy: {column: ''}, a color on
+// the measure or a config.legend of 'hidden' — still wins, so a caller that
+// wants one flat color can say so.
 //
 // "Bar chart" is the type the lone measure is actually DRAWN as: its own type
 // when it names one, which can turn a line chart's single series into bars or
@@ -50,6 +126,10 @@ export function isColorBy(config) {
     if (config.colorBy) {
         return !!config.colorBy.column;
     }
+    // A measure given its own color asks for one flat color.
+    if (measureColorHex(config.measures?.[0])) {
+        return false;
+    }
     return (config.xAxis?.kind ?? 'category') === 'category'
         && !config.xAxis?.granularity
         && (config.measures?.length ?? 1) <= 1;
@@ -63,15 +143,8 @@ export function colorByColumn(config) {
 }
 export function extractChartSeries(component, data) {
     const config = component.config;
-    const xColumn = config.xAxis?.column ?? data.columns[0];
-    const splitColumn = config.splitBy?.column;
-    // colorBy emits one series per category too (so each bar carries its own
-    // color + legend entry), but the bars are overlapped to full width in
-    // buildAxisOption rather than laid side-by-side. splitBy wins if both are set.
-    const groupColumn = splitColumn || colorByColumn(config);
-    const measures = config.measures?.length
-        ? config.measures
-        : [{ column: data.columns[data.columns.length - 1] }];
+    const { xColumn, groupColumn } = chartColumns(config, data);
+    const measures = chartMeasures(config, data);
     const rawCategories = uniqueValues(data.rows, xColumn);
     const categories = rawCategories.map((category) => String(category ?? '—'));
     const series = [];
@@ -79,34 +152,221 @@ export function extractChartSeries(component, data) {
         // One series per group value (splitBy/colorBy), pivoted over the first measure.
         const measure = measures[0];
         for (const groupValue of uniqueValues(data.rows, groupColumn)) {
-            const byCategory = new Map();
-            for (const row of data.rows) {
-                if (row[groupColumn] === groupValue) {
-                    byCategory.set(row[xColumn], row[measure.column]);
-                }
-            }
             series.push({
                 name: String(groupValue ?? '—'),
-                values: rawCategories.map((category) => numeric(byCategory.get(category))),
+                values: categoryValues(data.rows, xColumn, rawCategories, measure.column, (row) => row[groupColumn] === groupValue),
                 type: measure.type,
+                measure,
+                measureIndex: 0,
             });
         }
     }
     else {
-        for (const measure of measures) {
-            const byCategory = new Map();
-            for (const row of data.rows) {
-                byCategory.set(row[xColumn], row[measure.column]);
-            }
+        for (const [measureIndex, measure] of measures.entries()) {
             series.push({
-                name: measure.label ?? measure.column,
-                values: rawCategories.map((category) => numeric(byCategory.get(category))),
+                name: comparedSeriesName(measure, measures, data) ?? measure.label ?? measure.column,
+                values: categoryValues(data.rows, xColumn, rawCategories, measure.column),
                 type: measure.type,
+                measure,
+                measureIndex,
             });
         }
     }
     return { categories, series };
 }
+// The column a chart's categories come from, and the one that splits its
+// first measure into a series per value, if any. colorBy emits one series per
+// category too (so each bar carries its own color + legend entry), but the
+// bars are overlapped to full width in buildAxisOption rather than laid
+// side-by-side. splitBy wins if both are set.
+function chartColumns(config, data) {
+    return {
+        xColumn: config.xAxis?.column ?? data.columns[0],
+        groupColumn: config.splitBy?.column || colorByColumn(config),
+    };
+}
+// One column's values by category, from the rows `match` keeps (all of them
+// when it is left out). A category with no row has no value.
+function categoryValues(rows, xColumn, rawCategories, column, match) {
+    const byCategory = new Map();
+    for (const row of rows) {
+        if (!match || match(row)) {
+            byCategory.set(row[xColumn], row[column]);
+        }
+    }
+    return rawCategories.map((category) => numeric(byCategory.get(category)));
+}
+// A compared series' name, worded from its lane's offset rather than from its
+// own label, so a chart the viewer regrouped says what it now compares:
+// 'Revenue (vs previous week)', 'Revenue change (vs previous week)', 'Revenue
+// % change (vs previous year)'. The measure is named as its current value's
+// series is. null for any other series, which keeps its own name, and for
+// data without the comparison keys.
+function comparedSeriesName(measure, measures, data) {
+    const output = data.outputs?.[measure.column];
+    const offset = output?.offset ? data.comparison?.offsets?.[output.offset - 1] : undefined;
+    if (!output || !offset || !output.role || output.role === 'current') {
+        return null;
+    }
+    const current = currentOutputAlias(data.outputs, measure.column);
+    const label = measures.find((candidate) => candidate.column === current)?.label ?? current;
+    return `${label}${ROLE_NAME_SUFFIXES[output.role]} (${comparisonOffsetLabel(offset)})`;
+}
+// The column an output's current value is in: its lane's current output, else
+// for a rank or a share the uncompared one of the same measure, else the
+// measure's own column (a windowed value's source).
+function currentOutputAlias(outputs, alias) {
+    const output = outputs[alias];
+    const uncompared = output.kind === 'value'
+        ? undefined
+        : Object.keys(outputs).find((key) => outputs[key].measure === output.measure
+            && outputs[key].kind === output.kind
+            && outputs[key].role === null);
+    return laneOutputAlias(outputs, alias, 'current') ?? uncompared ?? output.measure;
+}
+// A series' own color as CSS hex: its measure's named color, or undefined when
+// it names none (or a name the palette does not know) and the theme colors it
+// by its position.
+export function seriesColor(series) {
+    const hex = namedColorHex(series);
+    return hex ? `#${hex}` : undefined;
+}
+// A series' color as the bare hex PowerPoint takes: its measure's named color,
+// else the palette color of its position, as the screen's theme picks it.
+export function seriesHex(series, index) {
+    return namedColorHex(series) ?? REPORT_CHART_COLORS[index % REPORT_CHART_COLORS.length];
+}
+function namedColorHex(series) {
+    return measureColorHex(series.measure);
+}
+// A measure's named color as bare hex, or undefined when it names none or a
+// name the palette does not know. The name is read through the enum, so a
+// stored name such as '__proto__' never reaches the lookup object.
+function measureColorHex(measure) {
+    const color = Object.values(ReportChartColor).find((name) => name === measure?.color);
+    return color ? REPORT_CHART_COLOR_BY_NAME[color] : undefined;
+}
+// A measure's line style when it names one ECharts knows, else undefined and
+// the line is solid.
+export function measureLineStyle(measure) {
+    return Object.values(ReportChartLineStyle).find((style) => style === measure?.line);
+}
+// A measure's statistic line when it names one the viewer knows, else
+// undefined and it draws none.
+export function measureMarkStat(measure) {
+    return Object.values(ReportChartMarkStat).find((stat) => stat === measure?.markLine);
+}
+// A series' statistic over its points that have a value: their mean, their
+// median (the mean of the two middle values when the count is even), the
+// lowest or the highest. null when no point has a value. Shared with the
+// PowerPoint export so both media draw the line at the same height.
+export function seriesStat(values, stat) {
+    const present = values.filter((value) => typeof value === 'number' && Number.isFinite(value));
+    if (!present.length) {
+        return null;
+    }
+    switch (stat) {
+        case ReportChartMarkStat.Average:
+            return present.reduce((sum, value) => sum + value, 0) / present.length;
+        case ReportChartMarkStat.Median: {
+            const sorted = [...present].sort((a, b) => a - b);
+            const middle = Math.floor(sorted.length / 2);
+            return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+        }
+        case ReportChartMarkStat.Min:
+            return Math.min(...present);
+        case ReportChartMarkStat.Max:
+            return Math.max(...present);
+        default:
+            return null;
+    }
+}
+// Whether a chart draws statistic lines. A horizontal chart's values run
+// along x, and PowerPoint cannot draw a line beside horizontal bars, so
+// neither medium draws one there.
+export function drawsStatLines(config) {
+    return config.orientation !== 'horizontal';
+}
+// A colorBy chart's one value per category: series i holds category i's bar.
+// PowerPoint draws these as its one series, and a statistic line is taken
+// over them.
+export function colorByValues(extracted) {
+    return extracted.categories.map((_, index) => extracted.series[index]?.values[index] ?? null);
+}
+// The references a chart draws. A vertical axis chart and a waterfall draw
+// them; a pie has no value axis, and a horizontal chart is left without them
+// as PowerPoint cannot draw a line beside horizontal bars. An entry without a
+// finite value is skipped, and one whose `to` is missing or equal to its value
+// is a line. secondary reaches the second value axis only on a chart that has
+// one (twoAxes). Shared with the PowerPoint export.
+export function chartReferences(config, twoAxes) {
+    const chartType = config.chartType ?? 'bar';
+    const references = Array.isArray(config.references) ? config.references : [];
+    if (config.orientation === 'horizontal' || chartType === 'pie' || chartType === 'donut') {
+        return [];
+    }
+    return references.flatMap((reference) => {
+        const value = axisNumber(reference?.value);
+        if (!reference || value === undefined) {
+            return [];
+        }
+        const to = axisNumber(reference.to);
+        const label = typeof reference.label === 'string' ? reference.label : '';
+        const axisIndex = twoAxes && reference.secondary === true ? 1 : 0;
+        return [to !== undefined && to !== value
+                ? { label, low: Math.min(value, to), high: Math.max(value, to), band: true, axisIndex }
+                : { label, low: value, high: value, band: false, axisIndex }];
+    });
+}
+// Each series as its share of its category's total: per category, the
+// denominator is the sum of every series' absolute value there, so the
+// magnitudes of a category's shares add up to 1. A mixed-sign category's
+// negative values take negative shares, drawn below zero. A missing value
+// stays missing, and a category whose total is zero has no shares. Shared by
+// the screen, the PDF and PowerPoint, so a 100% stack reads the same in each.
+export function percentShares(values) {
+    const length = Math.max(0, ...values.map((series) => series.length));
+    const totals = Array.from({ length }, (_, index) => values
+        .reduce((sum, series) => sum + Math.abs(series[index] ?? 0), 0));
+    return values.map((series) => series.map((value, index) => (value === null || !totals[index] ? null : value / totals[index])));
+}
+// The shares a 100% stacked chart draws in place of its values, or null when
+// the chart is not one. The primary axis's bar and area series take them,
+// each type's series sharing among themselves, as each type stacks apart.
+// Lines and secondary-axis series keep their values. A pie, a waterfall and a
+// colorBy chart (one series per category, each of which would be 100%) are
+// never 100% stacked, nor is a chart with no bar or area on its primary axis.
+export function percentStackedShares(extracted, config) {
+    const chartType = config.chartType ?? 'bar';
+    if (config.percentStacked !== true
+        || chartType === 'pie' || chartType === 'donut' || chartType === 'waterfall'
+        || isColorBy(config)) {
+        return null;
+    }
+    const types = seriesTypes(extracted, chartType);
+    const axisIndexes = seriesAxisIndexes(extracted, config);
+    const shares = new Map();
+    for (const type of ['bar', 'area']) {
+        const indexes = types
+            .map((seriesType, index) => (seriesType === type && axisIndexes[index] === 0 ? index : -1))
+            .filter((index) => index >= 0);
+        const typeShares = percentShares(indexes.map((index) => extracted.series[index].values));
+        indexes.forEach((seriesIndex, position) => shares.set(seriesIndex, typeShares[position]));
+    }
+    return shares.size ? shares : null;
+}
+// Where a 100% stacked chart's value axis starts: at -100% when any share is
+// negative, else at zero.
+export function percentAxisMin(shares) {
+    return [...shares.values()].some((series) => series.some((share) => (share ?? 0) < 0)) ? -1 : 0;
+}
+// The measures a chart plots: its configured ones, else the query's last
+// column, unformatted.
+function chartMeasures(config, data) {
+    return config.measures?.length
+        ? config.measures
+        : [{ column: data.columns[data.columns.length - 1] }];
+}
 // The type each extracted series is drawn as: its measure's own type when it
 // names one, the chart's chartType otherwise. More than one distinct type is a
 // combo chart. Shared with the PowerPoint export so both media draw each series
@@ -114,6 +374,17 @@ export function extractChartSeries(component, data) {
 export function seriesTypes(extracted, chartType) {
     return extracted.series.map((series) => series.type ?? chartType);
 }
+// The value axis each extracted series is plotted against: 1 when its measure
+// is secondary, 0 otherwise. A second axis is drawn only on a vertical chart
+// that keeps at least one series on the primary axis, so a combination the
+// server refuses (a horizontal chart, every measure secondary, the one measure
+// of a splitBy or colorBy chart) plots everything on the primary axis. Shared
+// with the PowerPoint export so both media put each series on the same axis.
+export function seriesAxisIndexes(extracted, config) {
+    const secondary = extracted.series.map((series) => !!series.measure.secondary);
+    const twoAxes = config.orientation !== 'horizontal' && secondary.includes(true) && secondary.includes(false);
+    return secondary.map((isSecondary) => (twoAxes && isSecondary ? 1 : 0));
+}
 export const WATERFALL_TOTAL_LABEL = 'Total';
 // A waterfall's bars from its one measure: each category's value is how far the
 // running total moves there, and a last Total bar shows where it ended. A
@@ -136,18 +407,24 @@ export function extractWaterfall(component, data) {
 // endpoint's rows to an ECharts option. Everything visual that isn't in the
 // registered 'report' theme is decided here, so report standards have exactly
 // two homes.
-export function buildChartOption(component, data) {
+//
+// Every number and period the chart writes (value-axis ticks, tooltip values,
+// period labels) is in the context's locale, never the browser's. A measure
+// with number-format keys formats its tooltips, and the value axis when every
+// measure on it agrees (axisNumberFormat); without them the axis and tooltips
+// keep the plain locale-grouped number.
+export function buildChartOption(component, data, context) {
     const config = component.config;
     const chartType = config.chartType ?? 'bar';
     if (chartType === 'pie' || chartType === 'donut') {
-        return buildPieOption(component, data, chartType === 'donut');
+        return buildPieOption(component, data, chartType === 'donut', context);
     }
     if (chartType === 'waterfall') {
-        return buildWaterfallOption(component, data);
+        return buildWaterfallOption(component, data, context);
     }
-    return buildAxisOption(component, data, chartType);
+    return buildAxisOption(component, data, chartType, context);
 }
-function buildAxisOption(component, data, chartType) {
+function buildAxisOption(component, data, chartType, context) {
     const config = component.config;
     const extracted = extractChartSeries(component, data);
     const horizontal = config.orientation === 'horizontal';
@@ -161,22 +438,707 @@ function buildAxisOption(component, data, chartType) {
     //
     // Stacking sums every series that shares a stack name, whatever its type. In
     // a combo each type stacks only with its own kind, so a line of a rate never
-    // sits on top of the bars' total.
-    const series = extracted.series.map((extractedSeries, index) => buildSeries(extractedSeries.name, extractedSeries.values, types[index], config.stacked ? (combo ? `total-${types[index]}` : 'total') : undefined, colorBy && index === 0, combo));
-    const categoryAxis = categoryAxisOption(config, data, extracted.categories, horizontal);
-    const valueAxis = { type: 'value' };
+    // sits on top of the bars' total, and on a two-axis chart only with the
+    // series on its own axis.
+    //
+    // A 100% stacked chart (percentStackedShares) plots its primary bars and
+    // areas as shares, each type in its own stack, and leaves every other series
+    // unstacked on its own values.
+    //
+    // What the server says of the numbers (chartAnnotations) marks them: a
+    // prior series dashed in its current series' color, the period not over yet
+    // hatched or dashed, ranks on an inverted axis, fractions on a percent axis,
+    // and the tooltip naming each prior's days and each window. Data without
+    // those keys draws exactly as before.
+    const axisIndexes = seriesAxisIndexes(extracted, config);
+    const twoAxes = axisIndexes.includes(1);
+    const shares = percentStackedShares(extracted, config);
+    const references = chartReferences(config, twoAxes);
+    const annotations = chartAnnotations(config, data, extracted, colorBy);
+    const axisFormats = valueAxisFormats(config, annotations ? annotatedAxisSeries(extracted, annotations) : extracted, axisIndexes, annotations && !shares ? annotatedAxisContexts(annotations, axisIndexes, context) : [context, context], !!shares, references);
+    const rankAxes = annotations && !shares ? rankAxisFlags(annotations.outputs, axisIndexes) : [false, false];
+    // A series' statistic line is taken over the points it plots. On a colorBy
+    // chart each series holds one bar, so the one line is taken over the bars
+    // together and hangs off the first series (colorByStatLine).
+    const statLines = drawsStatLines(config) && !colorBy;
+    const series = extracted.series.map((extractedSeries, index) => {
+        const seriesShares = shares?.get(index);
+        let stack;
+        if (seriesShares) {
+            stack = stackKey(types[index], combo, 0);
+        }
+        else if (config.stacked && !shares) {
+            stack = stackKey(types[index], combo, twoAxes ? axisIndexes[index] : undefined);
+        }
+        // An output series (a compared, windowed, ranked or shared value) writes
+        // its tooltip, data labels and statistic line by what it holds.
+        const write = annotations && !seriesShares && annotations.outputs[index]
+            ? outputWriter(annotations, index, extractedSeries.measure, context)
+            : null;
+        const stat = statLines ? measureMarkStat(extractedSeries.measure) : undefined;
+        const markLine = stat && statMarkLine(seriesShares ?? extractedSeries.values, stat, seriesShares ? shareWriter(context) : write ?? measureWriter(extractedSeries.measure, context));
+        const option = buildSeries(extractedSeries, seriesShares ? shareData(extractedSeries.values, seriesShares) : extractedSeries.values, {
+            type: types[index],
+            stack,
+            overlap: colorBy && index === 0,
+            combo,
+            tooltip: write ? { valueFormatter: write } : seriesTooltip(extractedSeries.measure, context),
+            axisIndex: twoAxes ? axisIndexes[index] : undefined,
+            // A colorBy chart's bars take the palette by category, as in
+            // PowerPoint, whatever color the measure names.
+            color: colorBy ? undefined : annotations?.colors?.[index] ?? seriesColor(extractedSeries),
+            labels: dataLabelOption(config.dataLabels, write
+                ? outputLabelFormatter(write)
+                : dataLabelFormatter(extractedSeries.measure, axisFormats[axisIndexes[index]] ?? null, !!seriesShares, context)),
+        });
+        const marked = annotations ? markSeries(option, annotations, index, extractedSeries.measure) : option;
+        return markLine ? { ...marked, markLine } : marked;
+    });
+    if (colorBy && drawsStatLines(config) && series.length) {
+        series[0] = colorByStatLine(series[0], extracted, context, annotations?.outputs[0]
+            ? outputWriter(annotations, 0, extracted.series[0].measure, context)
+            : undefined);
+    }
+    // Drawn after the measure series, so a tooltip reads a series by its index.
+    const segments = annotations ? partialSegments(series, annotations) : [];
+    const percentMin = shares ? percentAxisMin(shares) : undefined;
+    const categoryAxis = categoryAxisOption(config, data, extracted.categories, horizontal, context.locale);
+    // An axis of rate changes alone reads in percentage points, as its values do.
+    const axisLabels = [0, 1].map((axisIndex) => (annotations && !shares
+        ? pointsAxisLabel(annotations, extracted, axisIndexes, axisIndex, context)
+        : null) ?? valueAxisLabel(axisFormats[axisIndex] ?? null, context));
+    const valueAxis = twoAxes
+        ? twoValueAxesOption(config, axisLabels, context, percentMin, references, rankAxes)
+        : valueAxisOption(config.valueAxis, horizontal, percentMin === undefined
+            ? axisLabels[0]
+            : percentAxisLabel(context), { percentMin, reach: referenceReach(references, 0), rank: rankAxes[0] });
     const legendPosition = resolveLegendPosition(config, series.length, colorBy);
+    const valueTitles = [config.valueAxis, twoAxes ? config.secondaryAxis : undefined];
+    const granularity = bucketGranularity(data);
     return {
-        grid: axisGrid(legendPosition, categoryTitleSide(config, horizontal)),
-        legend: legendOption(legendPosition),
+        grid: axisGrid(legendPosition, categoryTitleSide(config, horizontal), valueTitleSide(valueTitles, horizontal)),
+        legend: referenceLegend(legendOption(legendPosition), series, references),
         // colorBy charts overlap N mostly-null series, so an axis tooltip would list
-        // every category; an item tooltip shows just the hovered bar.
-        tooltip: { trigger: colorBy ? 'item' : 'axis' },
+        // every category; an item tooltip shows just the hovered bar. A 100%
+        // stacked chart's tooltip gives each share and the value it came from. A
+        // chart with the server's annotations names what each value covers.
+        tooltip: shares
+            ? {
+                trigger: 'axis',
+                formatter: (params) => percentTooltip(params, extracted, shares, granularity, chartDateLabel(config), context),
+            }
+            : annotatedChartTooltip(annotations && !colorBy ? {
+                extracted,
+                annotations,
+                owners: segments.map((segment) => segment.owner),
+                granularity,
+                dateLabel: chartDateLabel(config),
+                context,
+            } : null) ?? { trigger: colorBy ? 'item' : 'axis' },
         xAxis: horizontal ? valueAxis : categoryAxis,
         yAxis: horizontal ? categoryAxis : valueAxis,
-        series,
+        series: [...series, ...segments.map((segment) => segment.series), ...referenceCarriers(references, extracted.categories)],
+    };
+}
+function chartAnnotations(config, data, extracted, colorBy) {
+    if (!data.comparison && !data.outputs && !data.windows && (data.partialPeriod ?? null) === null) {
+        return null;
+    }
+    const columns = extracted.series.map((series) => series.measure.column);
+    const outputs = columns.map((column) => data.outputs?.[column] ?? null);
+    const currents = columns.map((column, index) => (outputs[index] ? currentOutputAlias(data.outputs, column) : null));
+    const measures = chartMeasures(config, data);
+    // A prior series' current series, by index; -1 for any other.
+    const sources = currents.map((current, index) => (outputs[index]?.role === 'prior' ? columns.indexOf(current) : -1));
+    const partialIndex = (data.partialPeriod ?? null) === null ? -1 : extracted.categories.indexOf(String(data.partialPeriod));
+    const lanes = lanePriorValues(config, data, extracted, outputs);
+    return {
+        outputs,
+        windows: columns.map((column) => data.windows?.[column] ?? null),
+        measureSpecs: currents.map((current) => measures.find((measure) => measure.column === current)),
+        priors: lanes.map((lane, index) => (isDeltaRole(outputs[index]?.role) ? lane?.prior.values ?? null : null)),
+        lanePriors: lanes.map((lane) => (lane && !columns.includes(lane.alias) ? lane.prior : null)),
+        colors: colorBy ? null : annotatedColors(extracted, sources),
+        priorSeries: outputs.map((output) => output?.role === 'prior'),
+        comparison: data.comparison ?? null,
+        partialIndex: partialIndex < 0 ? null : partialIndex,
+    };
+}
+// A current, change or percent change series' lane prior, by category: its
+// lane's prior column in the same rows (the same group's on a splitBy chart),
+// and that column's alias.
+function lanePriorValues(config, data, extracted, outputs) {
+    const { xColumn, groupColumn } = chartColumns(config, data);
+    const rawCategories = uniqueValues(data.rows, xColumn);
+    const groups = groupColumn ? uniqueValues(data.rows, groupColumn) : [];
+    return extracted.series.map((series, index) => {
+        const role = outputs[index]?.role;
+        const alias = role === 'current' || isDeltaRole(role)
+            ? laneOutputAlias(data.outputs, series.measure.column, 'prior')
+            : null;
+        const output = alias ? data.outputs?.[alias] : undefined;
+        if (!alias || !output) {
+            return null;
+        }
+        const match = groupColumn ? (row) => row[groupColumn] === groups[index] : undefined;
+        return {
+            alias,
+            prior: {
+                key: groupColumn ? `${alias}\u0000${index}` : alias,
+                output,
+                values: categoryValues(data.rows, xColumn, rawCategories, alias, match),
+            },
+        };
+    });
+}
+function isDeltaRole(role) {
+    return role === 'change' || role === 'percent_change';
+}
+// Each series' color as the theme would hand it out: its measure's named
+// color, else the next palette color among the series without one. A prior
+// series that names no color takes its current series' color (sources) and
+// no palette color of its own.
+function annotatedColors(extracted, sources) {
+    let slot = 0;
+    const own = extracted.series.map((series, index) => {
+        const named = seriesColor(series);
+        if (named || sources[index] >= 0) {
+            return named ?? null;
+        }
+        return REPORT_CHART_COLORS_CSS[slot++ % REPORT_CHART_COLORS_CSS.length];
+    });
+    return own.map((color, index) => color ?? own[sources[index]]);
+}
+// A series' marks: a prior drawn in its current series' color family, dashed,
+// and the period not over yet hatched (a bar) or ringed (a point).
+function markSeries(option, annotations, index, measure) {
+    const prior = annotations.priorSeries[index] ? priorStyle(option, measure, annotations.colors?.[index]) : option;
+    return annotations.partialIndex === null ? prior : markPartialPoint(prior, annotations.partialIndex);
+}
+// A prior's bars are faded with a dashed edge; its line is dashed unless its
+// measure names a line style.
+function priorStyle(option, measure, color) {
+    const drawn = option;
+    if (drawn.type === 'bar') {
+        return {
+            ...option,
+            itemStyle: {
+                ...drawn.itemStyle,
+                opacity: PRIOR_BAR_OPACITY,
+                borderWidth: 1,
+                borderType: 'dashed',
+                ...(color ? { borderColor: color } : {}),
+            },
+        };
+    }
+    return { ...option, lineStyle: { ...drawn.lineStyle, type: measureLineStyle(measure) ?? PRIOR_LINE_STYLE } };
+}
+// The point of the period not over yet, when it has a value.
+function markPartialPoint(option, partialIndex) {
+    const drawn = option;
+    const data = [...(drawn.data ?? [])];
+    const item = data[partialIndex];
+    if (item === undefined || pointValue(item) === null) {
+        return option;
+    }
+    const mark = drawn.type === 'bar' ? { itemStyle: { decal: PARTIAL_BAR_DECAL } } : PARTIAL_POINT_MARK;
+    data[partialIndex] = (typeof item === 'object' ? { ...item, ...mark } : { value: item, ...mark });
+    return { ...option, data };
+}
+// A line or area series whose last period is not over yet draws its last
+// segment dashed: the series stops one point short, and a segment series
+// carries its last two points, dashed, in its color and under its name, so
+// the one legend entry toggles both. A stacked series keeps its line whole (a
+// segment would stack on top of it), and a gap stays a gap. Replaces each
+// such series in `series` and returns the segments.
+function partialSegments(series, annotations) {
+    const last = annotations.partialIndex;
+    const segments = [];
+    series.forEach((option, owner) => {
+        const drawn = option;
+        const data = drawn.data ?? [];
+        const color = annotations.colors?.[owner];
+        if (last === null || last < 1 || last !== data.length - 1 || drawn.type !== 'line' || drawn.stack || !color
+            || pointValue(data[last - 1]) === null || pointValue(data[last]) === null) {
+            return;
+        }
+        series[owner] = { ...option, data: [...data.slice(0, last), null] };
+        segments.push({ owner, series: segmentSeries(option, color, last) });
+    });
+    return segments;
+}
+// The dashed segment from the point before the last to the last one, which
+// keeps its marks and its data label. The point before it is drawn, and
+// labeled, by the series itself.
+function segmentSeries(option, color, last) {
+    const drawn = option;
+    const data = drawn.data ?? [];
+    return {
+        ...option,
+        markLine: undefined,
+        lineStyle: { ...drawn.lineStyle, color, type: PARTIAL_LINE_STYLE },
+        data: data.map((item, index) => {
+            if (index === last) {
+                return item;
+            }
+            return index === last - 1 ? { value: pointValue(item), symbol: 'none', label: { show: false } } : null;
+        }),
+    };
+}
+// A point's plotted value, whether it is a bare number or an object.
+function pointValue(item) {
+    if (item === null || item === undefined) {
+        return null;
+    }
+    return typeof item === 'number' ? item : item.value;
+}
+// How an output series writes a value: formatOutputValue's rules (a signed
+// change, points, '—' with the no-baseline title, ranks and shares) with its
+// measure's format and the comparison's floor. Given the point's index (a
+// tooltip, a data label), a change reads its prior there, which tells a
+// missing baseline from a zero one. The title says why a value reads '—' or
+// 'n/a'.
+function outputValue(annotations, index, measure, context) {
+    const output = annotations.outputs[index];
+    const priors = annotations.priors[index];
+    return (value, dataIndex) => formatOutputValue(Array.isArray(value) ? value[0] : value, output, measure, context, {
+        measureSpec: annotations.measureSpecs[index],
+        floor: annotations.comparison?.floor ?? null,
+        ...(priors && dataIndex !== undefined ? { prior: priors[dataIndex] ?? null } : {}),
+    });
+}
+// An output value's text alone, for a series' own tooltip and its data labels.
+function outputWriter(annotations, index, measure, context) {
+    const write = outputValue(annotations, index, measure, context);
+    return (value, dataIndex) => write(value, dataIndex).text;
+}
+function outputLabelFormatter(write) {
+    return (params) => write(dataLabelValue(params), params.dataIndex);
+}
+// The chart's series as its value axes read them: an output series whose
+// slot names no format takes its output's (outputAxisMeasure).
+function annotatedAxisSeries(extracted, annotations) {
+    return {
+        ...extracted,
+        series: extracted.series.map((series, index) => ({
+            ...series,
+            measure: outputAxisMeasure(series.measure, annotations.outputs[index], annotations.measureSpecs[index]),
+        })),
+    };
+}
+// The format an output's axis reads when its slot names none: a rank's whole
+// numbers, a 0-1 fraction's percent, and a compared or windowed value its
+// measure's format. The slot's own precision and units still apply.
+function outputAxisMeasure(measure, output, measureSpec) {
+    if (!output || namesValueFormat(measure)) {
+        return measure;
+    }
+    let base = measureSpec && hasNumberFormat(measureSpec) ? formatKeys(measureSpec) : null;
+    if (output.kind === 'rank') {
+        base = RANK_AXIS_FORMAT;
+    }
+    else if (isFractionOutput(output)) {
+        base = FRACTION_AXIS_FORMAT;
+    }
+    return base
+        ? { ...measure, ...base, ...formatKeys({ precision: measure.precision, units: measure.units }) }
+        : measure;
+}
+function namesValueFormat(spec) {
+    return Object.values(ReportValueFormat).some((format) => format === spec.format);
+}
+// A spec's number-format keys that are set.
+function formatKeys(spec) {
+    return {
+        ...((spec.format ?? null) !== null ? { format: spec.format } : {}),
+        ...((spec.precision ?? null) !== null ? { precision: spec.precision } : {}),
+        ...((spec.units ?? null) !== null ? { units: spec.units } : {}),
+    };
+}
+// Each value axis's context: one that plots only 0-1 fractions reads them as
+// ratios, whatever the report's percentFormat says of its stored values.
+function annotatedAxisContexts(annotations, axisIndexes, context) {
+    return [0, 1].map((axisIndex) => (everyOnAxis(annotations.outputs, axisIndexes, axisIndex, isFractionOutput)
+        ? { ...context, ratioPercent: true }
+        : context));
+}
+// Which value axes, by index, plot nothing but ranks.
+function rankAxisFlags(outputs, axisIndexes) {
+    return [0, 1].map((axisIndex) => everyOnAxis(outputs, axisIndexes, axisIndex, isRankPosition));
+}
+// How a chart that plots a prior series colors each series, for the
+// PowerPoint export: every series' color as bare hex, a prior taking its
+// current series' color and no palette color of its own (annotatedColors),
+// and which series are priors, which a line draws dashed. null when the chart
+// plots no prior series, and on a colorBy chart; its series keep seriesHex.
+export function priorSeriesStyles(config, data, extracted) {
+    const annotations = chartAnnotations(config, data, extracted, isColorBy(config));
+    if (!annotations?.colors || !annotations.priorSeries.some((prior) => prior)) {
+        return null;
+    }
+    return {
+        colors: annotations.colors.map((color) => color.replace('#', '')),
+        priors: annotations.priorSeries,
+    };
+}
+// Which value axes, by index, plot nothing but ranks, which the chart draws
+// inverted with rank 1 at the top. Shared with the PowerPoint export.
+export function rankValueAxes(extracted, data, config) {
+    return rankAxisFlags(extracted.series.map((series) => data.outputs?.[series.measure.column] ?? null), seriesAxisIndexes(extracted, config));
+}
+// Whether an axis has series and every one of them passes the test.
+function everyOnAxis(outputs, axisIndexes, axisIndex, test) {
+    const onAxis = outputs.filter((_, index) => axisIndexes[index] === axisIndex);
+    return onAxis.length > 0 && onAxis.every((output) => !!output && test(output));
+}
+// A share and a percent change are 0-1 fractions, whatever percentFormat says.
+function isFractionOutput(output) {
+    return output.kind === 'share' || output.role === 'percent_change';
+}
+// A value axis's tick labels when every series on it is a change of a rate
+// (a share's, or a percent-format value's): signed percentage points, as the
+// series' tooltips and data labels write them ('+5.0 pp'). null for any other
+// axis.
+function pointsAxisLabel(annotations, extracted, axisIndexes, axisIndex, context) {
+    const onAxis = extracted.series
+        .map((_, index) => index)
+        .filter((index) => axisIndexes[index] === axisIndex);
+    const points = onAxis.length > 0 && onAxis.every((index) => isPointsChange(annotations.outputs[index], outputAxisMeasure(extracted.series[index].measure, annotations.outputs[index], annotations.measureSpecs[index])));
+    if (!points) {
+        return null;
+    }
+    const write = outputWriter(annotations, onAxis[0], extracted.series[onAxis[0]].measure, context);
+    return { formatter: (value) => write(value) };
+}
+// A change of a rate, which prints in percentage points: a share's change, or
+// the change of a value whose format (its slot's, else its measure's) is a
+// percent.
+function isPointsChange(output, axisMeasure) {
+    return !!output && output.role === 'change' && output.kind !== 'rank'
+        && (output.kind === 'share' || axisMeasure.format === ReportValueFormat.Percent);
+}
+// A rank, current or prior; a rank change is a difference, not a position.
+function isRankPosition(output) {
+    return output.kind === 'rank' && output.role !== 'change';
+}
+function annotatedChartTooltip(source) {
+    return source
+        ? {
+            trigger: 'axis',
+            formatter: (params) => annotatedTooltip(params, source),
+        }
+        : null;
+}
+// The period, with 'to date' when it is not over yet, then each series shown
+// (a legend can hide some): its value written by what it is, and what it
+// covers. A partial segment speaks for its series. Names and values come from
+// the data and the config, and ECharts sets the tooltip as HTML, so both are
+// escaped.
+function annotatedTooltip(params, source) {
+    const items = Array.isArray(params) ? params : [params];
+    const dataIndex = items[0]?.dataIndex ?? 0;
+    const count = source.extracted.series.length;
+    const markers = new Map();
+    for (const item of items) {
+        const seriesIndex = item.seriesIndex ?? -1;
+        const owner = seriesIndex < count ? seriesIndex : source.owners[seriesIndex - count];
+        if (owner !== undefined && owner >= 0 && !markers.has(owner)) {
+            markers.set(owner, typeof item.marker === 'string' ? item.marker : '');
+        }
+    }
+    const namedPriors = new Set();
+    const lines = [...markers.entries()]
+        .sort(([first], [second]) => first - second)
+        .map(([index, marker]) => annotatedTooltipLine(source, index, dataIndex, marker, namedPriors));
+    return [annotatedTooltipHeading(source, dataIndex), ...lines].join('<br/>');
+}
+function annotatedTooltipHeading(source, dataIndex) {
+    const category = source.extracted.categories[dataIndex] ?? '';
+    const period = source.granularity
+        ? formatPeriodLabel(category, source.granularity, true, source.context.locale, source.dateLabel)
+        : category;
+    return escapeHtml(dataIndex === source.annotations.partialIndex ? `${period} (${PARTIAL_PERIOD_TEXT})` : period);
+}
+// '● Revenue (vs previous month): $813 · Aug 1 – 15, 2026', and why a value
+// reads '—' or 'n/a' when it does ('No baseline: no data before Jun 10, 2026').
+// A value compared with a prior the chart does not plot names that prior
+// once, on the first line shown that is compared with it: 'Rate % change (vs
+// previous month): -10% · vs 50% (Sep 1 – 2, 2026)'. namedPriors holds the
+// priors already named.
+function annotatedTooltipLine(source, index, dataIndex, marker, namedPriors) {
+    const series = source.extracted.series[index];
+    const value = series.values[dataIndex] ?? null;
+    const formatted = source.annotations.outputs[index]
+        ? outputValue(source.annotations, index, series.measure, source.context)(value, dataIndex)
+        : { text: seriesTooltip(series.measure, source.context).valueFormatter(value), title: null };
+    const lanePrior = source.annotations.lanePriors[index];
+    const compared = lanePrior && !namedPriors.has(lanePrior.key)
+        ? comparedPriorDetail(source, index, lanePrior, dataIndex)
+        : '';
+    if (lanePrior) {
+        namedPriors.add(lanePrior.key);
+    }
+    const parts = [formatted.text, seriesDetail(source, index, dataIndex), compared, formatted.title ?? ''];
+    return `${marker} ${escapeHtml(series.name)}: ${escapeHtml(parts.filter((part) => !!part).join(TOOLTIP_DETAIL_SEPARATOR))}`;
+}
+// The prior a value is compared with, when the chart does not plot it: its
+// value in its measure's format, and its days ('vs 50% (Sep 1 – 2, 2026)').
+// The measure's format is the current series' when the chart plots it, else
+// a change slot's own explicit format (a change is in its measure's units).
+function comparedPriorDetail(source, index, lanePrior, dataIndex) {
+    const annotations = source.annotations;
+    const measure = source.extracted.series[index].measure;
+    const measureSpec = annotations.measureSpecs[index]
+        ?? (annotations.outputs[index]?.role !== 'percent_change' && namesValueFormat(measure) ? measure : null);
+    const text = formatOutputValue(lanePrior.values[dataIndex] ?? null, lanePrior.output, null, source.context, {
+        measureSpec,
+        floor: annotations.comparison?.floor ?? null,
+    }).text;
+    const window = priorDetail(source, lanePrior.output, dataIndex);
+    return window ? `${COMPARED_PRIOR_PREFIX} ${text} (${window})` : `${COMPARED_PRIOR_PREFIX} ${text}`;
+}
+// What a series' value covers, when the server says: a prior's days, or a
+// windowed value's window ('Rolling 3-month total'), whose days the note
+// under the chart names.
+function seriesDetail(source, index, dataIndex) {
+    const output = source.annotations.outputs[index];
+    const window = source.annotations.windows[index];
+    if (output?.role === 'prior') {
+        return priorDetail(source, output, dataIndex);
+    }
+    return window ? windowText({ ...window, start: null, end: null }, source.context.locale, source.granularity) : '';
+}
+// A prior value's days. A range comparison compares every point with the
+// same window. A series comparison compares each period with the period its
+// lane's offset back; an as_of comparison reads the value at the end of that
+// period ('on Aug 31, 2026').
+function priorDetail(source, output, dataIndex) {
+    const comparison = source.annotations.comparison;
+    const lane = (output.offset ?? 1) - 1;
+    const offset = comparison?.offsets?.[lane];
+    const locale = source.context.locale;
+    if (!comparison || !offset) {
+        return '';
+    }
+    if (comparison.mode === 'range' || !source.granularity) {
+        const prior = comparison.priors?.[lane];
+        return prior ? formatDayWindow(prior, comparison.timezone, locale) : '';
+    }
+    const partial = dataIndex === source.annotations.partialIndex && comparison.align === 'to_date';
+    const today = partial ? zoneToday(comparison.timezone) : null;
+    const window = priorPeriodWindow(source.extracted.categories[dataIndex] ?? '', source.granularity, offset, today);
+    if (!window) {
+        return '';
+    }
+    return comparison.mode === 'as_of'
+        ? `on ${formatDayRange(window.end, window.end, locale)}`
+        : formatDayWindow({ ...window, through: partial ? comparison.current?.through ?? null : null }, comparison.timezone, locale);
+}
+// The days one period of the axis is compared with: the period moved back by
+// the lane's offset. A period not over yet, compared to date, runs only to
+// today moved back (priorToDateEnd). null for a category that is not a day,
+// or an offset without a unit (a custom range).
+function priorPeriodWindow(category, granularity, offset, today) {
+    const start = parseISO(category);
+    const unit = offset.unit;
+    const count = offset.count;
+    if (!isValid(start) || !unit || !count) {
+        return null;
+    }
+    const back = (date) => addPeriods(date, unit, -count);
+    const fullEnd = addDays(back(addPeriods(start, granularity, 1)), -1);
+    const end = today ? earliestOf([fullEnd, priorToDateEnd(today, start, back, unit)]) : fullEnd;
+    return { start: calendarDay(back(start)), end: calendarDay(latestOf([end, back(start)])) };
+}
+// Today, kept inside the period, moved back by the offset; when today is the
+// last day of its month, the last day of the month it lands in (the
+// server's end-of-month rule: Sep 30 compares with Aug 31, not Aug 30).
+function priorToDateEnd(today, periodStart, back, unit) {
+    const day = latestOf([startOfDay(today), periodStart]);
+    const moved = back(day);
+    return isLastDayOfMonth(day) && unit !== 'day' && unit !== 'week' ? endOfMonth(moved) : moved;
+}
+function addPeriods(date, unit, count) {
+    switch (unit) {
+        case 'day':
+            return addDays(date, count);
+        case 'week':
+            return addWeeks(date, count);
+        case 'quarter':
+            return addQuarters(date, count);
+        case 'year':
+            return addYears(date, count);
+        default:
+            return addMonths(date, count);
+    }
+}
+function calendarDay(date) {
+    return formatISO(date, { representation: 'date' });
+}
+// Today's calendar day in the report's zone, as local midnight. The server
+// marks which period holds today (partialPeriod) but not the day itself; the
+// prior of that period is clipped at the same day. An unknown zone reads the
+// browser's own day.
+function zoneToday(timezone) {
+    try {
+        const parts = dateFormat('en-US', { year: 'numeric', month: 'numeric', day: 'numeric' }, timezone)
+            .formatToParts(new Date());
+        const part = (type) => Number(parts.find((found) => found.type === type)?.value);
+        const today = new Date(part('year'), part('month') - 1, part('day'));
+        if (isValid(today)) {
+            return today;
+        }
+    }
+    catch {
+        // An unknown zone: the browser's day below.
+    }
+    return startOfDay(new Date());
+}
+// A colorBy chart's statistic line: one line over every bar, hung off the
+// first series and drawn in the reference slate, as no one category's color
+// speaks for the others.
+function colorByStatLine(first, extracted, context, write) {
+    const measure = extracted.series[0]?.measure;
+    const stat = measureMarkStat(measure);
+    const markLine = stat && statMarkLine(colorByValues(extracted), stat, write ?? measureWriter(measure, context), `#${REPORT_REFERENCE_COLOR}`);
+    return markLine ? { ...first, markLine } : first;
+}
+// A series' statistic line across the plot, labeled with the statistic and
+// its value ('Average: 1,234.5'), or undefined when no point has a value. It
+// takes the series' color unless it is given one.
+function statMarkLine(values, stat, write, color) {
+    const value = seriesStat(values, stat);
+    if (value === null) {
+        return undefined;
+    }
+    const text = `${STAT_LABEL[stat]}: ${write(value)}`;
+    return {
+        silent: true,
+        symbol: 'none',
+        lineStyle: { type: 'dashed', width: 1, ...(color ? { color } : {}) },
+        label: { formatter: () => text, position: 'insideEndTop', fontSize: REPORT_DATA_LABEL_FONT_SIZE, ...MARK_LABEL_BOX },
+        data: [{ yAxis: value }],
     };
 }
+// A statistic's value in its measure's number format, in the report locale.
+function measureWriter(measure, context) {
+    return (value) => formatNumber(value, measure, context);
+}
+// A 100% stacked series' statistic is a share, written as its tooltip writes
+// one.
+function shareWriter(context) {
+    const ratioContext = { ...context, ratioPercent: true };
+    return (value) => formatNumber(value, PERCENT_SHARE_FORMAT, ratioContext);
+}
+// The series that carry a chart's references, one per value axis that has
+// any: an empty line (every point null, so it draws nothing and stretches no
+// axis) whose markLine draws the reference lines and whose markArea fills the
+// bands. It is silent, left out of the tooltip and, by referenceLegend, out of
+// the legend. It has no name, so no measure series' legend entry (whatever its
+// name, '' included) toggles it.
+//
+// Labels are functions, as a string formatter is a template that would read
+// '{b}' or '{c}' in a label as a placeholder. ECharts draws a markArea under
+// the bars and a markLine over them, so a band's label rides an invisible
+// markLine on its upper edge, inside its top left corner, where the first bar
+// would otherwise cover it.
+function referenceCarriers(references, categories) {
+    const color = `#${REPORT_REFERENCE_COLOR}`;
+    return [0, 1].flatMap((axisIndex) => {
+        const onAxis = references.filter((reference) => reference.axisIndex === axisIndex);
+        const lines = onAxis.filter((reference) => !reference.band);
+        const bands = onAxis.filter((reference) => reference.band);
+        if (!onAxis.length) {
+            return [];
+        }
+        return [{
+                type: 'line',
+                data: categories.map(() => null),
+                yAxisIndex: axisIndex,
+                silent: true,
+                tooltip: { show: false },
+                markLine: {
+                    silent: true,
+                    symbol: 'none',
+                    lineStyle: { color, type: 'dashed', width: 1 },
+                    label: { position: 'insideEndTop', color, fontSize: REPORT_DATA_LABEL_FONT_SIZE, ...MARK_LABEL_BOX },
+                    data: [
+                        ...lines.map((reference) => ({ yAxis: reference.low, label: { formatter: () => reference.label } })),
+                        ...bands.map((reference) => ({
+                            yAxis: reference.high,
+                            // Zero width, not zero opacity: a markLine's label takes the
+                            // line's opacity.
+                            lineStyle: { width: 0 },
+                            label: { position: 'insideStartBottom', formatter: () => reference.label },
+                        })),
+                    ],
+                },
+                ...(bands.length ? {
+                    markArea: {
+                        silent: true,
+                        itemStyle: { color: REFERENCE_BAND_FILL },
+                        data: bands.map((reference) => [{ yAxis: reference.low }, { yAxis: reference.high }]),
+                    },
+                } : {}),
+            }];
+    });
+}
+// The largest magnitude a value axis's references reach, which its number
+// format counts toward its peak, as the axis stretches to them; 0 when it
+// has none.
+export function referencePeak(references, axisIndex) {
+    const reach = referenceReach(references, axisIndex);
+    return reach ? Math.max(Math.abs(reach.low), Math.abs(reach.high)) : 0;
+}
+// The legend of a chart with references names its measure series alone, so
+// a carrier never shows as a blank entry. Without references it is left as it
+// was.
+function referenceLegend(legend, series, references) {
+    return references.length
+        ? { ...legend, data: series.map((item) => String(item.name ?? '')) }
+        : legend;
+}
+// The span of the references on one value axis, or undefined when it has
+// none.
+function referenceReach(references, axisIndex) {
+    const onAxis = references.filter((reference) => reference.axisIndex === axisIndex);
+    return onAxis.length
+        ? { low: Math.min(...onAxis.map((reference) => reference.low)), high: Math.max(...onAxis.map((reference) => reference.high)) }
+        : undefined;
+}
+// ECharts leaves a markLine or markArea out of an axis's extent, so a
+// reference beyond the data would fall off the plot. An axis bound the config
+// does not pin reaches past the furthest reference, to a round number with
+// room for its label (beyondReference), when the data (and the zero a value
+// axis always shows) falls short of it, and is left to ECharts otherwise: a
+// callback returning undefined keeps the bound automatic. Past the data and
+// zero, a reference beyond the max is above zero and one beyond the min below
+// it.
+function reachMin(reach) {
+    return reach
+        ? (extent) => (reach.low < Math.min(extent.min, 0) ? -beyondReference(-reach.low) : undefined)
+        : undefined;
+}
+function reachMax(reach) {
+    return reach
+        ? (extent) => (reach.high > Math.max(extent.max, 0) ? beyondReference(reach.high) : undefined)
+        : undefined;
+}
+// The bound an axis takes past a reference of this (positive) magnitude: the
+// smallest round number at or above it plus REFERENCE_HEADROOM. The steps are
+// finer than ECharts' tick steps, so a reference just past the data does not
+// double the axis (110 gives 120, not 200). The tolerance keeps a float error
+// from skipping a round number the value already is.
+const NICE_STEPS = [1, 1.2, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10];
+const NICE_TOLERANCE = 1e-9;
+function beyondReference(magnitude) {
+    const target = magnitude * REFERENCE_HEADROOM;
+    const power = Math.pow(10, Math.floor(Math.log10(target)));
+    const step = NICE_STEPS.find((candidate) => candidate * power >= target * (1 - NICE_TOLERANCE)) ?? 10;
+    // Rounded back to the power's own digits, so 1.2 x 0.1 reads 0.12, not
+    // 0.12000000000000001.
+    return Number((step * power).toPrecision(12));
+}
 // The category axis of an axis chart or a waterfall: the categories in row
 // order, labeled as periods when the rows were bucketed by time.
 //
@@ -184,30 +1146,46 @@ function buildAxisOption(component, data, chartType) {
 // axis is inverted to put the first row (the largest of a top-N, a waterfall's
 // first step) at the top. The rotated title sits just beyond the longest label
 // rather than at a fixed gap that would put it on top of the labels.
-function categoryAxisOption(config, data, categories, horizontal) {
+//
+// A bucketed axis also names its period in the axis tooltip's header: ECharts
+// heads it with the raw category ('2026-01-01') unless the axis pointer's label
+// has a formatter, so it reads 'January 2026' instead, always with its year.
+// The axis's dateLabel style writes both its tick labels and that header.
+function categoryAxisOption(config, data, categories, horizontal, locale) {
     const granularity = bucketGranularity(data);
-    const periodLabel = periodAxisLabel(granularity, categories);
+    const dateLabel = chartDateLabel(config);
+    const periodLabel = periodAxisLabel(granularity, categories, locale, dateLabel);
     const axis = {
         type: 'category',
         data: categories,
         inverse: horizontal,
         name: config.xAxis?.label,
         nameLocation: 'middle',
+        ...(granularity ? {
+            axisPointer: {
+                label: {
+                    formatter: (params) => formatPeriodLabel(String(params.value), granularity, true, locale, dateLabel),
+                },
+            },
+        } : {}),
     };
     if (!horizontal) {
+        // The gap clears the year's second line when the labels print one.
+        const secondLine = granularity && dateLabel === ReportChartDateLabel.Short && spansMultipleYears(categories);
         return {
             ...axis,
-            nameGap: granularity && spansMultipleYears(categories) ? 40 : 28,
+            nameGap: secondLine ? 40 : 28,
             ...periodLabel,
         };
     }
-    // A period label ('May', 'Q2') is always short, so only a plain category is
-    // cut short. The labels are cut here rather than by ECharts' own truncation,
-    // so the title's gap is measured on exactly the text the axis draws.
+    // Period labels, short, long or numeric ('May', 'Q2', 'May 2026'), are
+    // bounded in length and never cut; only a plain category is truncated. The labels are cut here rather than by ECharts' own
+    // truncation, so the title's gap is measured on exactly the text the axis
+    // draws.
     const shown = granularity
         ? null
         : new Map(categories.map((category) => [category, truncateAxisLabel(category)]));
-    const labels = shown ? [...shown.values()] : displayedCategoryLabels(categories, granularity);
+    const labels = shown ? [...shown.values()] : displayedCategoryLabels(categories, granularity, locale, dateLabel);
     return {
         ...axis,
         nameGap: widestAxisLabel(labels) + AXIS_LABEL_MARGIN + AXIS_NAME_CLEARANCE,
@@ -222,12 +1200,22 @@ function categoryTitleSide(config, horizontal) {
     }
     return horizontal ? 'left' : 'bottom';
 }
+// The value axes' title side, or null when none of them has a title. A
+// vertical chart's titles sit above the plot, at the top of each axis line, so
+// room is made once for both; a horizontal chart's sits below.
+function valueTitleSide(axes, horizontal) {
+    if (!axes.some((axis) => axis?.label)) {
+        return null;
+    }
+    return horizontal ? 'bottom' : 'top';
+}
 // The tick labels as the axis shows them: a bucket's primary period label
-// ('May', 'Q2'), otherwise the category itself. The year a multi-year axis
-// prints under a period is left out, as it is never the wider line.
-function displayedCategoryLabels(categories, granularity) {
+// ('May', 'Q2', 'May 2026'), otherwise the category itself. The year a
+// multi-year axis prints under a short period is left out, as it is never the
+// wider line.
+function displayedCategoryLabels(categories, granularity, locale, dateLabel) {
     return granularity
-        ? categories.map((category) => periodLabelParts(category, granularity)?.primary ?? category)
+        ? categories.map((category) => periodLabelParts(category, granularity, locale, dateLabel)?.primary ?? category)
         : categories;
 }
 // The pixel width of the widest label. A label that breaks over several lines
@@ -273,26 +1261,32 @@ function axisLabelWidth(line) {
     axisLabelContext.font = AXIS_LABEL_FONT;
     return axisLabelContext.measureText(line).width;
 }
-function buildWaterfallOption(component, data) {
+function buildWaterfallOption(component, data, context) {
     const config = component.config;
     const waterfall = extractWaterfall(component, data);
     const horizontal = config.orientation === 'horizontal';
-    const categoryAxis = categoryAxisOption(config, data, waterfall.steps.map((step) => step.category), horizontal);
-    const valueAxis = { type: 'value' };
+    const categories = waterfall.steps.map((step) => step.category);
+    const categoryAxis = categoryAxisOption(config, data, categories, horizontal, context.locale);
+    // The one measure's format writes the axis and the tooltip. The axis has to
+    // reach the furthest point the running total gets to, on either side of
+    // zero, or the furthest reference.
+    const spec = config.measures?.[0];
+    const references = chartReferences(config, false);
+    const valueAxis = valueAxisOption(config.valueAxis, horizontal, valueAxisLabel(resolveValueAxisFormat(spec && hasNumberFormat(spec) ? spec : null, () => Math.max(referencePeak(references, 0), ...waterfall.steps.map((step) => Math.abs(step.start + (step.change ?? 0)))), context), context), { reach: referenceReach(references, 0) });
     // One visible series, so the legend is hidden unless the config pins it.
     const legendPosition = resolveLegendPosition(config, 1);
     const granularity = bucketGranularity(data);
     return {
-        grid: axisGrid(legendPosition, categoryTitleSide(config, horizontal)),
+        grid: axisGrid(legendPosition, categoryTitleSide(config, horizontal), valueTitleSide([config.valueAxis], horizontal)),
         legend: { ...legendOption(legendPosition), data: [waterfall.name] },
         // Per bar: the invisible base is silent, so only a step answers the hover.
         tooltip: {
             trigger: 'item',
-            formatter: (params) => waterfallTooltip(waterfall, (Array.isArray(params) ? params[0] : params).dataIndex, granularity),
+            formatter: (params) => waterfallTooltip(waterfall, (Array.isArray(params) ? params[0] : params).dataIndex, granularity, chartDateLabel(config), spec, context),
         },
         xAxis: horizontal ? valueAxis : categoryAxis,
         yAxis: horizontal ? categoryAxis : valueAxis,
-        series: waterfallSeries(waterfall),
+        series: [...waterfallSeries(waterfall), ...referenceCarriers(references, categories)],
     };
 }
 // An invisible base series lifts each visible bar to where its step starts.
@@ -329,17 +1323,22 @@ function waterfallSeries(waterfall) {
 // A step's tooltip: its period, how far it moved the running total and where
 // that left it. The closing Total shows the total alone. The category and the
 // measure name come from the data and the config, and ECharts sets the tooltip
-// as HTML, so both are escaped.
-function waterfallTooltip(waterfall, index, granularity) {
+// as HTML, so both are escaped. Periods and amounts are written in the report's
+// locale, amounts in the measure's number format (a plain number without one);
+// the words ('Running total') stay English.
+function waterfallTooltip(waterfall, index, granularity, dateLabel, spec, context) {
     const step = waterfall.steps[index];
-    const category = escapeHtml(granularity ? formatPeriodLabel(step.category, granularity, true) : step.category);
+    const category = escapeHtml(granularity
+        ? formatPeriodLabel(step.category, granularity, true, context.locale, dateLabel)
+        : step.category);
     const name = escapeHtml(waterfall.name);
+    const amount = (value) => formatNumber(value, spec ?? {}, context);
     if (step.kind === 'total') {
-        return `${category}<br/>${name}: ${formatMeasureValue(step.change)}`;
+        return `${category}<br/>${name}: ${amount(step.change)}`;
     }
     const sign = (step.change ?? 0) > 0 ? '+' : '';
-    return `${category}<br/>${name}: ${sign}${formatMeasureValue(step.change)}`
-        + `<br/>Running total: ${formatMeasureValue(step.start + (step.change ?? 0))}`;
+    return `${category}<br/>${name}: ${sign}${amount(step.change)}`
+        + `<br/>Running total: ${amount(step.start + (step.change ?? 0))}`;
 }
 // Default legend placement when the config doesn't pin one: pie charts read
 // best with the slice key beside them (right); axis charts only need a legend
@@ -372,18 +1371,10 @@ function legendOption(position) {
     }
 }
 // The plot's grid: room on the legend's side so it never overlaps the
-// bars/lines, plus room for the category axis's title on its side, which
-// containLabel does not reserve (it covers the tick labels only).
-function axisGrid(position, titleSide) {
-    const grid = legendGrid(position);
-    switch (titleSide) {
-        case 'bottom':
-            return { ...grid, bottom: grid.bottom + AXIS_NAME_ROOM };
-        case 'left':
-            return { ...grid, left: grid.left + AXIS_NAME_ROOM };
-        default:
-            return grid;
-    }
+// bars/lines, plus room for the category and value axes' titles on their
+// sides, which containLabel does not reserve (it covers the tick labels only).
+function axisGrid(position, categoryTitle, valueTitle) {
+    return [categoryTitle, valueTitle].reduce((grid, side) => (side ? { ...grid, [side]: grid[side] + AXIS_NAME_ROOM } : grid), legendGrid(position));
 }
 // Plot-edge room on whichever side the legend occupies; containLabel keeps the
 // tick labels inside what is left.
@@ -402,32 +1393,317 @@ function legendGrid(position) {
             return { ...base, top: 32 };
     }
 }
-function buildSeries(name, values, type, stack, overlap, combo) {
-    if (type === 'bar') {
+// The stack a stacked series joins. On a two-axis chart (axisIndex set) each
+// type stacks per axis; otherwise a combo stacks per type and a single-type
+// chart stacks everything together.
+function stackKey(type, combo, axisIndex) {
+    if (axisIndex !== undefined) {
+        return `total-${type}-${axisIndex}`;
+    }
+    return combo ? `total-${type}` : 'total';
+}
+// One series of an axis chart. A measure's display keys only add what they
+// change, so a series that sets none is drawn by the theme as before: its own
+// color (the bar, the line, the area under it and its legend key all follow
+// itemStyle), its line style and its markers, shown on every point unless
+// markers is false. Data labels come last, on the series or on its latest
+// point.
+function buildSeries(series, values, layout) {
+    // On a two-axis chart every series names its value axis.
+    const axis = layout.axisIndex === undefined ? {} : { yAxisIndex: layout.axisIndex };
+    const color = layout.color;
+    const itemStyle = color ? { itemStyle: { color } } : {};
+    if (layout.type === 'bar') {
+        // 'outside' follows each bar's sign: past a positive bar's end and below
+        // (or left of) a negative one's, where 'top' would sit at the zero line.
+        const { series: labels, data } = placeDataLabels(layout.labels, layout.stack ? 'inside' : 'outside', values);
         return {
-            name,
+            name: series.name,
             type: 'bar',
-            data: values,
-            stack,
+            data,
+            stack: layout.stack,
+            tooltip: layout.tooltip,
+            ...axis,
+            ...itemStyle,
             barMaxWidth: 48,
             // colorBy: overlap the per-category series so each bar renders full-width.
-            ...(overlap ? { barGap: '-100%', barCategoryGap: '20%' } : {}),
+            ...(layout.overlap ? { barGap: '-100%', barCategoryGap: '20%' } : {}),
+            ...labels,
         };
     }
+    const lineType = measureLineStyle(series.measure);
+    const lineStyle = color || lineType
+        ? { lineStyle: { ...(color ? { color } : {}), ...(lineType ? { type: lineType } : {}) } }
+        : {};
+    const { series: labels, data } = placeDataLabels(layout.labels, 'top', values);
     return {
-        name,
+        name: series.name,
         type: 'line',
-        data: values,
-        stack,
+        data,
+        stack: layout.stack,
+        tooltip: layout.tooltip,
+        ...axis,
+        ...itemStyle,
+        ...lineStyle,
+        ...(series.measure.markers === false ? { showSymbol: false } : {}),
         smooth: true,
         symbolSize: 6,
-        areaStyle: type === 'area' ? { opacity: 0.25 } : undefined,
+        areaStyle: layout.type === 'area' ? { opacity: 0.25 } : undefined,
         // In a combo the line is drawn over the bars whatever order the measures
         // come in; at the same z a later bar series would paint across it.
-        ...(combo ? { z: 3 } : {}),
+        ...(layout.combo ? { z: 3 } : {}),
+        ...labels,
+    };
+}
+// A 100% stacked series' points: each share, plotted and stacked, with the
+// value it came from.
+function shareData(values, shares) {
+    return values.map((raw, index) => ({ value: shares[index] ?? null, raw }));
+}
+// What a series prints beside its points (A2 data labels): every point
+// ('all'), every point whose label fits without overlapping another ('auto',
+// LabelLayout's hideOverlap), or only its latest point ('last'). none, an
+// absent mode or one the viewer does not know prints nothing, and the series
+// is left as it was. A colorBy chart's series each hold one bar, so 'last'
+// labels every bar there, as 'all' does.
+//
+// Where the label sits depends on what the series draws, so buildSeries
+// places it (placeDataLabels).
+export function dataLabelOption(mode, formatter) {
+    const text = { show: true, fontSize: REPORT_DATA_LABEL_FONT_SIZE, formatter };
+    switch (mode) {
+        case ReportChartDataLabels.All:
+            return { text, hideOverlap: false, lastOnly: false };
+        case ReportChartDataLabels.Auto:
+            return { text, hideOverlap: true, lastOnly: false };
+        case ReportChartDataLabels.Last:
+            return { text, hideOverlap: false, lastOnly: true };
+        default:
+            return null;
+    }
+}
+// A series' data labels at `position`: on the series ('all', and with the
+// overlap hiding 'auto'), or on its latest non-empty point alone ('last').
+// No labels leave the series and its points as they were.
+function placeDataLabels(labels, position, values) {
+    if (!labels) {
+        return { series: {}, data: values };
+    }
+    const label = { ...labels.text, position };
+    if (labels.lastOnly) {
+        return { series: {}, data: labelLastPoint(values, label) };
+    }
+    return {
+        series: { label, ...(labels.hideOverlap ? { labelLayout: { hideOverlap: true } } : {}) },
+        data: values,
+    };
+}
+// A series' points with its latest non-empty point carrying the label. A
+// series with no value anywhere is left as it was.
+function labelLastPoint(values, label) {
+    const last = values.reduce((found, item, index) => (pointValue(item) === null ? found : index), -1);
+    return values.map((item, index) => {
+        if (index !== last) {
+            return item;
+        }
+        return isShareDataItem(item) ? { ...item, label } : { value: item, label };
+    });
+}
+function isShareDataItem(item) {
+    return item !== null && typeof item === 'object';
+}
+// How a series' data labels write a value. A 100% stacked series prints its
+// share as a whole percentage, as the share axis's ticks do. A series on an
+// axis with a number format prints its value in its measure's format, at the
+// units and decimals the axis decided, so a label reads like the ticks beside
+// it. Any other prints the plain locale-grouped number its tooltip shows. A
+// share point's raw value is what a label reads when it carries one.
+function dataLabelFormatter(measure, axisFormat, share, context) {
+    if (share) {
+        const percent = wholePercentFormatter(context);
+        return (params) => percent(params.value);
+    }
+    if (axisFormat) {
+        const options = { units: axisFormat.chart.units, decimals: axisFormat.chart.decimals };
+        return (params) => formatNumber(dataLabelValue(params), measure, context, options);
+    }
+    return (params) => formatPlainNumber(dataLabelValue(params), context.locale);
+}
+// The value a data label writes: the raw value its point carries, else the
+// plotted one.
+function dataLabelValue(params) {
+    const data = params.data;
+    const raw = data !== null && typeof data === 'object' ? data.raw : undefined;
+    return raw ?? params.value;
+}
+// A 100% stacked chart's tooltip: the category, then each series on its own
+// line, a share as its percentage to one decimal followed by the value it came
+// from in its measure's format ('25.0% (1)'), and any other series by its own
+// value. The category and the series names come from the data and the config,
+// and ECharts sets the tooltip as HTML, so both are escaped.
+function percentTooltip(params, extracted, shares, granularity, dateLabel, context) {
+    const items = Array.isArray(params) ? params : [params];
+    const dataIndex = items[0]?.dataIndex ?? 0;
+    const category = extracted.categories[dataIndex] ?? '';
+    const heading = escapeHtml(granularity
+        ? formatPeriodLabel(category, granularity, true, context.locale, dateLabel)
+        : category);
+    const ratioContext = { ...context, ratioPercent: true };
+    const lines = items.map((item) => {
+        const series = extracted.series[item.seriesIndex ?? -1];
+        const marker = typeof item.marker === 'string' ? item.marker : '';
+        const label = `${marker} ${escapeHtml(item.seriesName ?? series?.name ?? '')}`;
+        const value = seriesTooltip(series?.measure, context).valueFormatter(series?.values[item.dataIndex] ?? null);
+        const share = shares.get(item.seriesIndex ?? -1)?.[item.dataIndex] ?? null;
+        return share === null
+            ? `${label}: ${value}`
+            : `${label}: ${formatNumber(share, PERCENT_SHARE_FORMAT, ratioContext)} (${value})`;
+    });
+    return [heading, ...lines].join('<br/>');
+}
+// A value axis: its title and range from the config, its tick labels from
+// valueAxisLabel. A vertical chart's title sits above the axis line, reading
+// away from the plot's edge; a horizontal chart's is centered below the ticks.
+// A bound or interval that is not a usable number is left to ECharts. A 100%
+// stacked chart's share axis (extras.percentMin) has its own fixed range.
+function valueAxisOption(axis, horizontal, axisLabel, extras = {}) {
+    const range = extras.percentMin === undefined
+        ? valueAxisRange(axis)
+        : { min: extras.percentMin, max: PERCENT_AXIS_MAX, interval: PERCENT_AXIS_INTERVAL };
+    return {
+        type: 'value',
+        name: axis?.label || undefined,
+        nameLocation: horizontal ? 'middle' : 'end',
+        nameGap: horizontal ? 28 : 10,
+        nameTextStyle: horizontal ? undefined : { align: extras.index === 1 ? 'right' : 'left' },
+        // A pinned bound wins; one left open reaches the references (reachMin),
+        // or on a rank axis starts at rank 1.
+        min: range.min ?? (extras.rank ? RANK_AXIS_MIN : reachMin(extras.reach)),
+        max: range.max ?? reachMax(extras.reach),
+        interval: range.interval,
+        axisLabel,
+        ...(extras.rank ? { inverse: true, minInterval: 1 } : {}),
+    };
+}
+// The part of a value axis's range the config pins. A bound that is not a
+// finite number, or an interval that is not a positive one, is left out, and
+// the chart picks it from the data. Shared with the PowerPoint export so both
+// media draw the same range.
+export function valueAxisRange(axis) {
+    const interval = axisNumber(axis?.interval);
+    return {
+        min: axisNumber(axis?.min),
+        max: axisNumber(axis?.max),
+        interval: interval !== undefined && interval > 0 ? interval : undefined,
+    };
+}
+// A two-axis chart's value axes: the primary on the left, the second on the
+// right without gridlines of its own. Each axis's ticks take the format of the
+// measures plotted against it (axisLabels). Without a range on either axis the
+// second axis aligns its ticks to the primary's gridlines.
+//
+// On a 100% stacked chart (percentMin set) the primary axis is the share axis,
+// whose range is fixed, and the second axis's series are not stacked. An axis
+// of ranks alone (rankAxes) is inverted, and the axes then keep their own
+// ticks, so a rank axis steps by whole ranks.
+function twoValueAxesOption(config, axisLabels, context, percentMin, references, rankAxes) {
+    const percent = percentMin !== undefined;
+    const label = (axisIndex) => axisLabels[axisIndex];
+    return [
+        valueAxisOption(config.valueAxis, false, percent ? percentAxisLabel(context) : label(0), {
+            index: 0,
+            percentMin,
+            reach: referenceReach(references, 0),
+            rank: rankAxes[0],
+        }),
+        {
+            ...valueAxisOption(config.secondaryAxis, false, label(1), {
+                index: 1,
+                reach: referenceReach(references, 1),
+                rank: rankAxes[1],
+            }),
+            position: 'right',
+            splitLine: { show: false },
+            alignTicks: !percent && !rankAxes[0] && !rankAxes[1]
+                && !hasAxisRange(config.valueAxis) && !hasAxisRange(config.secondaryAxis),
+        },
+    ];
+}
+// Whether the config pins any of an axis's range: a bound or a tick interval.
+function hasAxisRange(axis) {
+    return Object.values(valueAxisRange(axis)).some((value) => value !== undefined);
+}
+// A configured bound or interval when it is a finite number, else undefined.
+function axisNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+// Tick labels written in the locale. ECharts' own ticks are grouped en-US
+// whatever the page's language.
+//
+// With a number format, the units and decimals decided once for the whole
+// axis (resolveValueAxisFormat) write every tick alike ('1.5K', '2.0K', never
+// '2K'). Without one, or when it leaves the ticks an unscaled number with no
+// pinned decimals (format 'number', or precision-less units none), each tick
+// is a plain locale-grouped number keeping its own decimals, so a 0.0002 tick
+// never rounds to '0'.
+function valueAxisLabel(format, context) {
+    if (!format || (format.chart.units === ReportNumberUnits.None && format.chart.decimals === null)) {
+        return { formatter: (value) => formatPlainNumber(value, context.locale) };
+    }
+    const options = { units: format.chart.units, decimals: format.chart.decimals };
+    return {
+        formatter: (value) => formatNumber(value, format.spec, format.context, options),
     };
 }
-function buildPieOption(component, data, donut) {
+// An axis's format from the spec its measures agree on, with the units and
+// decimals decided from its peak. Without a spec the axis is plain, and the
+// peak is never computed.
+function resolveValueAxisFormat(spec, peak, context) {
+    return spec ? { spec, chart: resolveChartNumberFormat(spec, peak(), context), context } : null;
+}
+// Each value axis's format, by axis index. A chart with one value axis takes
+// the format the plotted series' measures agree on (a splitBy or colorBy chart
+// plots only its first measure), from the peak of all its series. On a two-axis chart each axis takes the format of the measures
+// plotted against it, from the peak of its own series, which are never
+// stacked with a 100% stacked chart's shares. A reference past the data
+// stretches its axis, so it counts toward the peak (referencePeak); a 100%
+// stacked chart's references are shares, which the raw values' peak leaves
+// out. contexts holds each axis's context (annotatedAxisContexts).
+function valueAxisFormats(config, extracted, axisIndexes, contexts, percent, references) {
+    const reach = (axisIndex) => (percent && axisIndex === 0 ? 0 : referencePeak(references, axisIndex));
+    if (!axisIndexes.includes(1)) {
+        return [resolveValueAxisFormat(axisNumberFormat(extracted.series.map((series) => series.measure)), () => Math.max(chartValuePeak(extracted.series.map((series) => series.values), !!config.stacked), reach(0)), contexts[0])];
+    }
+    return [0, 1].map((axisIndex) => {
+        const onAxis = extracted.series.filter((_, index) => axisIndexes[index] === axisIndex);
+        return resolveValueAxisFormat(axisNumberFormat(onAxis.map((series) => series.measure)), () => Math.max(chartValuePeak(onAxis.map((series) => series.values), !!config.stacked && !percent), reach(axisIndex)), contexts[axisIndex]);
+    });
+}
+// A 100% stacked chart's share axis ticks: whole percentages in the locale
+// ('25%', '25 %' in fr-CA). The shares are ratios whatever the report's
+// percentFormat says of its stored values.
+function percentAxisLabel(context) {
+    return { formatter: wholePercentFormatter(context) };
+}
+// A share as a whole percentage in the locale, for the share axis's ticks and
+// its series' data labels.
+function wholePercentFormatter(context) {
+    const ratioContext = { ...context, ratioPercent: true };
+    return (value) => formatNumber(value, PERCENT_AXIS_FORMAT, ratioContext);
+}
+// A series' tooltip value in its measure's number format, per value ('—' when
+// empty). A measure without one writes it as the plain value axis does. A
+// value can arrive as an array (a [value, ...] data item), whose first entry
+// is the value.
+function seriesTooltip(measure, context) {
+    if (!hasNumberFormat(measure)) {
+        return { valueFormatter: (value) => formatPlainNumber(value, context.locale) };
+    }
+    return {
+        valueFormatter: (value) => formatNumber(Array.isArray(value) ? value[0] : value, measure, context),
+    };
+}
+function buildPieOption(component, data, donut, context) {
     const config = component.config;
     const extracted = extractChartSeries(component, data);
     const values = extracted.series[0]?.values ?? [];
@@ -440,6 +1716,7 @@ function buildPieOption(component, data, donut) {
                 type: 'pie',
                 radius: donut ? ['45%', '72%'] : '72%',
                 center: pieCenter(legendPosition),
+                tooltip: seriesTooltip(extracted.series[0]?.measure, context),
                 label: { show: false },
                 data: extracted.categories.map((category, index) => ({
                     name: category,
@@ -503,55 +1780,118 @@ export function spansMultipleYears(categories) {
     }
     return years.size > 1;
 }
-// A bucket's period-start split into its primary label and its year. Day/week
-// read as "May 1", month as "May", quarter as "Q2", year as "2025". Returns null
-// for a value that isn't a parseable date (left as-is by callers).
-function periodLabelParts(value, granularity) {
+// A time axis's date label style when its config names one the viewer knows,
+// else short.
+export function chartDateLabel(config) {
+    return Object.values(ReportChartDateLabel).find((style) => style === config?.xAxis?.dateLabel)
+        ?? ReportChartDateLabel.Short;
+}
+// A bucket's period-start split into its primary label and its year. A year
+// reads "2025" in every style. Short, in the locale: day/week read "May 1"
+// ('1 mai' in fr-CA), month "May" ('mai'), quarter "Q2" ('T2' in French).
+// Long carries its year, in the locale: "May 1, 2026", "May 2026" ('mai
+// 2026'), "Q2 2026". Numeric is the same in every locale: "2026-05-01",
+// "2026-05", "2026-Q2". Returns null for a value that isn't a parseable date
+// (left as-is by callers).
+function periodLabelParts(value, granularity, locale, dateLabel = ReportChartDateLabel.Short) {
     const date = parseISO(value);
     if (!isValid(date)) {
         return null;
     }
     const year = String(date.getFullYear());
+    if (granularity === 'year') {
+        return { primary: year, year };
+    }
+    return { primary: periodPrimaryLabel(date, granularity, locale, dateLabel), year };
+}
+// A period's label in the style asked for, the year aside (see
+// periodLabelParts).
+function periodPrimaryLabel(date, granularity, locale, dateLabel) {
+    const year = String(date.getFullYear());
+    const quarter = Math.floor(date.getMonth() / 3) + 1;
+    if (dateLabel === ReportChartDateLabel.Numeric) {
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        switch (granularity) {
+            case 'quarter':
+                return `${year}-Q${quarter}`;
+            case 'month':
+                return `${year}-${month}`;
+            default: // day, week — the bucket start
+                return `${year}-${month}-${day}`;
+        }
+    }
+    const long = dateLabel === ReportChartDateLabel.Long;
     switch (granularity) {
-        case 'year':
-            return { primary: year, year };
         case 'quarter':
-            return { primary: `Q${Math.floor(date.getMonth() / 3) + 1}`, year };
+            return long
+                ? `${quarterPrefix(locale)}${quarter} ${year}`
+                : `${quarterPrefix(locale)}${quarter}`;
         case 'month':
-            return { primary: format(date, 'MMMM'), year };
-        default: // day, week — the bucket start as a compact "MMM d"
-            return { primary: format(date, 'MMM d'), year };
+            return formatLocalDate(date, locale, long ? MONTH_YEAR : MONTH_LONG);
+        default: // day, week — the bucket start as a month and day
+            return formatLocalDate(date, locale, long ? DAY_SHORT : MONTH_DAY);
     }
 }
-// A compact single-line period label (year appended only when the data spans
-// years) — for media that can't do a styled second line, e.g. PowerPoint.
-export function formatPeriodLabel(value, granularity, multiYear) {
-    const parts = periodLabelParts(value, granularity);
+// Whether a period label leaves its year to be added apart: only a short one
+// does, a long or numeric label already carries it.
+function periodYearApart(granularity, dateLabel) {
+    return granularity !== 'year' && dateLabel === ReportChartDateLabel.Short;
+}
+function quarterPrefix(locale) {
+    return QUARTER_PREFIXES.get(locale.split('-')[0].toLowerCase()) ?? QUARTER_PREFIX;
+}
+// A compact single-line period label — for media that can't do a styled
+// second line, e.g. PowerPoint. A short label has its year appended only when
+// the data spans years; a long or numeric one always carries it.
+export function formatPeriodLabel(value, granularity, multiYear, locale, dateLabel = ReportChartDateLabel.Short) {
+    const parts = periodLabelParts(value, granularity, locale, dateLabel);
     if (!parts) {
         return value;
     }
-    return multiYear && granularity !== 'year' ? `${parts.primary} ${parts.year}` : parts.primary;
+    return multiYear && periodYearApart(granularity, dateLabel) ? `${parts.primary} ${parts.year}` : parts.primary;
 }
 // A cross-tab's column headings, the one rule the grid and the PDF/PowerPoint
 // exports share. The first is the row key and keeps its authored label; the
 // rest are pivot VALUES. When the pivot axis is a time dimension the server
 // sends the grain it bucketed at, so a period-start like "2026-01-01" reads
-// "January 2026", as the chart's x-axis labels it.
-export function pivotHeadings(config, data) {
+// "January 2026" ('janvier 2026' in fr-CA), as the chart's x-axis labels it.
+export function pivotHeadings(config, data, locale) {
     const columns = data.columns ?? [];
     const multiYear = spansMultipleYears(columns);
     return columns.map((column, index) => {
         if (index === 0) {
             return config.rowBy?.label || column;
         }
-        return data.granularity ? formatPeriodLabel(column, data.granularity, multiYear) : column;
+        return data.granularity ? formatPeriodLabel(column, data.granularity, multiYear, locale) : column;
     });
 }
+// A cross-tab's columns as the grid and the exports draw them: each headed by
+// pivotHeadings(), and every pivot-value column formatted by the one
+// config.cellFormat. The row key column stays as it came. `numeric` marks the
+// columns whose cells are formatted numbers, which are right-aligned.
+export function pivotColumnSpecs(config, data, locale) {
+    const headings = pivotHeadings(config, data, locale);
+    const cellFormat = config.cellFormat;
+    const numeric = hasNumberFormat(cellFormat);
+    const cells = numeric && cellFormat
+        ? { format: listColumnFormat(cellFormat.format), precision: cellFormat.precision, units: cellFormat.units }
+        : {};
+    return (data.columns ?? []).map((column, index) => index === 0
+        ? { column, label: headings[index], numeric: false }
+        : { column, label: headings[index], ...cells, numeric });
+}
+// A number format's style as a list column's format: the two enums share
+// their number values.
+function listColumnFormat(format) {
+    return Object.values(ReportListColumnFormat).find((value) => value === format);
+}
 // ECharts category-axis label config for a time bucket: the primary label on
 // line one, and — only when the data spans multiple years — the year on a small
 // gray second line, centered under the tick (year granularity needs no second
-// line, it already is the year). Empty for a non-time axis (labels as-is).
-function periodAxisLabel(granularity, categories) {
+// line, it already is the year, and neither does a long or numeric label,
+// which carries its year). Empty for a non-time axis (labels as-is).
+function periodAxisLabel(granularity, categories, locale, dateLabel) {
     if (!granularity) {
         return {};
     }
@@ -559,11 +1899,11 @@ function periodAxisLabel(granularity, categories) {
     return {
         axisLabel: {
             formatter: (value) => {
-                const parts = periodLabelParts(value, granularity);
+                const parts = periodLabelParts(value, granularity, locale, dateLabel);
                 if (!parts) {
                     return value;
                 }
-                return multiYear && granularity !== 'year'
+                return multiYear && periodYearApart(granularity, dateLabel)
                     ? `${parts.primary}\n{yr|${parts.year}}`
                     : parts.primary;
             },
@@ -571,4 +1911,4 @@ function periodAxisLabel(granularity, categories) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"option-builder.js","sourceRoot":"","sources":["../../../../src/app/reports/option-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import type { EChartsOption, LegendComponentOption, SeriesOption, TooltipComponentFormatterCallbackParams } from 'echarts';\n\nimport { format, isValid, parseISO } from 'date-fns';\n\nimport { formatMeasureValue } from './format';\nimport {\n  AxisChartType,\n  ChartConfig,\n  ChartGranularity,\n  ComponentData,\n  GRANULARITY_OPTIONS,\n  LegendPosition,\n  ListConfig,\n  ReportComponent,\n  WaterfallStepKind,\n} from './interfaces/report.interface';\nimport { escapeHtml } from './text';\nimport { REPORT_WATERFALL_COLORS } from './theme/palette';\nimport { REPORT_AXIS_LABEL_FONT_SIZE, REPORT_CHART_FONT_FAMILY } from './theme/typography';\n\n\n// Room for the category axis's title. ECharts 5's containLabel keeps the TICK\n// labels inside the grid but not the axis name, so without this a vertical\n// chart's title runs off the bottom edge or under a bottom legend.\nconst AXIS_NAME_ROOM = 20;\n// ECharts' own default gap between the axis line and its tick labels.\nconst AXIS_LABEL_MARGIN = 8;\n// Clearance between the longest tick label and a horizontal chart's rotated\n// title, so the two never touch.\nconst AXIS_NAME_CLEARANCE = 6;\n// A horizontal chart's category labels are cut short with an ellipsis past\n// this width (the tooltip still shows them in full), so one long label cannot\n// squeeze the plot away.\nconst CATEGORY_LABEL_MAX_WIDTH = 160;\nconst LABEL_ELLIPSIS = '…';\n// The font the theme draws axis labels in, as a canvas font string. Labels are\n// measured in it the way ECharts measures them for containLabel, so a\n// horizontal chart's title lands exactly beyond the widest label.\nconst AXIS_LABEL_FONT = `${REPORT_AXIS_LABEL_FONT_SIZE}px ${REPORT_CHART_FONT_FAMILY}`;\n\n// Which edge of the plot the category axis's title sits on: below a vertical\n// chart, to the left of a horizontal one.\ntype AxisTitleSide = 'bottom' | 'left';\n\n// The plot's distance from each edge of the chart, in pixels.\ninterface AxisGridRoom {\n  left: number;\n  right: number;\n  top: number;\n  bottom: number;\n  containLabel: boolean;\n}\n\n\n// colorBy applies only to single-dimension bar charts, and only when splitBy\n// isn't already driving multiple series: it colors each bar by its category and\n// shows a legend (one series per category, overlapped to full width).\n//\n// It is the DEFAULT for a categorical bar chart rather than something the config\n// has to ask for. A bar chart whose x-axis is a category — regions, statuses,\n// stores — is comparing those categories to each other, and one flat color with\n// no legend is the wrong reading of it in essentially every case. Requiring\n// colorBy to opt in meant every such chart rendered monochrome unless whoever\n// wrote the config remembered an optional property, which is a default set the\n// wrong way round: the common case should not need the flag.\n//\n// A TIME axis is excluded: consecutive periods are one series moving, not\n// categories being compared, and coloring each month differently reads as\n// unrelated groups. Explicitly opting out — colorBy: {column: ''} or a\n// config.legend of 'hidden' — still wins, so a caller that wants one flat color\n// can say so.\n//\n// \"Bar chart\" is the type the lone measure is actually DRAWN as: its own type\n// when it names one, which can turn a line chart's single series into bars or\n// a bar chart's into a line.\nexport function isColorBy(config: ChartConfig): boolean {\n  if (config.splitBy?.column || (config.measures?.[0]?.type ?? config.chartType ?? 'bar') !== 'bar') {\n    return false;\n  }\n\n  if (config.colorBy) {\n    return !!config.colorBy.column;\n  }\n\n  return (config.xAxis?.kind ?? 'category') === 'category'\n    && !config.xAxis?.granularity\n    && (config.measures?.length ?? 1) <= 1;\n}\n\n\n// The column colorBy groups by — its own when the config named one, otherwise\n// the x-axis it defaults to coloring.\nexport function colorByColumn(config: ChartConfig): string | undefined {\n  return isColorBy(config)\n    ? (config.colorBy?.column || config.xAxis?.column)\n    : undefined;\n}\n\n\n// Categories + named series extracted from a chart component's config + rows —\n// the one pivot (splitBy → series, measures → series) shared by the on-screen\n// ECharts option below AND the PowerPoint export's native chart data, so both\n// media plot identical numbers.\n//\n// A series' `type` is the type its measure asks to be drawn as, and is absent\n// when the measure leaves it to the chart's chartType (see seriesTypes).\nexport interface ExtractedChartSeries {\n  categories: string[];\n  series: { name: string; values: (number | null)[]; type?: AxisChartType }[];\n}\n\nexport function extractChartSeries(component: ReportComponent, data: ComponentData): ExtractedChartSeries {\n  const config = component.config as ChartConfig;\n  const xColumn = config.xAxis?.column ?? data.columns[0];\n  const splitColumn = config.splitBy?.column;\n  // colorBy emits one series per category too (so each bar carries its own\n  // color + legend entry), but the bars are overlapped to full width in\n  // buildAxisOption rather than laid side-by-side. splitBy wins if both are set.\n  const groupColumn = splitColumn || colorByColumn(config);\n  const measures = config.measures?.length\n    ? config.measures\n    : [{ column: data.columns[data.columns.length - 1] }];\n\n  const rawCategories = uniqueValues(data.rows, xColumn);\n  const categories = rawCategories.map((category) => String(category ?? '—'));\n  const series: ExtractedChartSeries['series'] = [];\n\n  if (groupColumn) {\n    // One series per group value (splitBy/colorBy), pivoted over the first measure.\n    const measure = measures[0];\n    for (const groupValue of uniqueValues(data.rows, groupColumn)) {\n      const byCategory = new Map<unknown, unknown>();\n      for (const row of data.rows) {\n        if (row[groupColumn] === groupValue) {\n          byCategory.set(row[xColumn], row[measure.column]);\n        }\n      }\n\n      series.push({\n        name: String(groupValue ?? '—'),\n        values: rawCategories.map((category) => numeric(byCategory.get(category))),\n        type: measure.type,\n      });\n    }\n  } else {\n    for (const measure of measures) {\n      const byCategory = new Map<unknown, unknown>();\n      for (const row of data.rows) {\n        byCategory.set(row[xColumn], row[measure.column]);\n      }\n\n      series.push({\n        name: measure.label ?? measure.column,\n        values: rawCategories.map((category) => numeric(byCategory.get(category))),\n        type: measure.type,\n      });\n    }\n  }\n\n  return { categories, series };\n}\n\n// The type each extracted series is drawn as: its measure's own type when it\n// names one, the chart's chartType otherwise. More than one distinct type is a\n// combo chart. Shared with the PowerPoint export so both media draw each series\n// the same way.\nexport function seriesTypes(extracted: ExtractedChartSeries, chartType: AxisChartType): AxisChartType[] {\n  return extracted.series.map((series) => series.type ?? chartType);\n}\n\n// One bar of a waterfall. `start` is the running total before it, where the bar\n// starts, and `change` its signed height, so it ends at start + change. The\n// closing total starts at zero and its change is the whole running total.\nexport interface WaterfallStep {\n  category: string;\n  start: number;\n  change: number | null;\n  kind: WaterfallStepKind;\n}\n\nexport interface ExtractedWaterfall {\n  name: string;\n  steps: WaterfallStep[];\n}\n\nexport const WATERFALL_TOTAL_LABEL = 'Total';\n\n// A waterfall's bars from its one measure: each category's value is how far the\n// running total moves there, and a last Total bar shows where it ended. A\n// category with no value moves nothing and draws no bar. Shared with the\n// PowerPoint export so both media draw the same steps.\nexport function extractWaterfall(component: ReportComponent, data: ComponentData): ExtractedWaterfall {\n  const extracted = extractChartSeries(component, data);\n  const values = extracted.series[0]?.values ?? [];\n  const steps: WaterfallStep[] = [];\n  let total = 0;\n\n  extracted.categories.forEach((category, index) => {\n    const change = values[index] ?? null;\n    steps.push({ category, start: total, change, kind: (change ?? 0) < 0 ? 'fall' : 'rise' });\n    total += change ?? 0;\n  });\n\n  steps.push({ category: WATERFALL_TOTAL_LABEL, start: 0, change: total, kind: 'total' });\n\n  return { name: extracted.series[0]?.name ?? '', steps };\n}\n\n// The one pure mapping from our standard camelCase chart config + the data\n// endpoint's rows to an ECharts option. Everything visual that isn't in the\n// registered 'report' theme is decided here, so report standards have exactly\n// two homes.\nexport function buildChartOption(component: ReportComponent, data: ComponentData): EChartsOption {\n  const config = component.config as ChartConfig;\n  const chartType = config.chartType ?? 'bar';\n\n  if (chartType === 'pie' || chartType === 'donut') {\n    return buildPieOption(component, data, chartType === 'donut');\n  }\n\n  if (chartType === 'waterfall') {\n    return buildWaterfallOption(component, data);\n  }\n\n  return buildAxisOption(component, data, chartType);\n}\n\nfunction buildAxisOption(\n  component: ReportComponent,\n  data: ComponentData,\n  chartType: AxisChartType,\n): EChartsOption {\n  const config = component.config as ChartConfig;\n  const extracted = extractChartSeries(component, data);\n  const horizontal = config.orientation === 'horizontal';\n  const colorBy = isColorBy(config);\n  const types = seriesTypes(extracted, chartType);\n  const combo = new Set(types).size > 1;\n\n  // colorBy emits one series per category; overlapping them (barGap -100%) makes\n  // each render at the full category-band width — one full-width, distinctly\n  // colored bar per category — instead of side-by-side slivers. The layout props\n  // are read from the first series of the coordinate system.\n  //\n  // Stacking sums every series that shares a stack name, whatever its type. In\n  // a combo each type stacks only with its own kind, so a line of a rate never\n  // sits on top of the bars' total.\n  const series: SeriesOption[] = extracted.series.map((extractedSeries, index) => buildSeries(\n    extractedSeries.name,\n    extractedSeries.values,\n    types[index],\n    config.stacked ? (combo ? `total-${types[index]}` : 'total') : undefined,\n    colorBy && index === 0,\n    combo,\n  ));\n\n  const categoryAxis = categoryAxisOption(config, data, extracted.categories, horizontal);\n  const valueAxis = { type: 'value' as const };\n\n  const legendPosition = resolveLegendPosition(config, series.length, colorBy);\n\n  return {\n    grid: axisGrid(legendPosition, categoryTitleSide(config, horizontal)),\n    legend: legendOption(legendPosition),\n    // colorBy charts overlap N mostly-null series, so an axis tooltip would list\n    // every category; an item tooltip shows just the hovered bar.\n    tooltip: { trigger: colorBy ? 'item' : 'axis' },\n    xAxis: horizontal ? valueAxis : categoryAxis,\n    yAxis: horizontal ? categoryAxis : valueAxis,\n    series,\n  };\n}\n\n// The category axis of an axis chart or a waterfall: the categories in row\n// order, labeled as periods when the rows were bucketed by time.\n//\n// Horizontal bars read top-down: ECharts draws category 0 at the bottom, so the\n// axis is inverted to put the first row (the largest of a top-N, a waterfall's\n// first step) at the top. The rotated title sits just beyond the longest label\n// rather than at a fixed gap that would put it on top of the labels.\nfunction categoryAxisOption(config: ChartConfig, data: ComponentData, categories: string[], horizontal: boolean) {\n  const granularity = bucketGranularity(data);\n  const periodLabel = periodAxisLabel(granularity, categories);\n  const axis = {\n    type: 'category' as const,\n    data: categories,\n    inverse: horizontal,\n    name: config.xAxis?.label,\n    nameLocation: 'middle' as const,\n  };\n\n  if (!horizontal) {\n    return {\n      ...axis,\n      nameGap: granularity && spansMultipleYears(categories) ? 40 : 28,\n      ...periodLabel,\n    };\n  }\n\n  // A period label ('May', 'Q2') is always short, so only a plain category is\n  // cut short. The labels are cut here rather than by ECharts' own truncation,\n  // so the title's gap is measured on exactly the text the axis draws.\n  const shown = granularity\n    ? null\n    : new Map(categories.map((category) => [category, truncateAxisLabel(category)]));\n  const labels = shown ? [...shown.values()] : displayedCategoryLabels(categories, granularity);\n\n  return {\n    ...axis,\n    nameGap: widestAxisLabel(labels) + AXIS_LABEL_MARGIN + AXIS_NAME_CLEARANCE,\n    ...(shown ? { axisLabel: { formatter: (value: string) => shown.get(value) ?? value } } : periodLabel),\n  };\n}\n\n// The category axis's title side, or null when the axis has no title to make\n// room for.\nfunction categoryTitleSide(config: ChartConfig, horizontal: boolean): AxisTitleSide | null {\n  if (!config.xAxis?.label) {\n    return null;\n  }\n\n  return horizontal ? 'left' : 'bottom';\n}\n\n// The tick labels as the axis shows them: a bucket's primary period label\n// ('May', 'Q2'), otherwise the category itself. The year a multi-year axis\n// prints under a period is left out, as it is never the wider line.\nfunction displayedCategoryLabels(categories: string[], granularity: ChartGranularity | null): string[] {\n  return granularity\n    ? categories.map((category) => periodLabelParts(category, granularity)?.primary ?? category)\n    : categories;\n}\n\n// The pixel width of the widest label. A label that breaks over several lines\n// is as wide as its longest line.\nfunction widestAxisLabel(labels: string[]): number {\n  return labels.reduce((widest, label) => label.split('\\n').reduce(\n    (lineWidest, line) => Math.max(lineWidest, axisLabelWidth(line)),\n    widest,\n  ), 0);\n}\n\n// A category label cut to CATEGORY_LABEL_MAX_WIDTH, line by line: the longest\n// start of each line that still fits with the ellipsis after it.\nfunction truncateAxisLabel(label: string): string {\n  return label.split('\\n').map((line) => {\n    if (axisLabelWidth(line) <= CATEGORY_LABEL_MAX_WIDTH) {\n      return line;\n    }\n\n    // Code points, so an emoji or other surrogate pair is never split.\n    const characters = Array.from(line);\n    const cut = (length: number) => `${characters.slice(0, length).join('').trimEnd()}${LABEL_ELLIPSIS}`;\n    let fits = 0;\n    let tooLong = characters.length;\n    while (tooLong - fits > 1) {\n      const length = Math.floor((fits + tooLong) / 2);\n      if (axisLabelWidth(cut(length)) <= CATEGORY_LABEL_MAX_WIDTH) {\n        fits = length;\n      } else {\n        tooLong = length;\n      }\n    }\n\n    return cut(fits);\n  }).join('\\n');\n}\n\n// One line's width in the axis-label font, measured on a canvas the way\n// ECharts measures it for containLabel. Outside a browser there is no canvas\n// to measure with, so the line counts as zero width.\nlet axisLabelContext: CanvasRenderingContext2D | null = null;\n\nfunction axisLabelWidth(line: string): number {\n  if (!axisLabelContext && typeof document !== 'undefined') {\n    axisLabelContext = document.createElement('canvas').getContext('2d');\n  }\n\n  if (!axisLabelContext) {\n    return 0;\n  }\n\n  axisLabelContext.font = AXIS_LABEL_FONT;\n\n  return axisLabelContext.measureText(line).width;\n}\n\nfunction buildWaterfallOption(component: ReportComponent, data: ComponentData): EChartsOption {\n  const config = component.config as ChartConfig;\n  const waterfall = extractWaterfall(component, data);\n  const horizontal = config.orientation === 'horizontal';\n  const categoryAxis = categoryAxisOption(config, data, waterfall.steps.map((step) => step.category), horizontal);\n  const valueAxis = { type: 'value' as const };\n  // One visible series, so the legend is hidden unless the config pins it.\n  const legendPosition = resolveLegendPosition(config, 1);\n  const granularity = bucketGranularity(data);\n\n  return {\n    grid: axisGrid(legendPosition, categoryTitleSide(config, horizontal)),\n    legend: { ...legendOption(legendPosition), data: [waterfall.name] },\n    // Per bar: the invisible base is silent, so only a step answers the hover.\n    tooltip: {\n      trigger: 'item',\n      formatter: (params: TooltipComponentFormatterCallbackParams) => waterfallTooltip(\n        waterfall,\n        (Array.isArray(params) ? params[0] : params).dataIndex,\n        granularity,\n      ),\n    },\n    xAxis: horizontal ? valueAxis : categoryAxis,\n    yAxis: horizontal ? categoryAxis : valueAxis,\n    series: waterfallSeries(waterfall),\n  };\n}\n\n// An invisible base series lifts each visible bar to where its step starts.\n// Both stack with the 'all' strategy, which adds signed values in series order,\n// so a fall draws DOWN from the total before it, even across zero. The default\n// same-sign stacking would hang a negative bar below the axis instead.\nfunction waterfallSeries(waterfall: ExtractedWaterfall): SeriesOption[] {\n  return [\n    {\n      type: 'bar',\n      stack: 'waterfall',\n      stackStrategy: 'all',\n      data: waterfall.steps.map((step) => step.start),\n      barMaxWidth: 48,\n      itemStyle: { color: 'transparent' },\n      silent: true,\n    },\n    {\n      name: waterfall.name,\n      type: 'bar',\n      stack: 'waterfall',\n      stackStrategy: 'all',\n      barMaxWidth: 48,\n      // The series color is the rise color so a pinned legend shows it; each\n      // bar is then colored by what it does to the total.\n      itemStyle: { color: `#${REPORT_WATERFALL_COLORS.rise}` },\n      data: waterfall.steps.map((step) => ({\n        value: step.change,\n        itemStyle: { color: `#${REPORT_WATERFALL_COLORS[step.kind]}` },\n      })),\n    },\n  ];\n}\n\n// A step's tooltip: its period, how far it moved the running total and where\n// that left it. The closing Total shows the total alone. The category and the\n// measure name come from the data and the config, and ECharts sets the tooltip\n// as HTML, so both are escaped.\nfunction waterfallTooltip(waterfall: ExtractedWaterfall, index: number, granularity: ChartGranularity | null): string {\n  const step = waterfall.steps[index];\n  const category = escapeHtml(granularity ? formatPeriodLabel(step.category, granularity, true) : step.category);\n  const name = escapeHtml(waterfall.name);\n\n  if (step.kind === 'total') {\n    return `${category}<br/>${name}: ${formatMeasureValue(step.change)}`;\n  }\n\n  const sign = (step.change ?? 0) > 0 ? '+' : '';\n\n  return `${category}<br/>${name}: ${sign}${formatMeasureValue(step.change)}`\n    + `<br/>Running total: ${formatMeasureValue(step.start + (step.change ?? 0))}`;\n}\n\n// Default legend placement when the config doesn't pin one: pie charts read\n// best with the slice key beside them (right); axis charts only need a legend\n// to tell multiple series apart, so a single-series chart hides it. An explicit\n// config.legend (including 'hidden') always wins. Shared with the PowerPoint\n// export so both media place the legend identically.\nexport function resolveLegendPosition(config: ChartConfig, seriesCount: number, colorBy = false): LegendPosition {\n  if (config.legend) {\n    return config.legend;\n  }\n\n  const pie = config.chartType === 'pie' || config.chartType === 'donut';\n\n  // colorBy maps each bar's color to its category, so it needs a legend even\n  // though it's a single measure.\n  return pie || colorBy || seriesCount > 1 ? (pie ? 'right' : 'top') : 'hidden';\n}\n\nfunction legendOption(position: LegendPosition): LegendComponentOption {\n  if (position === 'hidden') {\n    return { show: false };\n  }\n\n  const base: LegendComponentOption = { type: 'scroll' };\n\n  switch (position) {\n    case 'bottom':\n      return { ...base, bottom: 0 };\n    case 'left':\n      return { ...base, orient: 'vertical', left: 0, top: 'middle' };\n    case 'right':\n      return { ...base, orient: 'vertical', right: 0, top: 'middle' };\n    default:\n      return { ...base, top: 0 };\n  }\n}\n\n// The plot's grid: room on the legend's side so it never overlaps the\n// bars/lines, plus room for the category axis's title on its side, which\n// containLabel does not reserve (it covers the tick labels only).\nfunction axisGrid(position: LegendPosition, titleSide: AxisTitleSide | null): EChartsOption['grid'] {\n  const grid = legendGrid(position);\n\n  switch (titleSide) {\n    case 'bottom':\n      return { ...grid, bottom: grid.bottom + AXIS_NAME_ROOM };\n    case 'left':\n      return { ...grid, left: grid.left + AXIS_NAME_ROOM };\n    default:\n      return grid;\n  }\n}\n\n// Plot-edge room on whichever side the legend occupies; containLabel keeps the\n// tick labels inside what is left.\nfunction legendGrid(position: LegendPosition): AxisGridRoom {\n  const base: AxisGridRoom = { left: 8, right: 16, top: 8, bottom: 8, containLabel: true };\n\n  switch (position) {\n    case 'bottom':\n      return { ...base, bottom: 32 };\n    case 'left':\n      return { ...base, left: 96 };\n    case 'right':\n      return { ...base, right: 96 };\n    case 'hidden':\n      return base;\n    default:\n      return { ...base, top: 32 };\n  }\n}\n\nfunction buildSeries(\n  name: string,\n  values: (number | null)[],\n  type: AxisChartType,\n  stack: string | undefined,\n  overlap: boolean,\n  combo: boolean,\n): SeriesOption {\n  if (type === 'bar') {\n    return {\n      name,\n      type: 'bar',\n      data: values,\n      stack,\n      barMaxWidth: 48,\n      // colorBy: overlap the per-category series so each bar renders full-width.\n      ...(overlap ? { barGap: '-100%', barCategoryGap: '20%' } : {}),\n    };\n  }\n\n  return {\n    name,\n    type: 'line',\n    data: values,\n    stack,\n    smooth: true,\n    symbolSize: 6,\n    areaStyle: type === 'area' ? { opacity: 0.25 } : undefined,\n    // In a combo the line is drawn over the bars whatever order the measures\n    // come in; at the same z a later bar series would paint across it.\n    ...(combo ? { z: 3 } : {}),\n  };\n}\n\nfunction buildPieOption(component: ReportComponent, data: ComponentData, donut: boolean): EChartsOption {\n  const config = component.config as ChartConfig;\n  const extracted = extractChartSeries(component, data);\n  const values = extracted.series[0]?.values ?? [];\n  const legendPosition = resolveLegendPosition(config, extracted.series.length);\n\n  return {\n    tooltip: { trigger: 'item' },\n    legend: legendOption(legendPosition),\n    series: [\n      {\n        type: 'pie',\n        radius: donut ? ['45%', '72%'] : '72%',\n        center: pieCenter(legendPosition),\n        label: { show: false },\n        data: extracted.categories.map((category, index) => ({\n          name: category,\n          value: values[index] ?? 0,\n        })),\n      },\n    ],\n  };\n}\n\n// Nudge the pie off-center toward the opposite edge from its legend so the two\n// don't collide; centered when the legend is hidden.\nfunction pieCenter(position: LegendPosition): [string, string] {\n  switch (position) {\n    case 'left':\n      return ['60%', '50%'];\n    case 'right':\n      return ['40%', '50%'];\n    case 'top':\n      return ['50%', '58%'];\n    case 'bottom':\n      return ['50%', '46%'];\n    default:\n      return ['50%', '50%'];\n  }\n}\n\nfunction uniqueValues(rows: Record<string, unknown>[], column: string): unknown[] {\n  const seen = new Set<unknown>();\n  const values: unknown[] = [];\n  for (const row of rows) {\n    const value = row[column];\n    if (!seen.has(value)) {\n      seen.add(value);\n      values.push(value);\n    }\n  }\n\n  return values;\n}\n\nfunction numeric(value: unknown): number | null {\n  if (value === null || value === undefined || value === '') {\n    return null;\n  }\n\n  const parsed = Number(value);\n\n  return Number.isFinite(parsed) ? parsed : null;\n}\n\n// The effective time bucket the rows were grouped into (from the data endpoint),\n// or null when the x-axis isn't a time axis — gates the compact period labels.\nfunction bucketGranularity(data: ComponentData): ChartGranularity | null {\n  return data.granularity && GRANULARITY_OPTIONS.some((option) => option.value === data.granularity)\n    ? data.granularity\n    : null;\n}\n\n// Whether the period-start categories cross a year boundary. When they don't,\n// the year is pure noise on every label, so it's dropped entirely.\nexport function spansMultipleYears(categories: string[]): boolean {\n  const years = new Set<number>();\n  for (const category of categories) {\n    const date = parseISO(category);\n    if (isValid(date)) {\n      years.add(date.getFullYear());\n    }\n  }\n\n  return years.size > 1;\n}\n\n// A bucket's period-start split into its primary label and its year. Day/week\n// read as \"May 1\", month as \"May\", quarter as \"Q2\", year as \"2025\". Returns null\n// for a value that isn't a parseable date (left as-is by callers).\nfunction periodLabelParts(value: string, granularity: ChartGranularity): { primary: string; year: string } | null {\n  const date = parseISO(value);\n  if (!isValid(date)) {\n    return null;\n  }\n\n  const year = String(date.getFullYear());\n  switch (granularity) {\n    case 'year':\n      return { primary: year, year };\n    case 'quarter':\n      return { primary: `Q${Math.floor(date.getMonth() / 3) + 1}`, year };\n    case 'month':\n      return { primary: format(date, 'MMMM'), year };\n    default: // day, week — the bucket start as a compact \"MMM d\"\n      return { primary: format(date, 'MMM d'), year };\n  }\n}\n\n// A compact single-line period label (year appended only when the data spans\n// years) — for media that can't do a styled second line, e.g. PowerPoint.\nexport function formatPeriodLabel(value: string, granularity: ChartGranularity, multiYear: boolean): string {\n  const parts = periodLabelParts(value, granularity);\n  if (!parts) {\n    return value;\n  }\n\n  return multiYear && granularity !== 'year' ? `${parts.primary} ${parts.year}` : parts.primary;\n}\n\n// A cross-tab's column headings, the one rule the grid and the PDF/PowerPoint\n// exports share. The first is the row key and keeps its authored label; the\n// rest are pivot VALUES. When the pivot axis is a time dimension the server\n// sends the grain it bucketed at, so a period-start like \"2026-01-01\" reads\n// \"January 2026\", as the chart's x-axis labels it.\nexport function pivotHeadings(config: ListConfig, data: ComponentData): string[] {\n  const columns = data.columns ?? [];\n  const multiYear = spansMultipleYears(columns);\n\n  return columns.map((column, index) => {\n    if (index === 0) {\n      return config.rowBy?.label || column;\n    }\n\n    return data.granularity ? formatPeriodLabel(column, data.granularity, multiYear) : column;\n  });\n}\n\n// ECharts category-axis label config for a time bucket: the primary label on\n// line one, and — only when the data spans multiple years — the year on a small\n// gray second line, centered under the tick (year granularity needs no second\n// line, it already is the year). Empty for a non-time axis (labels as-is).\nfunction periodAxisLabel(granularity: ChartGranularity | null, categories: string[]): { axisLabel?: Record<string, unknown> } {\n  if (!granularity) {\n    return {};\n  }\n\n  const multiYear = spansMultipleYears(categories);\n\n  return {\n    axisLabel: {\n      formatter: (value: string) => {\n        const parts = periodLabelParts(value, granularity);\n        if (!parts) {\n          return value;\n        }\n\n        return multiYear && granularity !== 'year'\n          ? `${parts.primary}\\n{yr|${parts.year}}`\n          : parts.primary;\n      },\n      rich: { yr: { fontSize: 10, color: '#9aa0a6', lineHeight: 14 } },\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"option-builder.js","sourceRoot":"","sources":["../../../../src/app/reports/option-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import type { EChartsOption, LegendComponentOption, SeriesOption, TooltipComponentFormatterCallbackParams } from 'echarts';\n\nimport {\n  addDays,\n  addMonths,\n  addQuarters,\n  addWeeks,\n  addYears,\n  endOfMonth,\n  formatISO,\n  isLastDayOfMonth,\n  isValid,\n  max as latestOf,\n  min as earliestOf,\n  parseISO,\n  startOfDay,\n} from 'date-fns';\n\nimport { ReportChartColor } from './enums/report-chart-color.enum';\nimport { ReportChartDataLabels } from './enums/report-chart-data-labels.enum';\nimport { ReportChartDateLabel } from './enums/report-chart-date-label.enum';\nimport { ReportChartLineStyle } from './enums/report-chart-line-style.enum';\nimport { ReportChartMarkStat } from './enums/report-chart-mark-stat.enum';\nimport { ReportListColumnFormat } from './enums/report-list-column-format.enum';\nimport { ReportNumberUnits } from './enums/report-number-units.enum';\nimport { ReportValueFormat } from './enums/report-value-format.enum';\nimport {\n  axisNumberFormat,\n  ChartNumberFormat,\n  chartValuePeak,\n  comparisonOffsetLabel,\n  DAY_SHORT,\n  dateFormat,\n  formatDayRange,\n  formatDayWindow,\n  formatLocalDate,\n  FormattedOutputValue,\n  formatNumber,\n  formatOutputValue,\n  formatPlainNumber,\n  hasNumberFormat,\n  laneOutputAlias,\n  MONTH_DAY,\n  MONTH_LONG,\n  MONTH_YEAR,\n  resolveChartNumberFormat,\n  windowText,\n} from './format';\nimport {\n  AxisChartType,\n  ChartConfig,\n  ChartGranularity,\n  ChartMeasure,\n  ChartReference,\n  ChartValueAxis,\n  ComparisonOffset,\n  ComponentComparison,\n  ComponentData,\n  GRANULARITY_OPTIONS,\n  LegendPosition,\n  ListColumn,\n  ListConfig,\n  NumberFormatSpec,\n  OutputMeta,\n  OutputRole,\n  ReportComponent,\n  ReportFormatContext,\n  ReportLocaleTag,\n  WaterfallStepKind,\n  WindowMeta,\n} from './interfaces/report.interface';\nimport { escapeHtml } from './text';\nimport {\n  REPORT_CHART_COLOR_BY_NAME,\n  REPORT_CHART_COLORS,\n  REPORT_CHART_COLORS_CSS,\n  REPORT_REFERENCE_COLOR,\n  REPORT_WATERFALL_COLORS,\n} from './theme/palette';\nimport { REPORT_AXIS_LABEL_FONT_SIZE, REPORT_CHART_FONT_FAMILY, REPORT_DATA_LABEL_FONT_SIZE } from './theme/typography';\n\n\n// Room for an axis title. ECharts 5's containLabel keeps the TICK labels inside\n// the grid but not the axis name, so without this a vertical chart's category\n// title runs off the bottom edge or under a bottom legend, and its value title\n// above the plot runs off the top or under a top legend.\nconst AXIS_NAME_ROOM = 20;\n// ECharts' own default gap between the axis line and its tick labels.\nconst AXIS_LABEL_MARGIN = 8;\n// Clearance between the longest tick label and a horizontal chart's rotated\n// title, so the two never touch.\nconst AXIS_NAME_CLEARANCE = 6;\n// A horizontal chart's category labels are cut short with an ellipsis past\n// this width (the tooltip still shows them in full), so one long label cannot\n// squeeze the plot away.\nconst CATEGORY_LABEL_MAX_WIDTH = 160;\nconst LABEL_ELLIPSIS = '…';\n// The font the theme draws axis labels in, as a canvas font string. Labels are\n// measured in it the way ECharts measures them for containLabel, so a\n// horizontal chart's title lands exactly beyond the widest label.\nconst AXIS_LABEL_FONT = `${REPORT_AXIS_LABEL_FONT_SIZE}px ${REPORT_CHART_FONT_FAMILY}`;\n// The letter a quarter label starts with, by language subtag. French writes the\n// second quarter 'T2' (trimestre); every other language reads 'Q2'.\nconst QUARTER_PREFIXES = new Map<string, string>([['fr', 'T']]);\nconst QUARTER_PREFIX = 'Q';\n// A 100% stacked chart's value axis: whole percentages, a gridline every 25%,\n// up to 100%. Its tooltip gives each share to one decimal.\nconst PERCENT_AXIS_FORMAT: NumberFormatSpec = { format: ReportValueFormat.Percent, precision: 0 };\nconst PERCENT_SHARE_FORMAT: NumberFormatSpec = { format: ReportValueFormat.Percent, precision: 1 };\nexport const PERCENT_AXIS_MAX = 1;\nexport const PERCENT_AXIS_INTERVAL = 0.25;\n// A reference band's fill: the reference slate, faint enough that the series\n// drawn across it stay readable.\nconst REFERENCE_BAND_FILL = 'rgba(82, 96, 109, 0.08)';\n// A reference's or statistic line's label sits on a light box, so it stays\n// readable where it crosses a bar or a line.\nconst MARK_LABEL_BOX = { backgroundColor: 'rgba(255, 255, 255, 0.85)', padding: [1, 3], borderRadius: 2 };\n// The room an axis stretched to a reference leaves above it, for its label:\n// the bound is the round number at or past the reference plus this share.\nconst REFERENCE_HEADROOM = 1.05;\n\n// How a chart marks what the server says of its numbers (ComponentData's\n// comparison, outputs, windows and partialPeriod). The words are interface\n// text, English in every report locale.\n// - The heading of a period not over yet ('September 2026 (to date)').\nconst PARTIAL_PERIOD_TEXT = 'to date';\n// - A compared series' name: its measure's, then its role and lane ('Revenue\n//   change (vs previous week)'). A prior keeps the measure's name alone.\nconst ROLE_NAME_SUFFIXES: Record<Exclude<OutputRole, 'current'>, string> = {\n  prior: '',\n  change: ' change',\n  percent_change: ' % change',\n};\n// - A prior series' bars: its current series' color, faded, with a dashed\n//   edge. Its line is dashed (PRIOR_LINE_STYLE) unless its measure names one.\nconst PRIOR_BAR_OPACITY = 0.45;\nconst PRIOR_LINE_STYLE = ReportChartLineStyle.Dashed;\n// - The period not over yet: its bar hatched in light stripes, its point on a\n//   line drawn larger with a dashed edge, and, when it is the last one, the\n//   line's last segment dashed.\nconst PARTIAL_LINE_STYLE = ReportChartLineStyle.Dashed;\nconst PARTIAL_BAR_DECAL = {\n  symbol: 'none',\n  dashArrayX: [1, 0],\n  dashArrayY: [3, 5],\n  rotation: -Math.PI / 4,\n  color: 'rgba(255, 255, 255, 0.6)',\n};\nconst PARTIAL_POINT_MARK = { symbol: 'emptyCircle', symbolSize: 9, itemStyle: { borderType: 'dashed' } };\n// - A value axis of ranks only: rank 1 at the top, whole steps, from 1.\nconst RANK_AXIS_FORMAT: NumberFormatSpec = { format: ReportValueFormat.Number, precision: 0 };\n// (Shared with the PowerPoint export, whose rank axes start there too.)\nexport const RANK_AXIS_MIN = 1;\n// - A value axis of 0-1 fractions only (shares, percent changes) is a\n//   percent axis, its decimals decided by its peak.\nconst FRACTION_AXIS_FORMAT: NumberFormatSpec = { format: ReportValueFormat.Percent };\n// - Between a tooltip value and what it covers.\nconst TOOLTIP_DETAIL_SEPARATOR = ' · ';\n// - The prior a tooltip value is compared with, when the chart does not plot\n//   it ('vs 50% (Sep 1 – 2, 2026)').\nconst COMPARED_PRIOR_PREFIX = 'vs';\n\n// The words a statistic line's label starts with. They are interface text,\n// English in every report locale; only the value after them follows it.\nexport const STAT_LABEL: Record<ReportChartMarkStat, string> = {\n  [ReportChartMarkStat.Average]: 'Average',\n  [ReportChartMarkStat.Median]: 'Median',\n  [ReportChartMarkStat.Min]: 'Minimum',\n  [ReportChartMarkStat.Max]: 'Maximum',\n};\n\n// Which edge of the plot an axis title sits on. The category axis's is below a\n// vertical chart and to the left of a horizontal one; the value axis's is above\n// a vertical chart and below a horizontal one.\ntype AxisTitleSide = 'top' | 'bottom' | 'left';\n\n// Which value axis a series is plotted against: 0 the primary, 1 the second\n// axis on the right.\nexport type ValueAxisIndex = 0 | 1;\n\n// What valueAxisOption adds for one axis. `index` is the axis of a two-axis\n// chart it builds: the second one's title is aligned to read leftward from the\n// right edge. `percentMin` makes it a 100% stacked chart's share axis, from\n// that bound (0, or -1 when a share is negative) up to 100%, whatever range\n// the config pins. `reach` is the span of the references plotted against it,\n// which the axis stretches to when the data falls short of them. `rank`\n// inverts it.\ninterface ValueAxisExtras {\n  index?: ValueAxisIndex;\n  percentMin?: number;\n  reach?: ReferenceReach;\n  // Every series on the axis plots a rank: it runs from rank 1 at the top in\n  // whole steps.\n  rank?: boolean;\n}\n\n// A reference as the chart draws it: its lower and upper edge (the same value\n// for a line), whether it is a band, and the value axis it is plotted against.\n// Shared with the PowerPoint export, which draws each edge as a constant line.\nexport interface DrawnReference {\n  label: string;\n  low: number;\n  high: number;\n  band: boolean;\n  axisIndex: ValueAxisIndex;\n}\n\n// The lowest and highest edge of the references on one value axis.\ninterface ReferenceReach {\n  low: number;\n  high: number;\n}\n\n// What ECharts hands a value axis's min and max callbacks: the extent of the\n// data plotted against it.\ninterface AxisExtent {\n  min: number;\n  max: number;\n}\n\n// One point of a 100% stacked series: its share of the category's total,\n// which ECharts plots and stacks, and the value it came from.\ninterface ShareDataItem {\n  value: number | null;\n  raw: number | null;\n}\n\n// A point that prints its own data label: a 'last' series' latest point,\n// keeping the raw value a 100% stacked point carries.\ninterface LabeledDataItem<P extends DataLabelPosition> {\n  value: number | null;\n  raw?: number | null;\n  label: DataLabel<P>;\n}\n\ntype SeriesDataItem<P extends DataLabelPosition> = number | null | ShareDataItem | LabeledDataItem<P>;\n\n// What a data label's formatter is handed: the point's plotted value, its\n// data item as given (a number, or an object carrying the raw value), and its\n// index.\ninterface DataLabelParams {\n  value?: unknown;\n  data?: unknown;\n  dataIndex?: number;\n}\n\nexport type DataLabelFormatter = (params: DataLabelParams) => string;\n\n// Where a data label sits: 'outside' past an unstacked bar's end, on the side\n// its sign points to; 'inside' a stacked bar; 'top' above a line or area\n// point. ECharts takes 'outside' on a bar only.\nexport type DataLabelPosition = 'top' | 'inside' | 'outside';\n\n// One ECharts label, as a series or a single point prints it.\nexport interface DataLabel<P extends DataLabelPosition = DataLabelPosition> {\n  show: true;\n  position: P;\n  fontSize: number;\n  formatter: DataLabelFormatter;\n}\n\n// A series' data labels as dataLabelOption decides them, before buildSeries\n// places them by what the series draws: the label's text and size, whether\n// labels that would overlap are hidden ('auto'), and whether only the latest\n// point prints one ('last').\nexport interface SeriesDataLabels {\n  text: Omit<DataLabel, 'position'>;\n  hideOverlap: boolean;\n  lastOnly: boolean;\n}\n\n// A series' data labels placed: `series` is spread over the series (its\n// label, and for 'auto' the overlap hiding), and `data` is its points, the\n// latest non-empty one carrying the label for 'last'.\ninterface PlacedDataLabels<P extends DataLabelPosition> {\n  series: { label?: DataLabel<P>; labelLayout?: { hideOverlap: boolean } };\n  data: SeriesDataItem<P>[];\n}\n\n// A value axis's number format, decided once for the axis: the format the\n// measures plotted against it agree on (axisNumberFormat), with the units and\n// decimals its peak calls for, and the context its ticks are written in (an\n// axis of 0-1 fractions reads them as ratios whatever the report's\n// percentFormat). null is a plain axis. Its ticks and its series' data labels\n// both write in it.\ninterface ValueAxisFormat {\n  spec: NumberFormatSpec;\n  chart: ChartNumberFormat;\n  context: ReportFormatContext;\n}\n\n// The shares a 100% stacked chart draws, by the index of the extracted series\n// they replace.\nexport type PercentShares = Map<number, (number | null)[]>;\n\n// The plot's distance from each edge of the chart, in pixels.\ninterface AxisGridRoom {\n  left: number;\n  right: number;\n  top: number;\n  bottom: number;\n  containLabel: boolean;\n}\n\n\n// colorBy applies only to single-dimension bar charts, and only when splitBy\n// isn't already driving multiple series: it colors each bar by its category and\n// shows a legend (one series per category, overlapped to full width).\n//\n// It is the DEFAULT for a categorical bar chart rather than something the config\n// has to ask for. A bar chart whose x-axis is a category — regions, statuses,\n// stores — is comparing those categories to each other, and one flat color with\n// no legend is the wrong reading of it in essentially every case. Requiring\n// colorBy to opt in meant every such chart rendered monochrome unless whoever\n// wrote the config remembered an optional property, which is a default set the\n// wrong way round: the common case should not need the flag.\n//\n// A TIME axis is excluded: consecutive periods are one series moving, not\n// categories being compared, and coloring each month differently reads as\n// unrelated groups. Explicitly opting out — colorBy: {column: ''}, a color on\n// the measure or a config.legend of 'hidden' — still wins, so a caller that\n// wants one flat color can say so.\n//\n// \"Bar chart\" is the type the lone measure is actually DRAWN as: its own type\n// when it names one, which can turn a line chart's single series into bars or\n// a bar chart's into a line.\nexport function isColorBy(config: ChartConfig): boolean {\n  if (config.splitBy?.column || (config.measures?.[0]?.type ?? config.chartType ?? 'bar') !== 'bar') {\n    return false;\n  }\n\n  if (config.colorBy) {\n    return !!config.colorBy.column;\n  }\n\n  // A measure given its own color asks for one flat color.\n  if (measureColorHex(config.measures?.[0])) {\n    return false;\n  }\n\n  return (config.xAxis?.kind ?? 'category') === 'category'\n    && !config.xAxis?.granularity\n    && (config.measures?.length ?? 1) <= 1;\n}\n\n\n// The column colorBy groups by — its own when the config named one, otherwise\n// the x-axis it defaults to coloring.\nexport function colorByColumn(config: ChartConfig): string | undefined {\n  return isColorBy(config)\n    ? (config.colorBy?.column || config.xAxis?.column)\n    : undefined;\n}\n\n\n// Categories + named series extracted from a chart component's config + rows —\n// the one pivot (splitBy → series, measures → series) shared by the on-screen\n// ECharts option below AND the PowerPoint export's native chart data, so both\n// media plot identical numbers.\n//\n// A series' `type` is the type its measure asks to be drawn as, and is absent\n// when the measure leaves it to the chart's chartType (see seriesTypes). Its\n// `measure` is the one it plots, whose number format its tooltip uses and\n// whose display keys (color, axis) it follows, and `measureIndex` that\n// measure's position: the first measure, 0, for every series of a splitBy or\n// colorBy chart.\nexport interface ExtractedChartSeries {\n  categories: string[];\n  series: ExtractedChartSeriesItem[];\n}\n\nexport interface ExtractedChartSeriesItem {\n  name: string;\n  values: (number | null)[];\n  type?: AxisChartType;\n  measure: ChartMeasure;\n  measureIndex: number;\n}\n\nexport function extractChartSeries(component: ReportComponent, data: ComponentData): ExtractedChartSeries {\n  const config = component.config as ChartConfig;\n  const { xColumn, groupColumn } = chartColumns(config, data);\n  const measures = chartMeasures(config, data);\n\n  const rawCategories = uniqueValues(data.rows, xColumn);\n  const categories = rawCategories.map((category) => String(category ?? '—'));\n  const series: ExtractedChartSeries['series'] = [];\n\n  if (groupColumn) {\n    // One series per group value (splitBy/colorBy), pivoted over the first measure.\n    const measure = measures[0];\n    for (const groupValue of uniqueValues(data.rows, groupColumn)) {\n      series.push({\n        name: String(groupValue ?? '—'),\n        values: categoryValues(data.rows, xColumn, rawCategories, measure.column, (row) => row[groupColumn] === groupValue),\n        type: measure.type,\n        measure,\n        measureIndex: 0,\n      });\n    }\n  } else {\n    for (const [measureIndex, measure] of measures.entries()) {\n      series.push({\n        name: comparedSeriesName(measure, measures, data) ?? measure.label ?? measure.column,\n        values: categoryValues(data.rows, xColumn, rawCategories, measure.column),\n        type: measure.type,\n        measure,\n        measureIndex,\n      });\n    }\n  }\n\n  return { categories, series };\n}\n\n// The column a chart's categories come from, and the one that splits its\n// first measure into a series per value, if any. colorBy emits one series per\n// category too (so each bar carries its own color + legend entry), but the\n// bars are overlapped to full width in buildAxisOption rather than laid\n// side-by-side. splitBy wins if both are set.\nfunction chartColumns(config: ChartConfig, data: ComponentData): { xColumn: string; groupColumn: string | undefined } {\n  return {\n    xColumn: config.xAxis?.column ?? data.columns[0],\n    groupColumn: config.splitBy?.column || colorByColumn(config),\n  };\n}\n\n// One column's values by category, from the rows `match` keeps (all of them\n// when it is left out). A category with no row has no value.\nfunction categoryValues(\n  rows: Record<string, unknown>[],\n  xColumn: string,\n  rawCategories: unknown[],\n  column: string,\n  match?: (row: Record<string, unknown>) => boolean,\n): (number | null)[] {\n  const byCategory = new Map<unknown, unknown>();\n  for (const row of rows) {\n    if (!match || match(row)) {\n      byCategory.set(row[xColumn], row[column]);\n    }\n  }\n\n  return rawCategories.map((category) => numeric(byCategory.get(category)));\n}\n\n// A compared series' name, worded from its lane's offset rather than from its\n// own label, so a chart the viewer regrouped says what it now compares:\n// 'Revenue (vs previous week)', 'Revenue change (vs previous week)', 'Revenue\n// % change (vs previous year)'. The measure is named as its current value's\n// series is. null for any other series, which keeps its own name, and for\n// data without the comparison keys.\nfunction comparedSeriesName(measure: ChartMeasure, measures: ChartMeasure[], data: ComponentData): string | null {\n  const output = data.outputs?.[measure.column];\n  const offset = output?.offset ? data.comparison?.offsets?.[output.offset - 1] : undefined;\n\n  if (!output || !offset || !output.role || output.role === 'current') {\n    return null;\n  }\n\n  const current = currentOutputAlias(data.outputs, measure.column);\n  const label = measures.find((candidate) => candidate.column === current)?.label ?? current;\n\n  return `${label}${ROLE_NAME_SUFFIXES[output.role]} (${comparisonOffsetLabel(offset)})`;\n}\n\n// The column an output's current value is in: its lane's current output, else\n// for a rank or a share the uncompared one of the same measure, else the\n// measure's own column (a windowed value's source).\nfunction currentOutputAlias(outputs: Record<string, OutputMeta>, alias: string): string {\n  const output = outputs[alias];\n  const uncompared = output.kind === 'value'\n    ? undefined\n    : Object.keys(outputs).find((key) => outputs[key].measure === output.measure\n      && outputs[key].kind === output.kind\n      && outputs[key].role === null);\n\n  return laneOutputAlias(outputs, alias, 'current') ?? uncompared ?? output.measure;\n}\n\n// A series' own color as CSS hex: its measure's named color, or undefined when\n// it names none (or a name the palette does not know) and the theme colors it\n// by its position.\nexport function seriesColor(series: ExtractedChartSeriesItem): string | undefined {\n  const hex = namedColorHex(series);\n\n  return hex ? `#${hex}` : undefined;\n}\n\n// A series' color as the bare hex PowerPoint takes: its measure's named color,\n// else the palette color of its position, as the screen's theme picks it.\nexport function seriesHex(series: ExtractedChartSeriesItem, index: number): string {\n  return namedColorHex(series) ?? REPORT_CHART_COLORS[index % REPORT_CHART_COLORS.length];\n}\n\nfunction namedColorHex(series: ExtractedChartSeriesItem): string | undefined {\n  return measureColorHex(series.measure);\n}\n\n// A measure's named color as bare hex, or undefined when it names none or a\n// name the palette does not know. The name is read through the enum, so a\n// stored name such as '__proto__' never reaches the lookup object.\nfunction measureColorHex(measure: ChartMeasure | undefined): string | undefined {\n  const color = Object.values(ReportChartColor).find((name) => name === measure?.color);\n\n  return color ? REPORT_CHART_COLOR_BY_NAME[color] : undefined;\n}\n\n// A measure's line style when it names one ECharts knows, else undefined and\n// the line is solid.\nexport function measureLineStyle(measure: ChartMeasure | undefined): ReportChartLineStyle | undefined {\n  return Object.values(ReportChartLineStyle).find((style) => style === measure?.line);\n}\n\n// A measure's statistic line when it names one the viewer knows, else\n// undefined and it draws none.\nexport function measureMarkStat(measure: ChartMeasure | undefined): ReportChartMarkStat | undefined {\n  return Object.values(ReportChartMarkStat).find((stat) => stat === measure?.markLine);\n}\n\n// A series' statistic over its points that have a value: their mean, their\n// median (the mean of the two middle values when the count is even), the\n// lowest or the highest. null when no point has a value. Shared with the\n// PowerPoint export so both media draw the line at the same height.\nexport function seriesStat(values: (number | null)[], stat: ReportChartMarkStat): number | null {\n  const present = values.filter((value): value is number => typeof value === 'number' && Number.isFinite(value));\n\n  if (!present.length) {\n    return null;\n  }\n\n  switch (stat) {\n    case ReportChartMarkStat.Average:\n      return present.reduce((sum, value) => sum + value, 0) / present.length;\n    case ReportChartMarkStat.Median: {\n      const sorted = [...present].sort((a, b) => a - b);\n      const middle = Math.floor(sorted.length / 2);\n\n      return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;\n    }\n    case ReportChartMarkStat.Min:\n      return Math.min(...present);\n    case ReportChartMarkStat.Max:\n      return Math.max(...present);\n    default:\n      return null;\n  }\n}\n\n// Whether a chart draws statistic lines. A horizontal chart's values run\n// along x, and PowerPoint cannot draw a line beside horizontal bars, so\n// neither medium draws one there.\nexport function drawsStatLines(config: ChartConfig): boolean {\n  return config.orientation !== 'horizontal';\n}\n\n// A colorBy chart's one value per category: series i holds category i's bar.\n// PowerPoint draws these as its one series, and a statistic line is taken\n// over them.\nexport function colorByValues(extracted: ExtractedChartSeries): (number | null)[] {\n  return extracted.categories.map((_, index) => extracted.series[index]?.values[index] ?? null);\n}\n\n// The references a chart draws. A vertical axis chart and a waterfall draw\n// them; a pie has no value axis, and a horizontal chart is left without them\n// as PowerPoint cannot draw a line beside horizontal bars. An entry without a\n// finite value is skipped, and one whose `to` is missing or equal to its value\n// is a line. secondary reaches the second value axis only on a chart that has\n// one (twoAxes). Shared with the PowerPoint export.\nexport function chartReferences(config: ChartConfig, twoAxes: boolean): DrawnReference[] {\n  const chartType = config.chartType ?? 'bar';\n  const references: (ChartReference | null | undefined)[] = Array.isArray(config.references) ? config.references : [];\n\n  if (config.orientation === 'horizontal' || chartType === 'pie' || chartType === 'donut') {\n    return [];\n  }\n\n  return references.flatMap((reference): DrawnReference[] => {\n    const value = axisNumber(reference?.value);\n\n    if (!reference || value === undefined) {\n      return [];\n    }\n\n    const to = axisNumber(reference.to);\n    const label = typeof reference.label === 'string' ? reference.label : '';\n    const axisIndex: ValueAxisIndex = twoAxes && reference.secondary === true ? 1 : 0;\n\n    return [to !== undefined && to !== value\n      ? { label, low: Math.min(value, to), high: Math.max(value, to), band: true, axisIndex }\n      : { label, low: value, high: value, band: false, axisIndex }];\n  });\n}\n\n// Each series as its share of its category's total: per category, the\n// denominator is the sum of every series' absolute value there, so the\n// magnitudes of a category's shares add up to 1. A mixed-sign category's\n// negative values take negative shares, drawn below zero. A missing value\n// stays missing, and a category whose total is zero has no shares. Shared by\n// the screen, the PDF and PowerPoint, so a 100% stack reads the same in each.\nexport function percentShares(values: (number | null)[][]): (number | null)[][] {\n  const length = Math.max(0, ...values.map((series) => series.length));\n  const totals = Array.from({ length }, (_, index) => values\n    .reduce((sum, series) => sum + Math.abs(series[index] ?? 0), 0));\n\n  return values.map((series) => series.map((value, index) => (\n    value === null || !totals[index] ? null : value / totals[index]\n  )));\n}\n\n// The shares a 100% stacked chart draws in place of its values, or null when\n// the chart is not one. The primary axis's bar and area series take them,\n// each type's series sharing among themselves, as each type stacks apart.\n// Lines and secondary-axis series keep their values. A pie, a waterfall and a\n// colorBy chart (one series per category, each of which would be 100%) are\n// never 100% stacked, nor is a chart with no bar or area on its primary axis.\nexport function percentStackedShares(extracted: ExtractedChartSeries, config: ChartConfig): PercentShares | null {\n  const chartType = config.chartType ?? 'bar';\n\n  if (config.percentStacked !== true\n    || chartType === 'pie' || chartType === 'donut' || chartType === 'waterfall'\n    || isColorBy(config)) {\n    return null;\n  }\n\n  const types = seriesTypes(extracted, chartType);\n  const axisIndexes = seriesAxisIndexes(extracted, config);\n  const shares: PercentShares = new Map();\n\n  for (const type of ['bar', 'area'] as const) {\n    const indexes = types\n      .map((seriesType, index) => (seriesType === type && axisIndexes[index] === 0 ? index : -1))\n      .filter((index) => index >= 0);\n    const typeShares = percentShares(indexes.map((index) => extracted.series[index].values));\n    indexes.forEach((seriesIndex, position) => shares.set(seriesIndex, typeShares[position]));\n  }\n\n  return shares.size ? shares : null;\n}\n\n// Where a 100% stacked chart's value axis starts: at -100% when any share is\n// negative, else at zero.\nexport function percentAxisMin(shares: PercentShares): number {\n  return [...shares.values()].some((series) => series.some((share) => (share ?? 0) < 0)) ? -1 : 0;\n}\n\n// The measures a chart plots: its configured ones, else the query's last\n// column, unformatted.\nfunction chartMeasures(config: ChartConfig, data: ComponentData): ChartMeasure[] {\n  return config.measures?.length\n    ? config.measures\n    : [{ column: data.columns[data.columns.length - 1] }];\n}\n\n// The type each extracted series is drawn as: its measure's own type when it\n// names one, the chart's chartType otherwise. More than one distinct type is a\n// combo chart. Shared with the PowerPoint export so both media draw each series\n// the same way.\nexport function seriesTypes(extracted: ExtractedChartSeries, chartType: AxisChartType): AxisChartType[] {\n  return extracted.series.map((series) => series.type ?? chartType);\n}\n\n// The value axis each extracted series is plotted against: 1 when its measure\n// is secondary, 0 otherwise. A second axis is drawn only on a vertical chart\n// that keeps at least one series on the primary axis, so a combination the\n// server refuses (a horizontal chart, every measure secondary, the one measure\n// of a splitBy or colorBy chart) plots everything on the primary axis. Shared\n// with the PowerPoint export so both media put each series on the same axis.\nexport function seriesAxisIndexes(extracted: ExtractedChartSeries, config: ChartConfig): ValueAxisIndex[] {\n  const secondary = extracted.series.map((series) => !!series.measure.secondary);\n  const twoAxes = config.orientation !== 'horizontal' && secondary.includes(true) && secondary.includes(false);\n\n  return secondary.map((isSecondary) => (twoAxes && isSecondary ? 1 : 0));\n}\n\n// One bar of a waterfall. `start` is the running total before it, where the bar\n// starts, and `change` its signed height, so it ends at start + change. The\n// closing total starts at zero and its change is the whole running total.\nexport interface WaterfallStep {\n  category: string;\n  start: number;\n  change: number | null;\n  kind: WaterfallStepKind;\n}\n\nexport interface ExtractedWaterfall {\n  name: string;\n  steps: WaterfallStep[];\n}\n\nexport const WATERFALL_TOTAL_LABEL = 'Total';\n\n// A waterfall's bars from its one measure: each category's value is how far the\n// running total moves there, and a last Total bar shows where it ended. A\n// category with no value moves nothing and draws no bar. Shared with the\n// PowerPoint export so both media draw the same steps.\nexport function extractWaterfall(component: ReportComponent, data: ComponentData): ExtractedWaterfall {\n  const extracted = extractChartSeries(component, data);\n  const values = extracted.series[0]?.values ?? [];\n  const steps: WaterfallStep[] = [];\n  let total = 0;\n\n  extracted.categories.forEach((category, index) => {\n    const change = values[index] ?? null;\n    steps.push({ category, start: total, change, kind: (change ?? 0) < 0 ? 'fall' : 'rise' });\n    total += change ?? 0;\n  });\n\n  steps.push({ category: WATERFALL_TOTAL_LABEL, start: 0, change: total, kind: 'total' });\n\n  return { name: extracted.series[0]?.name ?? '', steps };\n}\n\n// The one pure mapping from our standard camelCase chart config + the data\n// endpoint's rows to an ECharts option. Everything visual that isn't in the\n// registered 'report' theme is decided here, so report standards have exactly\n// two homes.\n//\n// Every number and period the chart writes (value-axis ticks, tooltip values,\n// period labels) is in the context's locale, never the browser's. A measure\n// with number-format keys formats its tooltips, and the value axis when every\n// measure on it agrees (axisNumberFormat); without them the axis and tooltips\n// keep the plain locale-grouped number.\nexport function buildChartOption(\n  component: ReportComponent,\n  data: ComponentData,\n  context: ReportFormatContext,\n): EChartsOption {\n  const config = component.config as ChartConfig;\n  const chartType = config.chartType ?? 'bar';\n\n  if (chartType === 'pie' || chartType === 'donut') {\n    return buildPieOption(component, data, chartType === 'donut', context);\n  }\n\n  if (chartType === 'waterfall') {\n    return buildWaterfallOption(component, data, context);\n  }\n\n  return buildAxisOption(component, data, chartType, context);\n}\n\nfunction buildAxisOption(\n  component: ReportComponent,\n  data: ComponentData,\n  chartType: AxisChartType,\n  context: ReportFormatContext,\n): EChartsOption {\n  const config = component.config as ChartConfig;\n  const extracted = extractChartSeries(component, data);\n  const horizontal = config.orientation === 'horizontal';\n  const colorBy = isColorBy(config);\n  const types = seriesTypes(extracted, chartType);\n  const combo = new Set(types).size > 1;\n\n  // colorBy emits one series per category; overlapping them (barGap -100%) makes\n  // each render at the full category-band width — one full-width, distinctly\n  // colored bar per category — instead of side-by-side slivers. The layout props\n  // are read from the first series of the coordinate system.\n  //\n  // Stacking sums every series that shares a stack name, whatever its type. In\n  // a combo each type stacks only with its own kind, so a line of a rate never\n  // sits on top of the bars' total, and on a two-axis chart only with the\n  // series on its own axis.\n  //\n  // A 100% stacked chart (percentStackedShares) plots its primary bars and\n  // areas as shares, each type in its own stack, and leaves every other series\n  // unstacked on its own values.\n  //\n  // What the server says of the numbers (chartAnnotations) marks them: a\n  // prior series dashed in its current series' color, the period not over yet\n  // hatched or dashed, ranks on an inverted axis, fractions on a percent axis,\n  // and the tooltip naming each prior's days and each window. Data without\n  // those keys draws exactly as before.\n  const axisIndexes = seriesAxisIndexes(extracted, config);\n  const twoAxes = axisIndexes.includes(1);\n  const shares = percentStackedShares(extracted, config);\n  const references = chartReferences(config, twoAxes);\n  const annotations = chartAnnotations(config, data, extracted, colorBy);\n  const axisFormats = valueAxisFormats(\n    config,\n    annotations ? annotatedAxisSeries(extracted, annotations) : extracted,\n    axisIndexes,\n    annotations && !shares ? annotatedAxisContexts(annotations, axisIndexes, context) : [context, context],\n    !!shares,\n    references,\n  );\n  const rankAxes = annotations && !shares ? rankAxisFlags(annotations.outputs, axisIndexes) : [false, false];\n  // A series' statistic line is taken over the points it plots. On a colorBy\n  // chart each series holds one bar, so the one line is taken over the bars\n  // together and hangs off the first series (colorByStatLine).\n  const statLines = drawsStatLines(config) && !colorBy;\n  const series: SeriesOption[] = extracted.series.map((extractedSeries, index) => {\n    const seriesShares = shares?.get(index);\n    let stack: string | undefined;\n    if (seriesShares) {\n      stack = stackKey(types[index], combo, 0);\n    } else if (config.stacked && !shares) {\n      stack = stackKey(types[index], combo, twoAxes ? axisIndexes[index] : undefined);\n    }\n\n    // An output series (a compared, windowed, ranked or shared value) writes\n    // its tooltip, data labels and statistic line by what it holds.\n    const write = annotations && !seriesShares && annotations.outputs[index]\n      ? outputWriter(annotations, index, extractedSeries.measure, context)\n      : null;\n    const stat = statLines ? measureMarkStat(extractedSeries.measure) : undefined;\n    const markLine = stat && statMarkLine(\n      seriesShares ?? extractedSeries.values,\n      stat,\n      seriesShares ? shareWriter(context) : write ?? measureWriter(extractedSeries.measure, context),\n    );\n    const option = buildSeries(\n      extractedSeries,\n      seriesShares ? shareData(extractedSeries.values, seriesShares) : extractedSeries.values,\n      {\n        type: types[index],\n        stack,\n        overlap: colorBy && index === 0,\n        combo,\n        tooltip: write ? { valueFormatter: write } : seriesTooltip(extractedSeries.measure, context),\n        axisIndex: twoAxes ? axisIndexes[index] : undefined,\n        // A colorBy chart's bars take the palette by category, as in\n        // PowerPoint, whatever color the measure names.\n        color: colorBy ? undefined : annotations?.colors?.[index] ?? seriesColor(extractedSeries),\n        labels: dataLabelOption(config.dataLabels, write\n          ? outputLabelFormatter(write)\n          : dataLabelFormatter(\n            extractedSeries.measure,\n            axisFormats[axisIndexes[index]] ?? null,\n            !!seriesShares,\n            context,\n          )),\n      },\n    );\n    const marked = annotations ? markSeries(option, annotations, index, extractedSeries.measure) : option;\n\n    return markLine ? { ...marked, markLine } as SeriesOption : marked;\n  });\n\n  if (colorBy && drawsStatLines(config) && series.length) {\n    series[0] = colorByStatLine(series[0], extracted, context, annotations?.outputs[0]\n      ? outputWriter(annotations, 0, extracted.series[0].measure, context)\n      : undefined);\n  }\n\n  // Drawn after the measure series, so a tooltip reads a series by its index.\n  const segments = annotations ? partialSegments(series, annotations) : [];\n  const percentMin = shares ? percentAxisMin(shares) : undefined;\n  const categoryAxis = categoryAxisOption(config, data, extracted.categories, horizontal, context.locale);\n  // An axis of rate changes alone reads in percentage points, as its values do.\n  const axisLabels = ([0, 1] as const).map((axisIndex) => (annotations && !shares\n    ? pointsAxisLabel(annotations, extracted, axisIndexes, axisIndex, context)\n    : null) ?? valueAxisLabel(axisFormats[axisIndex] ?? null, context));\n  const valueAxis = twoAxes\n    ? twoValueAxesOption(config, axisLabels, context, percentMin, references, rankAxes)\n    : valueAxisOption(config.valueAxis, horizontal, percentMin === undefined\n      ? axisLabels[0]\n      : percentAxisLabel(context), { percentMin, reach: referenceReach(references, 0), rank: rankAxes[0] });\n\n  const legendPosition = resolveLegendPosition(config, series.length, colorBy);\n  const valueTitles = [config.valueAxis, twoAxes ? config.secondaryAxis : undefined];\n  const granularity = bucketGranularity(data);\n\n  return {\n    grid: axisGrid(legendPosition, categoryTitleSide(config, horizontal), valueTitleSide(valueTitles, horizontal)),\n    legend: referenceLegend(legendOption(legendPosition), series, references),\n    // colorBy charts overlap N mostly-null series, so an axis tooltip would list\n    // every category; an item tooltip shows just the hovered bar. A 100%\n    // stacked chart's tooltip gives each share and the value it came from. A\n    // chart with the server's annotations names what each value covers.\n    tooltip: shares\n      ? {\n        trigger: 'axis',\n        formatter: (params: TooltipComponentFormatterCallbackParams) => percentTooltip(\n          params,\n          extracted,\n          shares,\n          granularity,\n          chartDateLabel(config),\n          context,\n        ),\n      }\n      : annotatedChartTooltip(annotations && !colorBy ? {\n        extracted,\n        annotations,\n        owners: segments.map((segment) => segment.owner),\n        granularity,\n        dateLabel: chartDateLabel(config),\n        context,\n      } : null) ?? { trigger: colorBy ? 'item' : 'axis' },\n    xAxis: horizontal ? valueAxis : categoryAxis,\n    yAxis: horizontal ? categoryAxis : valueAxis,\n    series: [...series, ...segments.map((segment) => segment.series), ...referenceCarriers(references, extracted.categories)],\n  };\n}\n\n// What the server says of the series an axis chart plots, read from the\n// data's comparison, outputs, windows and partialPeriod by each series'\n// measure column. chartAnnotations is null when the data carries none of\n// those keys, and the chart draws exactly as before.\ninterface ChartAnnotations {\n  outputs: (OutputMeta | null)[];\n  windows: (WindowMeta | null)[];\n  // The chart measure an output takes its measure's format from: its current\n  // value's, when the chart plots it.\n  measureSpecs: (ChartMeasure | undefined)[];\n  // A change or percent change series' prior values by category, which tell\n  // a missing baseline from a zero one; null for any other series.\n  priors: ((number | null)[] | null)[];\n  // The lane prior a current, change or percent change series is compared\n  // with, when the chart does not plot that prior itself: its tooltip line\n  // names the prior's value and days. null for any other series.\n  lanePriors: (LanePrior | null)[];\n  // Every series' own CSS color, so a prior series and a partial segment can\n  // share another's; null on a colorBy chart, which colors by category.\n  colors: string[] | null;\n  priorSeries: boolean[];\n  comparison: ComponentComparison | null;\n  // The category of the period not over yet, or null.\n  partialIndex: number | null;\n}\n\n// A series' lane prior: its output, its values by category, and a key that\n// names it once in a tooltip (the prior column, and on a splitBy chart the\n// group).\ninterface LanePrior {\n  key: string;\n  output: OutputMeta;\n  values: (number | null)[];\n}\n\n// The keys of a built axis series that the annotations read and replace.\ninterface DrawnSeries {\n  type?: string;\n  stack?: string;\n  data?: SeriesDataItem<DataLabelPosition>[];\n  itemStyle?: Record<string, unknown>;\n  lineStyle?: Record<string, unknown>;\n}\n\n// A dashed last segment (partialSegments), drawn after the measure series,\n// and the index of the series it continues.\ninterface PartialSegment {\n  series: SeriesOption;\n  owner: number;\n}\n\n// What an annotated chart's axis tooltip reads. owners holds, by position,\n// the series each partial segment continues.\ninterface AnnotatedTooltipSource {\n  extracted: ExtractedChartSeries;\n  annotations: ChartAnnotations;\n  owners: number[];\n  granularity: ChartGranularity | null;\n  dateLabel: ReportChartDateLabel;\n  context: ReportFormatContext;\n}\n\nfunction chartAnnotations(\n  config: ChartConfig,\n  data: ComponentData,\n  extracted: ExtractedChartSeries,\n  colorBy: boolean,\n): ChartAnnotations | null {\n  if (!data.comparison && !data.outputs && !data.windows && (data.partialPeriod ?? null) === null) {\n    return null;\n  }\n\n  const columns = extracted.series.map((series) => series.measure.column);\n  const outputs = columns.map((column) => data.outputs?.[column] ?? null);\n  const currents = columns.map((column, index) => (outputs[index] ? currentOutputAlias(data.outputs, column) : null));\n  const measures = chartMeasures(config, data);\n  // A prior series' current series, by index; -1 for any other.\n  const sources = currents.map((current, index) => (outputs[index]?.role === 'prior' ? columns.indexOf(current) : -1));\n  const partialIndex = (data.partialPeriod ?? null) === null ? -1 : extracted.categories.indexOf(String(data.partialPeriod));\n  const lanes = lanePriorValues(config, data, extracted, outputs);\n\n  return {\n    outputs,\n    windows: columns.map((column) => data.windows?.[column] ?? null),\n    measureSpecs: currents.map((current) => measures.find((measure) => measure.column === current)),\n    priors: lanes.map((lane, index) => (isDeltaRole(outputs[index]?.role) ? lane?.prior.values ?? null : null)),\n    lanePriors: lanes.map((lane) => (lane && !columns.includes(lane.alias) ? lane.prior : null)),\n    colors: colorBy ? null : annotatedColors(extracted, sources),\n    priorSeries: outputs.map((output) => output?.role === 'prior'),\n    comparison: data.comparison ?? null,\n    partialIndex: partialIndex < 0 ? null : partialIndex,\n  };\n}\n\n// A current, change or percent change series' lane prior, by category: its\n// lane's prior column in the same rows (the same group's on a splitBy chart),\n// and that column's alias.\nfunction lanePriorValues(\n  config: ChartConfig,\n  data: ComponentData,\n  extracted: ExtractedChartSeries,\n  outputs: (OutputMeta | null)[],\n): ({ alias: string; prior: LanePrior } | null)[] {\n  const { xColumn, groupColumn } = chartColumns(config, data);\n  const rawCategories = uniqueValues(data.rows, xColumn);\n  const groups = groupColumn ? uniqueValues(data.rows, groupColumn) : [];\n\n  return extracted.series.map((series, index) => {\n    const role = outputs[index]?.role;\n    const alias = role === 'current' || isDeltaRole(role)\n      ? laneOutputAlias(data.outputs, series.measure.column, 'prior')\n      : null;\n    const output = alias ? data.outputs?.[alias] : undefined;\n\n    if (!alias || !output) {\n      return null;\n    }\n\n    const match = groupColumn ? (row: Record<string, unknown>) => row[groupColumn] === groups[index] : undefined;\n\n    return {\n      alias,\n      prior: {\n        key: groupColumn ? `${alias}\\u0000${index}` : alias,\n        output,\n        values: categoryValues(data.rows, xColumn, rawCategories, alias, match),\n      },\n    };\n  });\n}\n\nfunction isDeltaRole(role: OutputRole | null | undefined): boolean {\n  return role === 'change' || role === 'percent_change';\n}\n\n// Each series' color as the theme would hand it out: its measure's named\n// color, else the next palette color among the series without one. A prior\n// series that names no color takes its current series' color (sources) and\n// no palette color of its own.\nfunction annotatedColors(extracted: ExtractedChartSeries, sources: number[]): string[] {\n  let slot = 0;\n  const own = extracted.series.map((series, index) => {\n    const named = seriesColor(series);\n\n    if (named || sources[index] >= 0) {\n      return named ?? null;\n    }\n\n    return REPORT_CHART_COLORS_CSS[slot++ % REPORT_CHART_COLORS_CSS.length];\n  });\n\n  return own.map((color, index) => color ?? own[sources[index]] as string);\n}\n\n// A series' marks: a prior drawn in its current series' color family, dashed,\n// and the period not over yet hatched (a bar) or ringed (a point).\nfunction markSeries(\n  option: SeriesOption,\n  annotations: ChartAnnotations,\n  index: number,\n  measure: ChartMeasure,\n): SeriesOption {\n  const prior = annotations.priorSeries[index] ? priorStyle(option, measure, annotations.colors?.[index]) : option;\n\n  return annotations.partialIndex === null ? prior : markPartialPoint(prior, annotations.partialIndex);\n}\n\n// A prior's bars are faded with a dashed edge; its line is dashed unless its\n// measure names a line style.\nfunction priorStyle(option: SeriesOption, measure: ChartMeasure, color: string | undefined): SeriesOption {\n  const drawn = option as DrawnSeries;\n\n  if (drawn.type === 'bar') {\n    return {\n      ...option,\n      itemStyle: {\n        ...drawn.itemStyle,\n        opacity: PRIOR_BAR_OPACITY,\n        borderWidth: 1,\n        borderType: 'dashed',\n        ...(color ? { borderColor: color } : {}),\n      },\n    } as SeriesOption;\n  }\n\n  return { ...option, lineStyle: { ...drawn.lineStyle, type: measureLineStyle(measure) ?? PRIOR_LINE_STYLE } } as SeriesOption;\n}\n\n// The point of the period not over yet, when it has a value.\nfunction markPartialPoint(option: SeriesOption, partialIndex: number): SeriesOption {\n  const drawn = option as DrawnSeries;\n  const data = [...(drawn.data ?? [])];\n  const item = data[partialIndex];\n\n  if (item === undefined || pointValue(item) === null) {\n    return option;\n  }\n\n  const mark = drawn.type === 'bar' ? { itemStyle: { decal: PARTIAL_BAR_DECAL } } : PARTIAL_POINT_MARK;\n  data[partialIndex] = (typeof item === 'object' ? { ...item, ...mark } : { value: item, ...mark }) as SeriesDataItem<DataLabelPosition>;\n\n  return { ...option, data } as SeriesOption;\n}\n\n// A line or area series whose last period is not over yet draws its last\n// segment dashed: the series stops one point short, and a segment series\n// carries its last two points, dashed, in its color and under its name, so\n// the one legend entry toggles both. A stacked series keeps its line whole (a\n// segment would stack on top of it), and a gap stays a gap. Replaces each\n// such series in `series` and returns the segments.\nfunction partialSegments(series: SeriesOption[], annotations: ChartAnnotations): PartialSegment[] {\n  const last = annotations.partialIndex;\n  const segments: PartialSegment[] = [];\n\n  series.forEach((option, owner) => {\n    const drawn = option as DrawnSeries;\n    const data = drawn.data ?? [];\n    const color = annotations.colors?.[owner];\n\n    if (last === null || last < 1 || last !== data.length - 1 || drawn.type !== 'line' || drawn.stack || !color\n      || pointValue(data[last - 1]) === null || pointValue(data[last]) === null) {\n      return;\n    }\n\n    series[owner] = { ...option, data: [...data.slice(0, last), null] } as SeriesOption;\n    segments.push({ owner, series: segmentSeries(option, color, last) });\n  });\n\n  return segments;\n}\n\n// The dashed segment from the point before the last to the last one, which\n// keeps its marks and its data label. The point before it is drawn, and\n// labeled, by the series itself.\nfunction segmentSeries(option: SeriesOption, color: string, last: number): SeriesOption {\n  const drawn = option as DrawnSeries;\n  const data = drawn.data ?? [];\n\n  return {\n    ...option,\n    markLine: undefined,\n    lineStyle: { ...drawn.lineStyle, color, type: PARTIAL_LINE_STYLE },\n    data: data.map((item, index) => {\n      if (index === last) {\n        return item;\n      }\n\n      return index === last - 1 ? { value: pointValue(item), symbol: 'none', label: { show: false } } : null;\n    }),\n  } as SeriesOption;\n}\n\n// A point's plotted value, whether it is a bare number or an object.\nfunction pointValue(item: SeriesDataItem<DataLabelPosition> | undefined): number | null {\n  if (item === null || item === undefined) {\n    return null;\n  }\n\n  return typeof item === 'number' ? item : item.value;\n}\n\n// How an output series writes a value: formatOutputValue's rules (a signed\n// change, points, '—' with the no-baseline title, ranks and shares) with its\n// measure's format and the comparison's floor. Given the point's index (a\n// tooltip, a data label), a change reads its prior there, which tells a\n// missing baseline from a zero one. The title says why a value reads '—' or\n// 'n/a'.\nfunction outputValue(\n  annotations: ChartAnnotations,\n  index: number,\n  measure: ChartMeasure,\n  context: ReportFormatContext,\n): (value: unknown, dataIndex?: number) => FormattedOutputValue {\n  const output = annotations.outputs[index];\n  const priors = annotations.priors[index];\n\n  return (value, dataIndex) => formatOutputValue(Array.isArray(value) ? value[0] : value, output, measure, context, {\n    measureSpec: annotations.measureSpecs[index],\n    floor: annotations.comparison?.floor ?? null,\n    ...(priors && dataIndex !== undefined ? { prior: priors[dataIndex] ?? null } : {}),\n  });\n}\n\n// An output value's text alone, for a series' own tooltip and its data labels.\nfunction outputWriter(\n  annotations: ChartAnnotations,\n  index: number,\n  measure: ChartMeasure,\n  context: ReportFormatContext,\n): (value: unknown, dataIndex?: number) => string {\n  const write = outputValue(annotations, index, measure, context);\n\n  return (value, dataIndex) => write(value, dataIndex).text;\n}\n\nfunction outputLabelFormatter(write: (value: unknown, dataIndex?: number) => string): DataLabelFormatter {\n  return (params) => write(dataLabelValue(params), params.dataIndex);\n}\n\n// The chart's series as its value axes read them: an output series whose\n// slot names no format takes its output's (outputAxisMeasure).\nfunction annotatedAxisSeries(extracted: ExtractedChartSeries, annotations: ChartAnnotations): ExtractedChartSeries {\n  return {\n    ...extracted,\n    series: extracted.series.map((series, index) => ({\n      ...series,\n      measure: outputAxisMeasure(series.measure, annotations.outputs[index], annotations.measureSpecs[index]),\n    })),\n  };\n}\n\n// The format an output's axis reads when its slot names none: a rank's whole\n// numbers, a 0-1 fraction's percent, and a compared or windowed value its\n// measure's format. The slot's own precision and units still apply.\nfunction outputAxisMeasure(\n  measure: ChartMeasure,\n  output: OutputMeta | null,\n  measureSpec: ChartMeasure | undefined,\n): ChartMeasure {\n  if (!output || namesValueFormat(measure)) {\n    return measure;\n  }\n\n  let base: NumberFormatSpec | null = measureSpec && hasNumberFormat(measureSpec) ? formatKeys(measureSpec) : null;\n  if (output.kind === 'rank') {\n    base = RANK_AXIS_FORMAT;\n  } else if (isFractionOutput(output)) {\n    base = FRACTION_AXIS_FORMAT;\n  }\n\n  return base\n    ? { ...measure, ...base, ...formatKeys({ precision: measure.precision, units: measure.units }) } as ChartMeasure\n    : measure;\n}\n\nfunction namesValueFormat(spec: NumberFormatSpec): boolean {\n  return Object.values(ReportValueFormat).some((format) => format === spec.format);\n}\n\n// A spec's number-format keys that are set.\nfunction formatKeys(spec: NumberFormatSpec): NumberFormatSpec {\n  return {\n    ...((spec.format ?? null) !== null ? { format: spec.format } : {}),\n    ...((spec.precision ?? null) !== null ? { precision: spec.precision } : {}),\n    ...((spec.units ?? null) !== null ? { units: spec.units } : {}),\n  };\n}\n\n// Each value axis's context: one that plots only 0-1 fractions reads them as\n// ratios, whatever the report's percentFormat says of its stored values.\nfunction annotatedAxisContexts(\n  annotations: ChartAnnotations,\n  axisIndexes: ValueAxisIndex[],\n  context: ReportFormatContext,\n): ReportFormatContext[] {\n  return ([0, 1] as const).map((axisIndex) => (everyOnAxis(annotations.outputs, axisIndexes, axisIndex, isFractionOutput)\n    ? { ...context, ratioPercent: true }\n    : context));\n}\n\n// Which value axes, by index, plot nothing but ranks.\nfunction rankAxisFlags(outputs: (OutputMeta | null)[], axisIndexes: ValueAxisIndex[]): boolean[] {\n  return ([0, 1] as const).map((axisIndex) => everyOnAxis(outputs, axisIndexes, axisIndex, isRankPosition));\n}\n\n// How a chart that plots a prior series colors each series, for the\n// PowerPoint export: every series' color as bare hex, a prior taking its\n// current series' color and no palette color of its own (annotatedColors),\n// and which series are priors, which a line draws dashed. null when the chart\n// plots no prior series, and on a colorBy chart; its series keep seriesHex.\nexport function priorSeriesStyles(\n  config: ChartConfig,\n  data: ComponentData,\n  extracted: ExtractedChartSeries,\n): { colors: string[]; priors: boolean[] } | null {\n  const annotations = chartAnnotations(config, data, extracted, isColorBy(config));\n\n  if (!annotations?.colors || !annotations.priorSeries.some((prior) => prior)) {\n    return null;\n  }\n\n  return {\n    colors: annotations.colors.map((color) => color.replace('#', '')),\n    priors: annotations.priorSeries,\n  };\n}\n\n// Which value axes, by index, plot nothing but ranks, which the chart draws\n// inverted with rank 1 at the top. Shared with the PowerPoint export.\nexport function rankValueAxes(extracted: ExtractedChartSeries, data: ComponentData, config: ChartConfig): boolean[] {\n  return rankAxisFlags(\n    extracted.series.map((series) => data.outputs?.[series.measure.column] ?? null),\n    seriesAxisIndexes(extracted, config),\n  );\n}\n\n// Whether an axis has series and every one of them passes the test.\nfunction everyOnAxis(\n  outputs: (OutputMeta | null)[],\n  axisIndexes: ValueAxisIndex[],\n  axisIndex: ValueAxisIndex,\n  test: (output: OutputMeta) => boolean,\n): boolean {\n  const onAxis = outputs.filter((_, index) => axisIndexes[index] === axisIndex);\n\n  return onAxis.length > 0 && onAxis.every((output) => !!output && test(output));\n}\n\n// A share and a percent change are 0-1 fractions, whatever percentFormat says.\nfunction isFractionOutput(output: OutputMeta): boolean {\n  return output.kind === 'share' || output.role === 'percent_change';\n}\n\n// A value axis's tick labels when every series on it is a change of a rate\n// (a share's, or a percent-format value's): signed percentage points, as the\n// series' tooltips and data labels write them ('+5.0 pp'). null for any other\n// axis.\nfunction pointsAxisLabel(\n  annotations: ChartAnnotations,\n  extracted: ExtractedChartSeries,\n  axisIndexes: ValueAxisIndex[],\n  axisIndex: ValueAxisIndex,\n  context: ReportFormatContext,\n): ValueAxisLabel | null {\n  const onAxis = extracted.series\n    .map((_, index) => index)\n    .filter((index) => axisIndexes[index] === axisIndex);\n  const points = onAxis.length > 0 && onAxis.every((index) => isPointsChange(\n    annotations.outputs[index],\n    outputAxisMeasure(extracted.series[index].measure, annotations.outputs[index], annotations.measureSpecs[index]),\n  ));\n\n  if (!points) {\n    return null;\n  }\n\n  const write = outputWriter(annotations, onAxis[0], extracted.series[onAxis[0]].measure, context);\n\n  return { formatter: (value: number) => write(value) };\n}\n\n// A change of a rate, which prints in percentage points: a share's change, or\n// the change of a value whose format (its slot's, else its measure's) is a\n// percent.\nfunction isPointsChange(output: OutputMeta | null, axisMeasure: ChartMeasure): boolean {\n  return !!output && output.role === 'change' && output.kind !== 'rank'\n    && (output.kind === 'share' || axisMeasure.format === ReportValueFormat.Percent);\n}\n\n// A rank, current or prior; a rank change is a difference, not a position.\nfunction isRankPosition(output: OutputMeta): boolean {\n  return output.kind === 'rank' && output.role !== 'change';\n}\n\nfunction annotatedChartTooltip(source: AnnotatedTooltipSource | null) {\n  return source\n    ? {\n      trigger: 'axis' as const,\n      formatter: (params: TooltipComponentFormatterCallbackParams) => annotatedTooltip(params, source),\n    }\n    : null;\n}\n\n// The period, with 'to date' when it is not over yet, then each series shown\n// (a legend can hide some): its value written by what it is, and what it\n// covers. A partial segment speaks for its series. Names and values come from\n// the data and the config, and ECharts sets the tooltip as HTML, so both are\n// escaped.\nfunction annotatedTooltip(params: TooltipComponentFormatterCallbackParams, source: AnnotatedTooltipSource): string {\n  const items = Array.isArray(params) ? params : [params];\n  const dataIndex = items[0]?.dataIndex ?? 0;\n  const count = source.extracted.series.length;\n  const markers = new Map<number, string>();\n\n  for (const item of items) {\n    const seriesIndex = item.seriesIndex ?? -1;\n    const owner = seriesIndex < count ? seriesIndex : source.owners[seriesIndex - count];\n\n    if (owner !== undefined && owner >= 0 && !markers.has(owner)) {\n      markers.set(owner, typeof item.marker === 'string' ? item.marker : '');\n    }\n  }\n\n  const namedPriors = new Set<string>();\n  const lines = [...markers.entries()]\n    .sort(([first], [second]) => first - second)\n    .map(([index, marker]) => annotatedTooltipLine(source, index, dataIndex, marker, namedPriors));\n\n  return [annotatedTooltipHeading(source, dataIndex), ...lines].join('<br/>');\n}\n\nfunction annotatedTooltipHeading(source: AnnotatedTooltipSource, dataIndex: number): string {\n  const category = source.extracted.categories[dataIndex] ?? '';\n  const period = source.granularity\n    ? formatPeriodLabel(category, source.granularity, true, source.context.locale, source.dateLabel)\n    : category;\n\n  return escapeHtml(dataIndex === source.annotations.partialIndex ? `${period} (${PARTIAL_PERIOD_TEXT})` : period);\n}\n\n// '● Revenue (vs previous month): $813 · Aug 1 – 15, 2026', and why a value\n// reads '—' or 'n/a' when it does ('No baseline: no data before Jun 10, 2026').\n// A value compared with a prior the chart does not plot names that prior\n// once, on the first line shown that is compared with it: 'Rate % change (vs\n// previous month): -10% · vs 50% (Sep 1 – 2, 2026)'. namedPriors holds the\n// priors already named.\nfunction annotatedTooltipLine(\n  source: AnnotatedTooltipSource,\n  index: number,\n  dataIndex: number,\n  marker: string,\n  namedPriors: Set<string>,\n): string {\n  const series = source.extracted.series[index];\n  const value = series.values[dataIndex] ?? null;\n  const formatted = source.annotations.outputs[index]\n    ? outputValue(source.annotations, index, series.measure, source.context)(value, dataIndex)\n    : { text: seriesTooltip(series.measure, source.context).valueFormatter(value), title: null };\n  const lanePrior = source.annotations.lanePriors[index];\n  const compared = lanePrior && !namedPriors.has(lanePrior.key)\n    ? comparedPriorDetail(source, index, lanePrior, dataIndex)\n    : '';\n  if (lanePrior) {\n    namedPriors.add(lanePrior.key);\n  }\n\n  const parts = [formatted.text, seriesDetail(source, index, dataIndex), compared, formatted.title ?? ''];\n\n  return `${marker} ${escapeHtml(series.name)}: ${escapeHtml(parts.filter((part) => !!part).join(TOOLTIP_DETAIL_SEPARATOR))}`;\n}\n\n// The prior a value is compared with, when the chart does not plot it: its\n// value in its measure's format, and its days ('vs 50% (Sep 1 – 2, 2026)').\n// The measure's format is the current series' when the chart plots it, else\n// a change slot's own explicit format (a change is in its measure's units).\nfunction comparedPriorDetail(\n  source: AnnotatedTooltipSource,\n  index: number,\n  lanePrior: LanePrior,\n  dataIndex: number,\n): string {\n  const annotations = source.annotations;\n  const measure = source.extracted.series[index].measure;\n  const measureSpec = annotations.measureSpecs[index]\n    ?? (annotations.outputs[index]?.role !== 'percent_change' && namesValueFormat(measure) ? measure : null);\n  const text = formatOutputValue(lanePrior.values[dataIndex] ?? null, lanePrior.output, null, source.context, {\n    measureSpec,\n    floor: annotations.comparison?.floor ?? null,\n  }).text;\n  const window = priorDetail(source, lanePrior.output, dataIndex);\n\n  return window ? `${COMPARED_PRIOR_PREFIX} ${text} (${window})` : `${COMPARED_PRIOR_PREFIX} ${text}`;\n}\n\n// What a series' value covers, when the server says: a prior's days, or a\n// windowed value's window ('Rolling 3-month total'), whose days the note\n// under the chart names.\nfunction seriesDetail(source: AnnotatedTooltipSource, index: number, dataIndex: number): string {\n  const output = source.annotations.outputs[index];\n  const window = source.annotations.windows[index];\n\n  if (output?.role === 'prior') {\n    return priorDetail(source, output, dataIndex);\n  }\n\n  return window ? windowText({ ...window, start: null, end: null }, source.context.locale, source.granularity) : '';\n}\n\n// A prior value's days. A range comparison compares every point with the\n// same window. A series comparison compares each period with the period its\n// lane's offset back; an as_of comparison reads the value at the end of that\n// period ('on Aug 31, 2026').\nfunction priorDetail(source: AnnotatedTooltipSource, output: OutputMeta, dataIndex: number): string {\n  const comparison = source.annotations.comparison;\n  const lane = (output.offset ?? 1) - 1;\n  const offset = comparison?.offsets?.[lane];\n  const locale = source.context.locale;\n\n  if (!comparison || !offset) {\n    return '';\n  }\n\n  if (comparison.mode === 'range' || !source.granularity) {\n    const prior = comparison.priors?.[lane];\n\n    return prior ? formatDayWindow(prior, comparison.timezone, locale) : '';\n  }\n\n  const partial = dataIndex === source.annotations.partialIndex && comparison.align === 'to_date';\n  const today = partial ? zoneToday(comparison.timezone) : null;\n  const window = priorPeriodWindow(source.extracted.categories[dataIndex] ?? '', source.granularity, offset, today);\n\n  if (!window) {\n    return '';\n  }\n\n  return comparison.mode === 'as_of'\n    ? `on ${formatDayRange(window.end, window.end, locale)}`\n    : formatDayWindow({ ...window, through: partial ? comparison.current?.through ?? null : null }, comparison.timezone, locale);\n}\n\n// The days one period of the axis is compared with: the period moved back by\n// the lane's offset. A period not over yet, compared to date, runs only to\n// today moved back (priorToDateEnd). null for a category that is not a day,\n// or an offset without a unit (a custom range).\nfunction priorPeriodWindow(\n  category: string,\n  granularity: ChartGranularity,\n  offset: ComparisonOffset,\n  today: Date | null,\n): { start: string; end: string } | null {\n  const start = parseISO(category);\n  const unit = offset.unit;\n  const count = offset.count;\n\n  if (!isValid(start) || !unit || !count) {\n    return null;\n  }\n\n  const back = (date: Date) => addPeriods(date, unit, -count);\n  const fullEnd = addDays(back(addPeriods(start, granularity, 1)), -1);\n  const end = today ? earliestOf([fullEnd, priorToDateEnd(today, start, back, unit)]) : fullEnd;\n\n  return { start: calendarDay(back(start)), end: calendarDay(latestOf([end, back(start)])) };\n}\n\n// Today, kept inside the period, moved back by the offset; when today is the\n// last day of its month, the last day of the month it lands in (the\n// server's end-of-month rule: Sep 30 compares with Aug 31, not Aug 30).\nfunction priorToDateEnd(\n  today: Date,\n  periodStart: Date,\n  back: (date: Date) => Date,\n  unit: ChartGranularity,\n): Date {\n  const day = latestOf([startOfDay(today), periodStart]);\n  const moved = back(day);\n\n  return isLastDayOfMonth(day) && unit !== 'day' && unit !== 'week' ? endOfMonth(moved) : moved;\n}\n\nfunction addPeriods(date: Date, unit: ChartGranularity, count: number): Date {\n  switch (unit) {\n    case 'day':\n      return addDays(date, count);\n    case 'week':\n      return addWeeks(date, count);\n    case 'quarter':\n      return addQuarters(date, count);\n    case 'year':\n      return addYears(date, count);\n    default:\n      return addMonths(date, count);\n  }\n}\n\nfunction calendarDay(date: Date): string {\n  return formatISO(date, { representation: 'date' });\n}\n\n// Today's calendar day in the report's zone, as local midnight. The server\n// marks which period holds today (partialPeriod) but not the day itself; the\n// prior of that period is clipped at the same day. An unknown zone reads the\n// browser's own day.\nfunction zoneToday(timezone: string): Date {\n  try {\n    const parts = dateFormat('en-US', { year: 'numeric', month: 'numeric', day: 'numeric' }, timezone)\n      .formatToParts(new Date());\n    const part = (type: Intl.DateTimeFormatPartTypes) => Number(parts.find((found) => found.type === type)?.value);\n    const today = new Date(part('year'), part('month') - 1, part('day'));\n\n    if (isValid(today)) {\n      return today;\n    }\n  } catch {\n    // An unknown zone: the browser's day below.\n  }\n\n  return startOfDay(new Date());\n}\n\n// A colorBy chart's statistic line: one line over every bar, hung off the\n// first series and drawn in the reference slate, as no one category's color\n// speaks for the others.\nfunction colorByStatLine(\n  first: SeriesOption,\n  extracted: ExtractedChartSeries,\n  context: ReportFormatContext,\n  write?: (value: number) => string,\n): SeriesOption {\n  const measure = extracted.series[0]?.measure;\n  const stat = measureMarkStat(measure);\n  const markLine = stat && statMarkLine(\n    colorByValues(extracted),\n    stat,\n    write ?? measureWriter(measure, context),\n    `#${REPORT_REFERENCE_COLOR}`,\n  );\n\n  return markLine ? { ...first, markLine } as SeriesOption : first;\n}\n\n// A series' statistic line across the plot, labeled with the statistic and\n// its value ('Average: 1,234.5'), or undefined when no point has a value. It\n// takes the series' color unless it is given one.\nfunction statMarkLine(\n  values: (number | null)[],\n  stat: ReportChartMarkStat,\n  write: (value: number) => string,\n  color?: string,\n) {\n  const value = seriesStat(values, stat);\n\n  if (value === null) {\n    return undefined;\n  }\n\n  const text = `${STAT_LABEL[stat]}: ${write(value)}`;\n\n  return {\n    silent: true,\n    symbol: 'none',\n    lineStyle: { type: 'dashed' as const, width: 1, ...(color ? { color } : {}) },\n    label: { formatter: () => text, position: 'insideEndTop' as const, fontSize: REPORT_DATA_LABEL_FONT_SIZE, ...MARK_LABEL_BOX },\n    data: [{ yAxis: value }],\n  };\n}\n\n// A statistic's value in its measure's number format, in the report locale.\nfunction measureWriter(measure: ChartMeasure | undefined, context: ReportFormatContext): (value: number) => string {\n  return (value) => formatNumber(value, measure, context);\n}\n\n// A 100% stacked series' statistic is a share, written as its tooltip writes\n// one.\nfunction shareWriter(context: ReportFormatContext): (value: number) => string {\n  const ratioContext = { ...context, ratioPercent: true };\n\n  return (value) => formatNumber(value, PERCENT_SHARE_FORMAT, ratioContext);\n}\n\n// The series that carry a chart's references, one per value axis that has\n// any: an empty line (every point null, so it draws nothing and stretches no\n// axis) whose markLine draws the reference lines and whose markArea fills the\n// bands. It is silent, left out of the tooltip and, by referenceLegend, out of\n// the legend. It has no name, so no measure series' legend entry (whatever its\n// name, '' included) toggles it.\n//\n// Labels are functions, as a string formatter is a template that would read\n// '{b}' or '{c}' in a label as a placeholder. ECharts draws a markArea under\n// the bars and a markLine over them, so a band's label rides an invisible\n// markLine on its upper edge, inside its top left corner, where the first bar\n// would otherwise cover it.\nfunction referenceCarriers(references: DrawnReference[], categories: string[]): SeriesOption[] {\n  const color = `#${REPORT_REFERENCE_COLOR}`;\n\n  return ([0, 1] as const).flatMap((axisIndex): SeriesOption[] => {\n    const onAxis = references.filter((reference) => reference.axisIndex === axisIndex);\n    const lines = onAxis.filter((reference) => !reference.band);\n    const bands = onAxis.filter((reference) => reference.band);\n\n    if (!onAxis.length) {\n      return [];\n    }\n\n    return [{\n      type: 'line',\n      data: categories.map(() => null),\n      yAxisIndex: axisIndex,\n      silent: true,\n      tooltip: { show: false },\n      markLine: {\n        silent: true,\n        symbol: 'none',\n        lineStyle: { color, type: 'dashed', width: 1 },\n        label: { position: 'insideEndTop', color, fontSize: REPORT_DATA_LABEL_FONT_SIZE, ...MARK_LABEL_BOX },\n        data: [\n          ...lines.map((reference) => ({ yAxis: reference.low, label: { formatter: () => reference.label } })),\n          ...bands.map((reference) => ({\n            yAxis: reference.high,\n            // Zero width, not zero opacity: a markLine's label takes the\n            // line's opacity.\n            lineStyle: { width: 0 },\n            label: { position: 'insideStartBottom', formatter: () => reference.label },\n          })),\n        ],\n      },\n      ...(bands.length ? {\n        markArea: {\n          silent: true,\n          itemStyle: { color: REFERENCE_BAND_FILL },\n          data: bands.map((reference) => [{ yAxis: reference.low }, { yAxis: reference.high }]),\n        },\n      } : {}),\n    } as SeriesOption];\n  });\n}\n\n// The largest magnitude a value axis's references reach, which its number\n// format counts toward its peak, as the axis stretches to them; 0 when it\n// has none.\nexport function referencePeak(references: DrawnReference[], axisIndex: ValueAxisIndex): number {\n  const reach = referenceReach(references, axisIndex);\n\n  return reach ? Math.max(Math.abs(reach.low), Math.abs(reach.high)) : 0;\n}\n\n// The legend of a chart with references names its measure series alone, so\n// a carrier never shows as a blank entry. Without references it is left as it\n// was.\nfunction referenceLegend(\n  legend: LegendComponentOption,\n  series: SeriesOption[],\n  references: DrawnReference[],\n): LegendComponentOption {\n  return references.length\n    ? { ...legend, data: series.map((item) => String(item.name ?? '')) }\n    : legend;\n}\n\n// The span of the references on one value axis, or undefined when it has\n// none.\nfunction referenceReach(references: DrawnReference[], axisIndex: ValueAxisIndex): ReferenceReach | undefined {\n  const onAxis = references.filter((reference) => reference.axisIndex === axisIndex);\n\n  return onAxis.length\n    ? { low: Math.min(...onAxis.map((reference) => reference.low)), high: Math.max(...onAxis.map((reference) => reference.high)) }\n    : undefined;\n}\n\n// ECharts leaves a markLine or markArea out of an axis's extent, so a\n// reference beyond the data would fall off the plot. An axis bound the config\n// does not pin reaches past the furthest reference, to a round number with\n// room for its label (beyondReference), when the data (and the zero a value\n// axis always shows) falls short of it, and is left to ECharts otherwise: a\n// callback returning undefined keeps the bound automatic. Past the data and\n// zero, a reference beyond the max is above zero and one beyond the min below\n// it.\nfunction reachMin(reach: ReferenceReach | undefined) {\n  return reach\n    ? (extent: AxisExtent) => (reach.low < Math.min(extent.min, 0) ? -beyondReference(-reach.low) : undefined)\n    : undefined;\n}\n\nfunction reachMax(reach: ReferenceReach | undefined) {\n  return reach\n    ? (extent: AxisExtent) => (reach.high > Math.max(extent.max, 0) ? beyondReference(reach.high) : undefined)\n    : undefined;\n}\n\n// The bound an axis takes past a reference of this (positive) magnitude: the\n// smallest round number at or above it plus REFERENCE_HEADROOM. The steps are\n// finer than ECharts' tick steps, so a reference just past the data does not\n// double the axis (110 gives 120, not 200). The tolerance keeps a float error\n// from skipping a round number the value already is.\nconst NICE_STEPS = [1, 1.2, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10];\nconst NICE_TOLERANCE = 1e-9;\n\nfunction beyondReference(magnitude: number): number {\n  const target = magnitude * REFERENCE_HEADROOM;\n  const power = Math.pow(10, Math.floor(Math.log10(target)));\n  const step = NICE_STEPS.find((candidate) => candidate * power >= target * (1 - NICE_TOLERANCE)) ?? 10;\n\n  // Rounded back to the power's own digits, so 1.2 x 0.1 reads 0.12, not\n  // 0.12000000000000001.\n  return Number((step * power).toPrecision(12));\n}\n\n// The category axis of an axis chart or a waterfall: the categories in row\n// order, labeled as periods when the rows were bucketed by time.\n//\n// Horizontal bars read top-down: ECharts draws category 0 at the bottom, so the\n// axis is inverted to put the first row (the largest of a top-N, a waterfall's\n// first step) at the top. The rotated title sits just beyond the longest label\n// rather than at a fixed gap that would put it on top of the labels.\n//\n// A bucketed axis also names its period in the axis tooltip's header: ECharts\n// heads it with the raw category ('2026-01-01') unless the axis pointer's label\n// has a formatter, so it reads 'January 2026' instead, always with its year.\n// The axis's dateLabel style writes both its tick labels and that header.\nfunction categoryAxisOption(\n  config: ChartConfig,\n  data: ComponentData,\n  categories: string[],\n  horizontal: boolean,\n  locale: ReportLocaleTag,\n) {\n  const granularity = bucketGranularity(data);\n  const dateLabel = chartDateLabel(config);\n  const periodLabel = periodAxisLabel(granularity, categories, locale, dateLabel);\n  const axis = {\n    type: 'category' as const,\n    data: categories,\n    inverse: horizontal,\n    name: config.xAxis?.label,\n    nameLocation: 'middle' as const,\n    ...(granularity ? {\n      axisPointer: {\n        label: {\n          formatter: (params: { value: unknown }) => formatPeriodLabel(\n            String(params.value),\n            granularity,\n            true,\n            locale,\n            dateLabel,\n          ),\n        },\n      },\n    } : {}),\n  };\n\n  if (!horizontal) {\n    // The gap clears the year's second line when the labels print one.\n    const secondLine = granularity && dateLabel === ReportChartDateLabel.Short && spansMultipleYears(categories);\n\n    return {\n      ...axis,\n      nameGap: secondLine ? 40 : 28,\n      ...periodLabel,\n    };\n  }\n\n  // Period labels, short, long or numeric ('May', 'Q2', 'May 2026'), are\n  // bounded in length and never cut; only a plain category is truncated. The labels are cut here rather than by ECharts' own\n  // truncation, so the title's gap is measured on exactly the text the axis\n  // draws.\n  const shown = granularity\n    ? null\n    : new Map(categories.map((category) => [category, truncateAxisLabel(category)]));\n  const labels = shown ? [...shown.values()] : displayedCategoryLabels(categories, granularity, locale, dateLabel);\n\n  return {\n    ...axis,\n    nameGap: widestAxisLabel(labels) + AXIS_LABEL_MARGIN + AXIS_NAME_CLEARANCE,\n    ...(shown ? { axisLabel: { formatter: (value: string) => shown.get(value) ?? value } } : periodLabel),\n  };\n}\n\n// The category axis's title side, or null when the axis has no title to make\n// room for.\nfunction categoryTitleSide(config: ChartConfig, horizontal: boolean): AxisTitleSide | null {\n  if (!config.xAxis?.label) {\n    return null;\n  }\n\n  return horizontal ? 'left' : 'bottom';\n}\n\n// The value axes' title side, or null when none of them has a title. A\n// vertical chart's titles sit above the plot, at the top of each axis line, so\n// room is made once for both; a horizontal chart's sits below.\nfunction valueTitleSide(axes: (ChartValueAxis | undefined)[], horizontal: boolean): AxisTitleSide | null {\n  if (!axes.some((axis) => axis?.label)) {\n    return null;\n  }\n\n  return horizontal ? 'bottom' : 'top';\n}\n\n// The tick labels as the axis shows them: a bucket's primary period label\n// ('May', 'Q2', 'May 2026'), otherwise the category itself. The year a\n// multi-year axis prints under a short period is left out, as it is never the\n// wider line.\nfunction displayedCategoryLabels(\n  categories: string[],\n  granularity: ChartGranularity | null,\n  locale: ReportLocaleTag,\n  dateLabel: ReportChartDateLabel,\n): string[] {\n  return granularity\n    ? categories.map((category) => periodLabelParts(category, granularity, locale, dateLabel)?.primary ?? category)\n    : categories;\n}\n\n// The pixel width of the widest label. A label that breaks over several lines\n// is as wide as its longest line.\nfunction widestAxisLabel(labels: string[]): number {\n  return labels.reduce((widest, label) => label.split('\\n').reduce(\n    (lineWidest, line) => Math.max(lineWidest, axisLabelWidth(line)),\n    widest,\n  ), 0);\n}\n\n// A category label cut to CATEGORY_LABEL_MAX_WIDTH, line by line: the longest\n// start of each line that still fits with the ellipsis after it.\nfunction truncateAxisLabel(label: string): string {\n  return label.split('\\n').map((line) => {\n    if (axisLabelWidth(line) <= CATEGORY_LABEL_MAX_WIDTH) {\n      return line;\n    }\n\n    // Code points, so an emoji or other surrogate pair is never split.\n    const characters = Array.from(line);\n    const cut = (length: number) => `${characters.slice(0, length).join('').trimEnd()}${LABEL_ELLIPSIS}`;\n    let fits = 0;\n    let tooLong = characters.length;\n    while (tooLong - fits > 1) {\n      const length = Math.floor((fits + tooLong) / 2);\n      if (axisLabelWidth(cut(length)) <= CATEGORY_LABEL_MAX_WIDTH) {\n        fits = length;\n      } else {\n        tooLong = length;\n      }\n    }\n\n    return cut(fits);\n  }).join('\\n');\n}\n\n// One line's width in the axis-label font, measured on a canvas the way\n// ECharts measures it for containLabel. Outside a browser there is no canvas\n// to measure with, so the line counts as zero width.\nlet axisLabelContext: CanvasRenderingContext2D | null = null;\n\nfunction axisLabelWidth(line: string): number {\n  if (!axisLabelContext && typeof document !== 'undefined') {\n    axisLabelContext = document.createElement('canvas').getContext('2d');\n  }\n\n  if (!axisLabelContext) {\n    return 0;\n  }\n\n  axisLabelContext.font = AXIS_LABEL_FONT;\n\n  return axisLabelContext.measureText(line).width;\n}\n\nfunction buildWaterfallOption(\n  component: ReportComponent,\n  data: ComponentData,\n  context: ReportFormatContext,\n): EChartsOption {\n  const config = component.config as ChartConfig;\n  const waterfall = extractWaterfall(component, data);\n  const horizontal = config.orientation === 'horizontal';\n  const categories = waterfall.steps.map((step) => step.category);\n  const categoryAxis = categoryAxisOption(config, data, categories, horizontal, context.locale);\n  // The one measure's format writes the axis and the tooltip. The axis has to\n  // reach the furthest point the running total gets to, on either side of\n  // zero, or the furthest reference.\n  const spec = config.measures?.[0];\n  const references = chartReferences(config, false);\n  const valueAxis = valueAxisOption(config.valueAxis, horizontal, valueAxisLabel(resolveValueAxisFormat(\n    spec && hasNumberFormat(spec) ? spec : null,\n    () => Math.max(referencePeak(references, 0), ...waterfall.steps.map((step) => Math.abs(step.start + (step.change ?? 0)))),\n    context,\n  ), context), { reach: referenceReach(references, 0) });\n  // One visible series, so the legend is hidden unless the config pins it.\n  const legendPosition = resolveLegendPosition(config, 1);\n  const granularity = bucketGranularity(data);\n\n  return {\n    grid: axisGrid(\n      legendPosition,\n      categoryTitleSide(config, horizontal),\n      valueTitleSide([config.valueAxis], horizontal),\n    ),\n    legend: { ...legendOption(legendPosition), data: [waterfall.name] },\n    // Per bar: the invisible base is silent, so only a step answers the hover.\n    tooltip: {\n      trigger: 'item',\n      formatter: (params: TooltipComponentFormatterCallbackParams) => waterfallTooltip(\n        waterfall,\n        (Array.isArray(params) ? params[0] : params).dataIndex,\n        granularity,\n        chartDateLabel(config),\n        spec,\n        context,\n      ),\n    },\n    xAxis: horizontal ? valueAxis : categoryAxis,\n    yAxis: horizontal ? categoryAxis : valueAxis,\n    series: [...waterfallSeries(waterfall), ...referenceCarriers(references, categories)],\n  };\n}\n\n// An invisible base series lifts each visible bar to where its step starts.\n// Both stack with the 'all' strategy, which adds signed values in series order,\n// so a fall draws DOWN from the total before it, even across zero. The default\n// same-sign stacking would hang a negative bar below the axis instead.\nfunction waterfallSeries(waterfall: ExtractedWaterfall): SeriesOption[] {\n  return [\n    {\n      type: 'bar',\n      stack: 'waterfall',\n      stackStrategy: 'all',\n      data: waterfall.steps.map((step) => step.start),\n      barMaxWidth: 48,\n      itemStyle: { color: 'transparent' },\n      silent: true,\n    },\n    {\n      name: waterfall.name,\n      type: 'bar',\n      stack: 'waterfall',\n      stackStrategy: 'all',\n      barMaxWidth: 48,\n      // The series color is the rise color so a pinned legend shows it; each\n      // bar is then colored by what it does to the total.\n      itemStyle: { color: `#${REPORT_WATERFALL_COLORS.rise}` },\n      data: waterfall.steps.map((step) => ({\n        value: step.change,\n        itemStyle: { color: `#${REPORT_WATERFALL_COLORS[step.kind]}` },\n      })),\n    },\n  ];\n}\n\n// A step's tooltip: its period, how far it moved the running total and where\n// that left it. The closing Total shows the total alone. The category and the\n// measure name come from the data and the config, and ECharts sets the tooltip\n// as HTML, so both are escaped. Periods and amounts are written in the report's\n// locale, amounts in the measure's number format (a plain number without one);\n// the words ('Running total') stay English.\nfunction waterfallTooltip(\n  waterfall: ExtractedWaterfall,\n  index: number,\n  granularity: ChartGranularity | null,\n  dateLabel: ReportChartDateLabel,\n  spec: NumberFormatSpec | undefined,\n  context: ReportFormatContext,\n): string {\n  const step = waterfall.steps[index];\n  const category = escapeHtml(granularity\n    ? formatPeriodLabel(step.category, granularity, true, context.locale, dateLabel)\n    : step.category);\n  const name = escapeHtml(waterfall.name);\n  const amount = (value: number | null) => formatNumber(value, spec ?? {}, context);\n\n  if (step.kind === 'total') {\n    return `${category}<br/>${name}: ${amount(step.change)}`;\n  }\n\n  const sign = (step.change ?? 0) > 0 ? '+' : '';\n\n  return `${category}<br/>${name}: ${sign}${amount(step.change)}`\n    + `<br/>Running total: ${amount(step.start + (step.change ?? 0))}`;\n}\n\n// Default legend placement when the config doesn't pin one: pie charts read\n// best with the slice key beside them (right); axis charts only need a legend\n// to tell multiple series apart, so a single-series chart hides it. An explicit\n// config.legend (including 'hidden') always wins. Shared with the PowerPoint\n// export so both media place the legend identically.\nexport function resolveLegendPosition(config: ChartConfig, seriesCount: number, colorBy = false): LegendPosition {\n  if (config.legend) {\n    return config.legend;\n  }\n\n  const pie = config.chartType === 'pie' || config.chartType === 'donut';\n\n  // colorBy maps each bar's color to its category, so it needs a legend even\n  // though it's a single measure.\n  return pie || colorBy || seriesCount > 1 ? (pie ? 'right' : 'top') : 'hidden';\n}\n\nfunction legendOption(position: LegendPosition): LegendComponentOption {\n  if (position === 'hidden') {\n    return { show: false };\n  }\n\n  const base: LegendComponentOption = { type: 'scroll' };\n\n  switch (position) {\n    case 'bottom':\n      return { ...base, bottom: 0 };\n    case 'left':\n      return { ...base, orient: 'vertical', left: 0, top: 'middle' };\n    case 'right':\n      return { ...base, orient: 'vertical', right: 0, top: 'middle' };\n    default:\n      return { ...base, top: 0 };\n  }\n}\n\n// The plot's grid: room on the legend's side so it never overlaps the\n// bars/lines, plus room for the category and value axes' titles on their\n// sides, which containLabel does not reserve (it covers the tick labels only).\nfunction axisGrid(\n  position: LegendPosition,\n  categoryTitle: AxisTitleSide | null,\n  valueTitle: AxisTitleSide | null,\n): EChartsOption['grid'] {\n  return [categoryTitle, valueTitle].reduce<AxisGridRoom>(\n    (grid, side) => (side ? { ...grid, [side]: grid[side] + AXIS_NAME_ROOM } : grid),\n    legendGrid(position),\n  );\n}\n\n// Plot-edge room on whichever side the legend occupies; containLabel keeps the\n// tick labels inside what is left.\nfunction legendGrid(position: LegendPosition): AxisGridRoom {\n  const base: AxisGridRoom = { left: 8, right: 16, top: 8, bottom: 8, containLabel: true };\n\n  switch (position) {\n    case 'bottom':\n      return { ...base, bottom: 32 };\n    case 'left':\n      return { ...base, left: 96 };\n    case 'right':\n      return { ...base, right: 96 };\n    case 'hidden':\n      return base;\n    default:\n      return { ...base, top: 32 };\n  }\n}\n\n// The stack a stacked series joins. On a two-axis chart (axisIndex set) each\n// type stacks per axis; otherwise a combo stacks per type and a single-type\n// chart stacks everything together.\nfunction stackKey(type: AxisChartType, combo: boolean, axisIndex: ValueAxisIndex | undefined): string {\n  if (axisIndex !== undefined) {\n    return `total-${type}-${axisIndex}`;\n  }\n\n  return combo ? `total-${type}` : 'total';\n}\n\n// How buildSeries draws one series: its drawn type, the stack it joins, whether\n// it lays the colorBy overlap, whether the chart is a combo, its tooltip, its\n// value axis on a two-axis chart, its own CSS color (undefined leaves it to\n// the theme's palette by position), and its data labels (null prints none).\ninterface SeriesLayout {\n  type: AxisChartType;\n  stack: string | undefined;\n  overlap: boolean;\n  combo: boolean;\n  tooltip: SeriesTooltip;\n  axisIndex: ValueAxisIndex | undefined;\n  color: string | undefined;\n  labels: SeriesDataLabels | null;\n}\n\n// One series of an axis chart. A measure's display keys only add what they\n// change, so a series that sets none is drawn by the theme as before: its own\n// color (the bar, the line, the area under it and its legend key all follow\n// itemStyle), its line style and its markers, shown on every point unless\n// markers is false. Data labels come last, on the series or on its latest\n// point.\nfunction buildSeries(\n  series: ExtractedChartSeriesItem,\n  values: (number | null | ShareDataItem)[],\n  layout: SeriesLayout,\n): SeriesOption {\n  // On a two-axis chart every series names its value axis.\n  const axis = layout.axisIndex === undefined ? {} : { yAxisIndex: layout.axisIndex };\n  const color = layout.color;\n  const itemStyle = color ? { itemStyle: { color } } : {};\n\n  if (layout.type === 'bar') {\n    // 'outside' follows each bar's sign: past a positive bar's end and below\n    // (or left of) a negative one's, where 'top' would sit at the zero line.\n    const { series: labels, data } = placeDataLabels(layout.labels, layout.stack ? 'inside' : 'outside', values);\n\n    return {\n      name: series.name,\n      type: 'bar',\n      data,\n      stack: layout.stack,\n      tooltip: layout.tooltip,\n      ...axis,\n      ...itemStyle,\n      barMaxWidth: 48,\n      // colorBy: overlap the per-category series so each bar renders full-width.\n      ...(layout.overlap ? { barGap: '-100%', barCategoryGap: '20%' } : {}),\n      ...labels,\n    };\n  }\n\n  const lineType = measureLineStyle(series.measure);\n  const lineStyle = color || lineType\n    ? { lineStyle: { ...(color ? { color } : {}), ...(lineType ? { type: lineType } : {}) } }\n    : {};\n  const { series: labels, data } = placeDataLabels(layout.labels, 'top', values);\n\n  return {\n    name: series.name,\n    type: 'line',\n    data,\n    stack: layout.stack,\n    tooltip: layout.tooltip,\n    ...axis,\n    ...itemStyle,\n    ...lineStyle,\n    ...(series.measure.markers === false ? { showSymbol: false } : {}),\n    smooth: true,\n    symbolSize: 6,\n    areaStyle: layout.type === 'area' ? { opacity: 0.25 } : undefined,\n    // In a combo the line is drawn over the bars whatever order the measures\n    // come in; at the same z a later bar series would paint across it.\n    ...(layout.combo ? { z: 3 } : {}),\n    ...labels,\n  };\n}\n\n// A 100% stacked series' points: each share, plotted and stacked, with the\n// value it came from.\nfunction shareData(values: (number | null)[], shares: (number | null)[]): ShareDataItem[] {\n  return values.map((raw, index) => ({ value: shares[index] ?? null, raw }));\n}\n\n// What a series prints beside its points (A2 data labels): every point\n// ('all'), every point whose label fits without overlapping another ('auto',\n// LabelLayout's hideOverlap), or only its latest point ('last'). none, an\n// absent mode or one the viewer does not know prints nothing, and the series\n// is left as it was. A colorBy chart's series each hold one bar, so 'last'\n// labels every bar there, as 'all' does.\n//\n// Where the label sits depends on what the series draws, so buildSeries\n// places it (placeDataLabels).\nexport function dataLabelOption(\n  mode: ReportChartDataLabels | undefined,\n  formatter: DataLabelFormatter,\n): SeriesDataLabels | null {\n  const text = { show: true as const, fontSize: REPORT_DATA_LABEL_FONT_SIZE, formatter };\n\n  switch (mode) {\n    case ReportChartDataLabels.All:\n      return { text, hideOverlap: false, lastOnly: false };\n    case ReportChartDataLabels.Auto:\n      return { text, hideOverlap: true, lastOnly: false };\n    case ReportChartDataLabels.Last:\n      return { text, hideOverlap: false, lastOnly: true };\n    default:\n      return null;\n  }\n}\n\n// A series' data labels at `position`: on the series ('all', and with the\n// overlap hiding 'auto'), or on its latest non-empty point alone ('last').\n// No labels leave the series and its points as they were.\nfunction placeDataLabels<P extends DataLabelPosition>(\n  labels: SeriesDataLabels | null,\n  position: P,\n  values: (number | null | ShareDataItem)[],\n): PlacedDataLabels<P> {\n  if (!labels) {\n    return { series: {}, data: values };\n  }\n\n  const label: DataLabel<P> = { ...labels.text, position };\n\n  if (labels.lastOnly) {\n    return { series: {}, data: labelLastPoint(values, label) };\n  }\n\n  return {\n    series: { label, ...(labels.hideOverlap ? { labelLayout: { hideOverlap: true } } : {}) },\n    data: values,\n  };\n}\n\n// A series' points with its latest non-empty point carrying the label. A\n// series with no value anywhere is left as it was.\nfunction labelLastPoint<P extends DataLabelPosition>(\n  values: (number | null | ShareDataItem)[],\n  label: DataLabel<P>,\n): SeriesDataItem<P>[] {\n  const last = values.reduce<number>((found, item, index) => (pointValue(item) === null ? found : index), -1);\n\n  return values.map((item, index): SeriesDataItem<P> => {\n    if (index !== last) {\n      return item;\n    }\n\n    return isShareDataItem(item) ? { ...item, label } : { value: item, label };\n  });\n}\n\nfunction isShareDataItem(item: number | null | ShareDataItem): item is ShareDataItem {\n  return item !== null && typeof item === 'object';\n}\n\n// How a series' data labels write a value. A 100% stacked series prints its\n// share as a whole percentage, as the share axis's ticks do. A series on an\n// axis with a number format prints its value in its measure's format, at the\n// units and decimals the axis decided, so a label reads like the ticks beside\n// it. Any other prints the plain locale-grouped number its tooltip shows. A\n// share point's raw value is what a label reads when it carries one.\nfunction dataLabelFormatter(\n  measure: ChartMeasure,\n  axisFormat: ValueAxisFormat | null,\n  share: boolean,\n  context: ReportFormatContext,\n): DataLabelFormatter {\n  if (share) {\n    const percent = wholePercentFormatter(context);\n\n    return (params) => percent(params.value);\n  }\n\n  if (axisFormat) {\n    const options = { units: axisFormat.chart.units, decimals: axisFormat.chart.decimals };\n\n    return (params) => formatNumber(dataLabelValue(params), measure, context, options);\n  }\n\n  return (params) => formatPlainNumber(dataLabelValue(params), context.locale);\n}\n\n// The value a data label writes: the raw value its point carries, else the\n// plotted one.\nfunction dataLabelValue(params: DataLabelParams): unknown {\n  const data = params.data;\n  const raw = data !== null && typeof data === 'object' ? (data as { raw?: unknown }).raw : undefined;\n\n  return raw ?? params.value;\n}\n\n// A 100% stacked chart's tooltip: the category, then each series on its own\n// line, a share as its percentage to one decimal followed by the value it came\n// from in its measure's format ('25.0% (1)'), and any other series by its own\n// value. The category and the series names come from the data and the config,\n// and ECharts sets the tooltip as HTML, so both are escaped.\nfunction percentTooltip(\n  params: TooltipComponentFormatterCallbackParams,\n  extracted: ExtractedChartSeries,\n  shares: PercentShares,\n  granularity: ChartGranularity | null,\n  dateLabel: ReportChartDateLabel,\n  context: ReportFormatContext,\n): string {\n  const items = Array.isArray(params) ? params : [params];\n  const dataIndex = items[0]?.dataIndex ?? 0;\n  const category = extracted.categories[dataIndex] ?? '';\n  const heading = escapeHtml(granularity\n    ? formatPeriodLabel(category, granularity, true, context.locale, dateLabel)\n    : category);\n  const ratioContext = { ...context, ratioPercent: true };\n\n  const lines = items.map((item) => {\n    const series = extracted.series[item.seriesIndex ?? -1];\n    const marker = typeof item.marker === 'string' ? item.marker : '';\n    const label = `${marker} ${escapeHtml(item.seriesName ?? series?.name ?? '')}`;\n    const value = seriesTooltip(series?.measure, context).valueFormatter(series?.values[item.dataIndex] ?? null);\n    const share = shares.get(item.seriesIndex ?? -1)?.[item.dataIndex] ?? null;\n\n    return share === null\n      ? `${label}: ${value}`\n      : `${label}: ${formatNumber(share, PERCENT_SHARE_FORMAT, ratioContext)} (${value})`;\n  });\n\n  return [heading, ...lines].join('<br/>');\n}\n\n// A value axis: its title and range from the config, its tick labels from\n// valueAxisLabel. A vertical chart's title sits above the axis line, reading\n// away from the plot's edge; a horizontal chart's is centered below the ticks.\n// A bound or interval that is not a usable number is left to ECharts. A 100%\n// stacked chart's share axis (extras.percentMin) has its own fixed range.\nfunction valueAxisOption(\n  axis: ChartValueAxis | undefined,\n  horizontal: boolean,\n  axisLabel: ValueAxisLabel,\n  extras: ValueAxisExtras = {},\n) {\n  const range = extras.percentMin === undefined\n    ? valueAxisRange(axis)\n    : { min: extras.percentMin, max: PERCENT_AXIS_MAX, interval: PERCENT_AXIS_INTERVAL };\n\n  return {\n    type: 'value' as const,\n    name: axis?.label || undefined,\n    nameLocation: horizontal ? 'middle' as const : 'end' as const,\n    nameGap: horizontal ? 28 : 10,\n    nameTextStyle: horizontal ? undefined : { align: extras.index === 1 ? 'right' as const : 'left' as const },\n    // A pinned bound wins; one left open reaches the references (reachMin),\n    // or on a rank axis starts at rank 1.\n    min: range.min ?? (extras.rank ? RANK_AXIS_MIN : reachMin(extras.reach)),\n    max: range.max ?? reachMax(extras.reach),\n    interval: range.interval,\n    axisLabel,\n    ...(extras.rank ? { inverse: true, minInterval: 1 } : {}),\n  };\n}\n\n// The part of a value axis's range the config pins. A bound that is not a\n// finite number, or an interval that is not a positive one, is left out, and\n// the chart picks it from the data. Shared with the PowerPoint export so both\n// media draw the same range.\nexport function valueAxisRange(axis: ChartValueAxis | undefined): { min?: number; max?: number; interval?: number } {\n  const interval = axisNumber(axis?.interval);\n\n  return {\n    min: axisNumber(axis?.min),\n    max: axisNumber(axis?.max),\n    interval: interval !== undefined && interval > 0 ? interval : undefined,\n  };\n}\n\n// A two-axis chart's value axes: the primary on the left, the second on the\n// right without gridlines of its own. Each axis's ticks take the format of the\n// measures plotted against it (axisLabels). Without a range on either axis the\n// second axis aligns its ticks to the primary's gridlines.\n//\n// On a 100% stacked chart (percentMin set) the primary axis is the share axis,\n// whose range is fixed, and the second axis's series are not stacked. An axis\n// of ranks alone (rankAxes) is inverted, and the axes then keep their own\n// ticks, so a rank axis steps by whole ranks.\nfunction twoValueAxesOption(\n  config: ChartConfig,\n  axisLabels: ValueAxisLabel[],\n  context: ReportFormatContext,\n  percentMin: number | undefined,\n  references: DrawnReference[],\n  rankAxes: boolean[],\n) {\n  const percent = percentMin !== undefined;\n  const label = (axisIndex: ValueAxisIndex) => axisLabels[axisIndex];\n\n  return [\n    valueAxisOption(config.valueAxis, false, percent ? percentAxisLabel(context) : label(0), {\n      index: 0,\n      percentMin,\n      reach: referenceReach(references, 0),\n      rank: rankAxes[0],\n    }),\n    {\n      ...valueAxisOption(config.secondaryAxis, false, label(1), {\n        index: 1,\n        reach: referenceReach(references, 1),\n        rank: rankAxes[1],\n      }),\n      position: 'right' as const,\n      splitLine: { show: false },\n      alignTicks: !percent && !rankAxes[0] && !rankAxes[1]\n        && !hasAxisRange(config.valueAxis) && !hasAxisRange(config.secondaryAxis),\n    },\n  ];\n}\n\n// Whether the config pins any of an axis's range: a bound or a tick interval.\nfunction hasAxisRange(axis: ChartValueAxis | undefined): boolean {\n  return Object.values(valueAxisRange(axis)).some((value) => value !== undefined);\n}\n\n// A configured bound or interval when it is a finite number, else undefined.\nfunction axisNumber(value: unknown): number | undefined {\n  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;\n}\n\n// A value axis's tick labels.\ninterface ValueAxisLabel {\n  formatter: (value: number) => string;\n}\n\n// Tick labels written in the locale. ECharts' own ticks are grouped en-US\n// whatever the page's language.\n//\n// With a number format, the units and decimals decided once for the whole\n// axis (resolveValueAxisFormat) write every tick alike ('1.5K', '2.0K', never\n// '2K'). Without one, or when it leaves the ticks an unscaled number with no\n// pinned decimals (format 'number', or precision-less units none), each tick\n// is a plain locale-grouped number keeping its own decimals, so a 0.0002 tick\n// never rounds to '0'.\nfunction valueAxisLabel(format: ValueAxisFormat | null, context: ReportFormatContext): ValueAxisLabel {\n  if (!format || (format.chart.units === ReportNumberUnits.None && format.chart.decimals === null)) {\n    return { formatter: (value: number) => formatPlainNumber(value, context.locale) };\n  }\n\n  const options = { units: format.chart.units, decimals: format.chart.decimals };\n\n  return {\n    formatter: (value: number) => formatNumber(value, format.spec, format.context, options),\n  };\n}\n\n// An axis's format from the spec its measures agree on, with the units and\n// decimals decided from its peak. Without a spec the axis is plain, and the\n// peak is never computed.\nfunction resolveValueAxisFormat(\n  spec: NumberFormatSpec | null,\n  peak: () => number,\n  context: ReportFormatContext,\n): ValueAxisFormat | null {\n  return spec ? { spec, chart: resolveChartNumberFormat(spec, peak(), context), context } : null;\n}\n\n// Each value axis's format, by axis index. A chart with one value axis takes\n// the format the plotted series' measures agree on (a splitBy or colorBy chart\n// plots only its first measure), from the peak of all its series. On a two-axis chart each axis takes the format of the measures\n// plotted against it, from the peak of its own series, which are never\n// stacked with a 100% stacked chart's shares. A reference past the data\n// stretches its axis, so it counts toward the peak (referencePeak); a 100%\n// stacked chart's references are shares, which the raw values' peak leaves\n// out. contexts holds each axis's context (annotatedAxisContexts).\nfunction valueAxisFormats(\n  config: ChartConfig,\n  extracted: ExtractedChartSeries,\n  axisIndexes: ValueAxisIndex[],\n  contexts: ReportFormatContext[],\n  percent: boolean,\n  references: DrawnReference[],\n): (ValueAxisFormat | null)[] {\n  const reach = (axisIndex: ValueAxisIndex) => (percent && axisIndex === 0 ? 0 : referencePeak(references, axisIndex));\n\n  if (!axisIndexes.includes(1)) {\n    return [resolveValueAxisFormat(\n      axisNumberFormat(extracted.series.map((series) => series.measure)),\n      () => Math.max(chartValuePeak(extracted.series.map((series) => series.values), !!config.stacked), reach(0)),\n      contexts[0],\n    )];\n  }\n\n  return ([0, 1] as const).map((axisIndex) => {\n    const onAxis = extracted.series.filter((_, index) => axisIndexes[index] === axisIndex);\n\n    return resolveValueAxisFormat(\n      axisNumberFormat(onAxis.map((series) => series.measure)),\n      () => Math.max(chartValuePeak(onAxis.map((series) => series.values), !!config.stacked && !percent), reach(axisIndex)),\n      contexts[axisIndex],\n    );\n  });\n}\n\n// A 100% stacked chart's share axis ticks: whole percentages in the locale\n// ('25%', '25 %' in fr-CA). The shares are ratios whatever the report's\n// percentFormat says of its stored values.\nfunction percentAxisLabel(context: ReportFormatContext): ValueAxisLabel {\n  return { formatter: wholePercentFormatter(context) };\n}\n\n// A share as a whole percentage in the locale, for the share axis's ticks and\n// its series' data labels.\nfunction wholePercentFormatter(context: ReportFormatContext): (value: unknown) => string {\n  const ratioContext = { ...context, ratioPercent: true };\n\n  return (value: unknown) => formatNumber(value, PERCENT_AXIS_FORMAT, ratioContext);\n}\n\n// What a series' tooltip writes beside its name.\ninterface SeriesTooltip {\n  valueFormatter: (value: unknown) => string;\n}\n\n// A series' tooltip value in its measure's number format, per value ('—' when\n// empty). A measure without one writes it as the plain value axis does. A\n// value can arrive as an array (a [value, ...] data item), whose first entry\n// is the value.\nfunction seriesTooltip(measure: ChartMeasure | undefined, context: ReportFormatContext): SeriesTooltip {\n  if (!hasNumberFormat(measure)) {\n    return { valueFormatter: (value: unknown) => formatPlainNumber(value, context.locale) };\n  }\n\n  return {\n    valueFormatter: (value: unknown) => formatNumber(Array.isArray(value) ? value[0] : value, measure, context),\n  };\n}\n\nfunction buildPieOption(\n  component: ReportComponent,\n  data: ComponentData,\n  donut: boolean,\n  context: ReportFormatContext,\n): EChartsOption {\n  const config = component.config as ChartConfig;\n  const extracted = extractChartSeries(component, data);\n  const values = extracted.series[0]?.values ?? [];\n  const legendPosition = resolveLegendPosition(config, extracted.series.length);\n\n  return {\n    tooltip: { trigger: 'item' },\n    legend: legendOption(legendPosition),\n    series: [\n      {\n        type: 'pie',\n        radius: donut ? ['45%', '72%'] : '72%',\n        center: pieCenter(legendPosition),\n        tooltip: seriesTooltip(extracted.series[0]?.measure, context),\n        label: { show: false },\n        data: extracted.categories.map((category, index) => ({\n          name: category,\n          value: values[index] ?? 0,\n        })),\n      },\n    ],\n  };\n}\n\n// Nudge the pie off-center toward the opposite edge from its legend so the two\n// don't collide; centered when the legend is hidden.\nfunction pieCenter(position: LegendPosition): [string, string] {\n  switch (position) {\n    case 'left':\n      return ['60%', '50%'];\n    case 'right':\n      return ['40%', '50%'];\n    case 'top':\n      return ['50%', '58%'];\n    case 'bottom':\n      return ['50%', '46%'];\n    default:\n      return ['50%', '50%'];\n  }\n}\n\nfunction uniqueValues(rows: Record<string, unknown>[], column: string): unknown[] {\n  const seen = new Set<unknown>();\n  const values: unknown[] = [];\n  for (const row of rows) {\n    const value = row[column];\n    if (!seen.has(value)) {\n      seen.add(value);\n      values.push(value);\n    }\n  }\n\n  return values;\n}\n\nfunction numeric(value: unknown): number | null {\n  if (value === null || value === undefined || value === '') {\n    return null;\n  }\n\n  const parsed = Number(value);\n\n  return Number.isFinite(parsed) ? parsed : null;\n}\n\n// The effective time bucket the rows were grouped into (from the data endpoint),\n// or null when the x-axis isn't a time axis — gates the compact period labels.\nfunction bucketGranularity(data: ComponentData): ChartGranularity | null {\n  return data.granularity && GRANULARITY_OPTIONS.some((option) => option.value === data.granularity)\n    ? data.granularity\n    : null;\n}\n\n// Whether the period-start categories cross a year boundary. When they don't,\n// the year is pure noise on every label, so it's dropped entirely.\nexport function spansMultipleYears(categories: string[]): boolean {\n  const years = new Set<number>();\n  for (const category of categories) {\n    const date = parseISO(category);\n    if (isValid(date)) {\n      years.add(date.getFullYear());\n    }\n  }\n\n  return years.size > 1;\n}\n\n// A time axis's date label style when its config names one the viewer knows,\n// else short.\nexport function chartDateLabel(config: ChartConfig | undefined): ReportChartDateLabel {\n  return Object.values(ReportChartDateLabel).find((style) => style === config?.xAxis?.dateLabel)\n    ?? ReportChartDateLabel.Short;\n}\n\n// A bucket's period-start split into its primary label and its year. A year\n// reads \"2025\" in every style. Short, in the locale: day/week read \"May 1\"\n// ('1 mai' in fr-CA), month \"May\" ('mai'), quarter \"Q2\" ('T2' in French).\n// Long carries its year, in the locale: \"May 1, 2026\", \"May 2026\" ('mai\n// 2026'), \"Q2 2026\". Numeric is the same in every locale: \"2026-05-01\",\n// \"2026-05\", \"2026-Q2\". Returns null for a value that isn't a parseable date\n// (left as-is by callers).\nfunction periodLabelParts(\n  value: string,\n  granularity: ChartGranularity,\n  locale: ReportLocaleTag,\n  dateLabel: ReportChartDateLabel = ReportChartDateLabel.Short,\n): { primary: string; year: string } | null {\n  const date = parseISO(value);\n  if (!isValid(date)) {\n    return null;\n  }\n\n  const year = String(date.getFullYear());\n  if (granularity === 'year') {\n    return { primary: year, year };\n  }\n\n  return { primary: periodPrimaryLabel(date, granularity, locale, dateLabel), year };\n}\n\n// A period's label in the style asked for, the year aside (see\n// periodLabelParts).\nfunction periodPrimaryLabel(\n  date: Date,\n  granularity: Exclude<ChartGranularity, 'year'>,\n  locale: ReportLocaleTag,\n  dateLabel: ReportChartDateLabel,\n): string {\n  const year = String(date.getFullYear());\n  const quarter = Math.floor(date.getMonth() / 3) + 1;\n\n  if (dateLabel === ReportChartDateLabel.Numeric) {\n    const month = String(date.getMonth() + 1).padStart(2, '0');\n    const day = String(date.getDate()).padStart(2, '0');\n    switch (granularity) {\n      case 'quarter':\n        return `${year}-Q${quarter}`;\n      case 'month':\n        return `${year}-${month}`;\n      default: // day, week — the bucket start\n        return `${year}-${month}-${day}`;\n    }\n  }\n\n  const long = dateLabel === ReportChartDateLabel.Long;\n  switch (granularity) {\n    case 'quarter':\n      return long\n        ? `${quarterPrefix(locale)}${quarter} ${year}`\n        : `${quarterPrefix(locale)}${quarter}`;\n    case 'month':\n      return formatLocalDate(date, locale, long ? MONTH_YEAR : MONTH_LONG);\n    default: // day, week — the bucket start as a month and day\n      return formatLocalDate(date, locale, long ? DAY_SHORT : MONTH_DAY);\n  }\n}\n\n// Whether a period label leaves its year to be added apart: only a short one\n// does, a long or numeric label already carries it.\nfunction periodYearApart(granularity: ChartGranularity, dateLabel: ReportChartDateLabel): boolean {\n  return granularity !== 'year' && dateLabel === ReportChartDateLabel.Short;\n}\n\nfunction quarterPrefix(locale: ReportLocaleTag): string {\n  return QUARTER_PREFIXES.get(locale.split('-')[0].toLowerCase()) ?? QUARTER_PREFIX;\n}\n\n// A compact single-line period label — for media that can't do a styled\n// second line, e.g. PowerPoint. A short label has its year appended only when\n// the data spans years; a long or numeric one always carries it.\nexport function formatPeriodLabel(\n  value: string,\n  granularity: ChartGranularity,\n  multiYear: boolean,\n  locale: ReportLocaleTag,\n  dateLabel: ReportChartDateLabel = ReportChartDateLabel.Short,\n): string {\n  const parts = periodLabelParts(value, granularity, locale, dateLabel);\n  if (!parts) {\n    return value;\n  }\n\n  return multiYear && periodYearApart(granularity, dateLabel) ? `${parts.primary} ${parts.year}` : parts.primary;\n}\n\n// A cross-tab's column headings, the one rule the grid and the PDF/PowerPoint\n// exports share. The first is the row key and keeps its authored label; the\n// rest are pivot VALUES. When the pivot axis is a time dimension the server\n// sends the grain it bucketed at, so a period-start like \"2026-01-01\" reads\n// \"January 2026\" ('janvier 2026' in fr-CA), as the chart's x-axis labels it.\nexport function pivotHeadings(\n  config: ListConfig,\n  data: ComponentData,\n  locale: ReportLocaleTag,\n): string[] {\n  const columns = data.columns ?? [];\n  const multiYear = spansMultipleYears(columns);\n\n  return columns.map((column, index) => {\n    if (index === 0) {\n      return config.rowBy?.label || column;\n    }\n\n    return data.granularity ? formatPeriodLabel(column, data.granularity, multiYear, locale) : column;\n  });\n}\n\n// A cross-tab's columns as the grid and the exports draw them: each headed by\n// pivotHeadings(), and every pivot-value column formatted by the one\n// config.cellFormat. The row key column stays as it came. `numeric` marks the\n// columns whose cells are formatted numbers, which are right-aligned.\nexport function pivotColumnSpecs(\n  config: ListConfig,\n  data: ComponentData,\n  locale: ReportLocaleTag,\n): (ListColumn & { numeric: boolean })[] {\n  const headings = pivotHeadings(config, data, locale);\n  const cellFormat = config.cellFormat;\n  const numeric = hasNumberFormat(cellFormat);\n  const cells: Pick<ListColumn, 'format' | 'precision' | 'units'> = numeric && cellFormat\n    ? { format: listColumnFormat(cellFormat.format), precision: cellFormat.precision, units: cellFormat.units }\n    : {};\n\n  return (data.columns ?? []).map((column, index) => index === 0\n    ? { column, label: headings[index], numeric: false }\n    : { column, label: headings[index], ...cells, numeric });\n}\n\n// A number format's style as a list column's format: the two enums share\n// their number values.\nfunction listColumnFormat(format: NumberFormatSpec['format']): ReportListColumnFormat | undefined {\n  return Object.values(ReportListColumnFormat).find((value) => value === format);\n}\n\n// ECharts category-axis label config for a time bucket: the primary label on\n// line one, and — only when the data spans multiple years — the year on a small\n// gray second line, centered under the tick (year granularity needs no second\n// line, it already is the year, and neither does a long or numeric label,\n// which carries its year). Empty for a non-time axis (labels as-is).\nfunction periodAxisLabel(\n  granularity: ChartGranularity | null,\n  categories: string[],\n  locale: ReportLocaleTag,\n  dateLabel: ReportChartDateLabel,\n): { axisLabel?: Record<string, unknown> } {\n  if (!granularity) {\n    return {};\n  }\n\n  const multiYear = spansMultipleYears(categories);\n\n  return {\n    axisLabel: {\n      formatter: (value: string) => {\n        const parts = periodLabelParts(value, granularity, locale, dateLabel);\n        if (!parts) {\n          return value;\n        }\n\n        return multiYear && periodYearApart(granularity, dateLabel)\n          ? `${parts.primary}\\n{yr|${parts.year}}`\n          : parts.primary;\n      },\n      rich: { yr: { fontSize: 10, color: '#9aa0a6', lineHeight: 14 } },\n    },\n  };\n}\n"]}