@firestitch/report 18.6.0 → 18.7.0

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

@@ -1,12 +1,21 @@
-import { format, isValid, parseISO } from 'date-fns';
-import { formatMeasureValue } from './format';
+import { isValid, parseISO } 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, DAY_SHORT, formatLocalDate, formatNumber, formatPlainNumber, hasNumberFormat, MONTH_DAY, MONTH_LONG, MONTH_YEAR, resolveChartNumberFormat, } 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_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,33 @@ 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;
+// 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 +72,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 +86,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;
@@ -69,9 +109,7 @@ export function extractChartSeries(component, data) {
     // 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 measures = chartMeasures(config, data);
     const rawCategories = uniqueValues(data.rows, xColumn);
     const categories = rawCategories.map((category) => String(category ?? '—'));
     const series = [];
@@ -89,11 +127,13 @@ export function extractChartSeries(component, data) {
                 name: String(groupValue ?? '—'),
                 values: rawCategories.map((category) => numeric(byCategory.get(category))),
                 type: measure.type,
+                measure,
+                measureIndex: 0,
             });
         }
     }
     else {
-        for (const measure of measures) {
+        for (const [measureIndex, measure] of measures.entries()) {
             const byCategory = new Map();
             for (const row of data.rows) {
                 byCategory.set(row[xColumn], row[measure.column]);
@@ -102,11 +142,156 @@ export function extractChartSeries(component, data) {
                 name: measure.label ?? measure.column,
                 values: rawCategories.map((category) => numeric(byCategory.get(category))),
                 type: measure.type,
+                measure,
+                measureIndex,
             });
         }
     }
     return { categories, series };
 }
+// 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 +299,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 +332,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 +363,221 @@ 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.
+    const axisIndexes = seriesAxisIndexes(extracted, config);
+    const twoAxes = axisIndexes.includes(1);
+    const shares = percentStackedShares(extracted, config);
+    const references = chartReferences(config, twoAxes);
+    const axisFormats = valueAxisFormats(config, extracted, axisIndexes, context, !!shares, references);
+    // 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);
+        }
+        const stat = statLines ? measureMarkStat(extractedSeries.measure) : undefined;
+        const markLine = stat && statMarkLine(seriesShares ?? extractedSeries.values, stat, seriesShares ? shareWriter(context) : 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: 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 : seriesColor(extractedSeries),
+            labels: dataLabelOption(config.dataLabels, dataLabelFormatter(extractedSeries.measure, axisFormats[axisIndexes[index]] ?? null, !!seriesShares, context)),
+        });
+        return markLine ? { ...option, markLine } : option;
+    });
+    if (colorBy && drawsStatLines(config) && series.length) {
+        series[0] = colorByStatLine(series[0], extracted, context);
+    }
+    const percentMin = shares ? percentAxisMin(shares) : undefined;
+    const categoryAxis = categoryAxisOption(config, data, extracted.categories, horizontal, context.locale);
+    const valueAxis = twoAxes
+        ? twoValueAxesOption(config, axisFormats, context, percentMin, references)
+        : valueAxisOption(config.valueAxis, horizontal, percentMin === undefined
+            ? valueAxisLabel(axisFormats[0], context)
+            : percentAxisLabel(context), { percentMin, reach: referenceReach(references, 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.
+        tooltip: shares
+            ? {
+                trigger: 'axis',
+                formatter: (params) => percentTooltip(params, extracted, shares, granularity, chartDateLabel(config), context),
+            }
+            : { trigger: colorBy ? 'item' : 'axis' },
         xAxis: horizontal ? valueAxis : categoryAxis,
         yAxis: horizontal ? categoryAxis : valueAxis,
-        series,
+        series: [...series, ...referenceCarriers(references, extracted.categories)],
     };
 }
+// 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) {
+    const measure = extracted.series[0]?.measure;
+    const stat = measureMarkStat(measure);
+    const markLine = stat && statMarkLine(colorByValues(extracted), stat, 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 +585,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 +639,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 +700,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 +762,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 +810,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 +832,308 @@ 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 pointValue = (item) => (isShareDataItem(item) ? item.value : item);
+    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).
+        min: range.min ?? reachMin(extras.reach),
+        max: range.max ?? reachMax(extras.reach),
+        interval: range.interval,
+        axisLabel,
     };
 }
-function buildPieOption(component, data, donut) {
+// 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. 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.
+function twoValueAxesOption(config, axisFormats, context, percentMin, references) {
+    const percent = percentMin !== undefined;
+    const label = (axisIndex) => valueAxisLabel(axisFormats[axisIndex] ?? null, context);
+    return [
+        valueAxisOption(config.valueAxis, false, percent ? percentAxisLabel(context) : label(0), {
+            index: 0,
+            percentMin,
+            reach: referenceReach(references, 0),
+        }),
+        {
+            ...valueAxisOption(config.secondaryAxis, false, label(1), { index: 1, reach: referenceReach(references, 1) }),
+            position: 'right',
+            splitLine: { show: false },
+            alignTicks: !percent && !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, context, options),
+    };
+}
+// 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) } : 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.
+function valueAxisFormats(config, extracted, axisIndexes, context, 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)), context)];
+    }
+    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)), context);
+    });
+}
+// 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 +1146,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,40 +1210,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" ('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, 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 {};
     }
@@ -544,11 +1329,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;
             },
@@ -556,4 +1341,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  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// 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 { isValid, parseISO } 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  DAY_SHORT,\n  formatLocalDate,\n  formatNumber,\n  formatPlainNumber,\n  hasNumberFormat,\n  MONTH_DAY,\n  MONTH_LONG,\n  MONTH_YEAR,\n  resolveChartNumberFormat,\n} from './format';\nimport {\n  AxisChartType,\n  ChartConfig,\n  ChartGranularity,\n  ChartMeasure,\n  ChartReference,\n  ChartValueAxis,\n  ComponentData,\n  GRANULARITY_OPTIONS,\n  LegendPosition,\n  ListColumn,\n  ListConfig,\n  NumberFormatSpec,\n  ReportComponent,\n  ReportFormatContext,\n  ReportLocaleTag,\n  WaterfallStepKind,\n} from './interfaces/report.interface';\nimport { escapeHtml } from './text';\nimport {\n  REPORT_CHART_COLOR_BY_NAME,\n  REPORT_CHART_COLORS,\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// 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.\ninterface ValueAxisExtras {\n  index?: ValueAxisIndex;\n  percentMin?: number;\n  reach?: ReferenceReach;\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 and its\n// data item as given (a number, or an object carrying the raw value).\ninterface DataLabelParams {\n  value?: unknown;\n  data?: unknown;\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. null is a plain axis. Its ticks and its series'\n// data labels both write in it.\ninterface ValueAxisFormat {\n  spec: NumberFormatSpec;\n  chart: ChartNumberFormat;\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 = 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 = 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      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        measure,\n        measureIndex: 0,\n      });\n    }\n  } else {\n    for (const [measureIndex, measure] of measures.entries()) {\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        measure,\n        measureIndex,\n      });\n    }\n  }\n\n  return { categories, series };\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  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 axisFormats = valueAxisFormats(config, extracted, axisIndexes, context, !!shares, references);\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    const stat = statLines ? measureMarkStat(extractedSeries.measure) : undefined;\n    const markLine = stat && statMarkLine(\n      seriesShares ?? extractedSeries.values,\n      stat,\n      seriesShares ? shareWriter(context) : 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: 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 : seriesColor(extractedSeries),\n        labels: dataLabelOption(config.dataLabels, dataLabelFormatter(\n          extractedSeries.measure,\n          axisFormats[axisIndexes[index]] ?? null,\n          !!seriesShares,\n          context,\n        )),\n      },\n    );\n\n    return markLine ? { ...option, markLine } as SeriesOption : option;\n  });\n\n  if (colorBy && drawsStatLines(config) && series.length) {\n    series[0] = colorByStatLine(series[0], extracted, context);\n  }\n\n  const percentMin = shares ? percentAxisMin(shares) : undefined;\n  const categoryAxis = categoryAxisOption(config, data, extracted.categories, horizontal, context.locale);\n  const valueAxis = twoAxes\n    ? twoValueAxesOption(config, axisFormats, context, percentMin, references)\n    : valueAxisOption(config.valueAxis, horizontal, percentMin === undefined\n      ? valueAxisLabel(axisFormats[0], context)\n      : percentAxisLabel(context), { percentMin, reach: referenceReach(references, 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.\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      : { trigger: colorBy ? 'item' : 'axis' },\n    xAxis: horizontal ? valueAxis : categoryAxis,\n    yAxis: horizontal ? categoryAxis : valueAxis,\n    series: [...series, ...referenceCarriers(references, extracted.categories)],\n  };\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): SeriesOption {\n  const measure = extracted.series[0]?.measure;\n  const stat = measureMarkStat(measure);\n  const markLine = stat && statMarkLine(\n    colorByValues(extracted),\n    stat,\n    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 pointValue = (item: number | null | ShareDataItem) => (isShareDataItem(item) ? item.value : item);\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    min: range.min ?? reachMin(extras.reach),\n    max: range.max ?? reachMax(extras.reach),\n    interval: range.interval,\n    axisLabel,\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. Without a range on either axis the second axis\n// 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.\nfunction twoValueAxesOption(\n  config: ChartConfig,\n  axisFormats: (ValueAxisFormat | null)[],\n  context: ReportFormatContext,\n  percentMin: number | undefined,\n  references: DrawnReference[],\n) {\n  const percent = percentMin !== undefined;\n  const label = (axisIndex: ValueAxisIndex) => valueAxisLabel(axisFormats[axisIndex] ?? null, context);\n\n  return [\n    valueAxisOption(config.valueAxis, false, percent ? percentAxisLabel(context) : label(0), {\n      index: 0,\n      percentMin,\n      reach: referenceReach(references, 0),\n    }),\n    {\n      ...valueAxisOption(config.secondaryAxis, false, label(1), { index: 1, reach: referenceReach(references, 1) }),\n      position: 'right' as const,\n      splitLine: { show: false },\n      alignTicks: !percent && !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, 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) } : 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.\nfunction valueAxisFormats(\n  config: ChartConfig,\n  extracted: ExtractedChartSeries,\n  axisIndexes: ValueAxisIndex[],\n  context: 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      context,\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      context,\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"]}