@firestitch/report 18.6.1 → 18.8.0

package/esm2022/app/reports/format.mjs

@@ -1,55 +1,620 @@
-import { format, isValid, parseISO } from 'date-fns';
+import { isValid, parseISO } from 'date-fns';
 import { formatInTimeZone, toZonedTime } from 'date-fns-tz';
-// Measure-value formatting shared by the KPI renderer and the exports — the
-// config's `format` (number | percent | currency) and `precision` mean the same
-// thing on screen, in PowerPoint and in PDF.
-// percent takes a 0-1 ratio and shows it as a percentage: 0.3 reads 30%. With
-// no precision it shows at most one decimal (0.037 reads 3.7%); a named
-// precision counts the decimals of the percentage, not of the ratio, so
-// precision 1 shows 0.3 as 30.0%. An older server sends percent values already
-// x100 (38.5 for 38.5%); its reports carry no `percentFormat`, and the caller
-// passes ratioPercent false so the value is printed as it came, with a % sign.
-//
-// When the measure names a precision it is pinned as BOTH the minimum and the
-// maximum, so a column of rates lines up instead of each value showing however
-// many decimals it happens to need. Undefined leaves each format's own default
-// alone.
-function getFractionDigits(precision) {
-    return Number.isFinite(precision)
-        ? { minimumFractionDigits: precision, maximumFractionDigits: precision }
-        : {};
-}
-export function formatMeasureValue(value, format, precision, ratioPercent = true) {
-    if (value === null || value === undefined || value === '') {
-        return '—';
+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';
+// What a report reads when the server names no usable locale or currency: an
+// older server that sends neither, or a value this browser's Intl cannot use.
+// Never the browser's own locale, so every viewer of a report sees the same text.
+export const REPORT_FALLBACK_LOCALE = 'en-US';
+export const REPORT_FALLBACK_CURRENCY = 'USD';
+export const DEFAULT_FORMAT_CONTEXT = Object.freeze({
+    locale: REPORT_FALLBACK_LOCALE,
+    currency: REPORT_FALLBACK_CURRENCY,
+    ratioPercent: true,
+});
+const CURRENCY_PATTERN = /^[A-Z]{3}$/;
+// The server's resolved locale as one this browser can format in. A malformed
+// tag ('en_CA') makes supportedLocalesOf throw, and one Intl has no data for
+// ('xx-YY') comes back empty; both read the fallback.
+export function resolveReportLocale(tag) {
+    if (!tag) {
+        return REPORT_FALLBACK_LOCALE;
+    }
+    try {
+        return Intl.NumberFormat.supportedLocalesOf([tag])[0] ?? REPORT_FALLBACK_LOCALE;
+    }
+    catch {
+        return REPORT_FALLBACK_LOCALE;
+    }
+}
+// The server's resolved currency as one Intl can label. The server decides
+// which codes name money; this only guards against a code Intl cannot take at
+// all. It is never checked against the runtime's own currency list, which
+// differs between browsers and leaves out codes the server offers (VEF, MRO),
+// so every viewer labels a report's money the same way.
+export function resolveReportCurrency(code) {
+    if (!code || !CURRENCY_PATTERN.test(code)) {
+        return REPORT_FALLBACK_CURRENCY;
+    }
+    try {
+        numberFormat(REPORT_FALLBACK_LOCALE, { style: 'currency', currency: code });
+        return code;
+    }
+    catch {
+        return REPORT_FALLBACK_CURRENCY;
+    }
+}
+// The one place a report's format context is built: the server's effective
+// locale and currency (absent on an older server, which then reads en-US/USD)
+// and whether its percent measures arrive as 0-1 ratios.
+export function resolveFormatContext(report) {
+    return {
+        locale: resolveReportLocale(report.effectiveLocale),
+        currency: resolveReportCurrency(report.effectiveCurrency),
+        ratioPercent: report.percentFormat === 'ratio',
+    };
+}
+// Building an Intl formatter is far slower than using one, and a chart formats
+// every tick and tooltip value, so each distinct locale + options (+ zone) is
+// built once and reused.
+const NUMBER_FORMATS = new Map();
+const DATE_FORMATS = new Map();
+export function numberFormat(locale, options) {
+    const key = `${locale}|${JSON.stringify(options)}`;
+    let formatter = NUMBER_FORMATS.get(key);
+    if (!formatter) {
+        formatter = new Intl.NumberFormat(locale, options);
+        NUMBER_FORMATS.set(key, formatter);
+    }
+    return formatter;
+}
+// No zone formats in the browser's own zone, which is right for a calendar day
+// parsed as local midnight: the day printed is the day stored.
+export function dateFormat(locale, options, timeZone) {
+    const key = `${locale}|${JSON.stringify(options)}|${timeZone ?? ''}`;
+    let formatter = DATE_FORMATS.get(key);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat(locale, { ...options, timeZone });
+        DATE_FORMATS.set(key, formatter);
+    }
+    return formatter;
+}
+// Number formatting: the one engine behind every numeric slot (a chart
+// measure, a KPI measure, a list column, a cross-tab's cells), so a format
+// means the same thing on screen, in the PDF and in PowerPoint. The data stays
+// raw; only what is shown changes. The rules:
+// - Empty: null, undefined, '', '-' and a non-finite number print the caller's
+//   `empty` ('—' unless it names another).
+// - Numeric: a finite number, or a string that spells one plainly ('1234.50',
+//   '-3e2'). Anything else ('$1,234', an id with letters, ' ') prints as it
+//   came, since a column the SQL already formatted is text.
+// - Styles: number is a plain decimal; currency is the report's currency
+//   written in its locale with its symbol (USD reads '$1,235' in en-US and
+//   'US$1,235' in en-CA; EUR reads '1 235 €' in fr-FR); percent takes a 0-1
+//   ratio (0.3 reads 30%), or, from an older server that sends percent values
+//   already x100, a decimal with a % sign. Precision or units without a format
+//   mean number.
+// - Decimals: a precision pins both the minimum and the maximum, so a column
+//   of rates lines up. Without one: at most one for a percent and for an
+//   abbreviated value (1.2K), whole units for currency, the locale's default
+//   for a number.
+// - Units: thousands and millions divide and add a K or M after the digits
+//   ('$1.2K', '1,2K $'); auto picks per value by size, and a value that would
+//   round to 1000K reads 1M. Units never apply to a percent.
+// - Negatives keep the locale's leading minus. A negative that rounds to zero
+//   prints as zero, never '-0'.
+// - Rounding is Intl's, on the digits shown. Every value is written in the
+//   context's locale, never the browser's.
+// The most decimals a precision pins: the server's schema bound.
+const MAX_PRECISION = 6;
+// At most one decimal for a percent, and for an abbreviated value (1.2K).
+const PERCENT_DECIMALS = 1;
+const SCALED_DECIMALS = 1;
+// Money shows whole units unless a precision asks for decimals.
+const CURRENCY_DECIMALS = 0;
+// A currency axis whose ticks need decimals shows cents, not tenths.
+const CURRENCY_AXIS_DECIMALS = 2;
+// What a missing value prints unless the caller names its own.
+const EMPTY_VALUE = '—';
+// The tick count a value axis aims for, as ECharts' splitNumber default.
+const AXIS_TICKS = 5;
+// A change's sign: a plus on a positive value, nothing on zero.
+const SIGNED = { signDisplay: 'exceptZero' };
+const NUMERIC_PATTERN = /^\s*[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?\s*$/;
+// The formatToParts types that carry a number's digits and separators.
+const NUMBER_PARTS = new Set(['integer', 'group', 'decimal', 'fraction']);
+const DIGIT_PARTS = new Set(['integer', 'fraction']);
+const UNIT_SCALES = new Map([
+    [ReportNumberUnits.Thousands, { divisor: 1e3, suffix: 'K', commas: ',' }],
+    [ReportNumberUnits.Millions, { divisor: 1e6, suffix: 'M', commas: ',,' }],
+]);
+// The value as a finite number when it is one or plainly spells one, else
+// null.
+export function toFiniteNumber(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value !== 'string' || !NUMERIC_PATTERN.test(value)) {
+        return null;
     }
     const numeric = Number(value);
-    if (!Number.isFinite(numeric)) {
+    return Number.isFinite(numeric) ? numeric : null;
+}
+// Whether a slot asks to be formatted at all. A slot without these keys, or a
+// list column whose format is date, keeps its own rendering. Units none is the
+// same as no units key, as it is on the server.
+export function hasNumberFormat(spec) {
+    if (!spec || spec.format === ReportListColumnFormat.Date) {
+        return false;
+    }
+    return valueFormat(spec) !== null
+        || (spec.precision ?? null) !== null
+        || ((spec.units ?? ReportNumberUnits.None) !== ReportNumberUnits.None);
+}
+// The units a value is written in. auto decides by the magnitude: a million
+// and up reads M, a thousand and up K, unless the value would then round to
+// 1000K at these decimals, which reads 1M instead.
+export function resolveUnits(units, magnitude, decimals) {
+    switch (units) {
+        case ReportNumberUnits.Thousands:
+        case ReportNumberUnits.Millions:
+            return units;
+        case ReportNumberUnits.Auto:
+            return autoUnits(Math.abs(magnitude), decimals);
+        default:
+            return ReportNumberUnits.None;
+    }
+}
+function autoUnits(magnitude, decimals) {
+    if (magnitude >= 1e6) {
+        return ReportNumberUnits.Millions;
+    }
+    if (magnitude < 1e3) {
+        return ReportNumberUnits.None;
+    }
+    return roundTo(magnitude / 1e3, decimals) >= 1000
+        ? ReportNumberUnits.Millions
+        : ReportNumberUnits.Thousands;
+}
+// The value rounded as Intl rounds it for display, so the K-to-M promotion
+// agrees with the digits actually shown.
+function roundTo(value, decimals) {
+    const digits = clampDecimals(decimals) ?? 0;
+    // A fixed locale only so Number() can parse the rounded digits back.
+    return Number(numberFormat(REPORT_FALLBACK_LOCALE, {
+        useGrouping: false,
+        minimumFractionDigits: 0,
+        maximumFractionDigits: digits,
+    }).format(value));
+}
+// One value, written by the rules above.
+export function formatNumber(value, spec, context, options = {}) {
+    if (isEmptyValue(value)) {
+        return options.empty ?? EMPTY_VALUE;
+    }
+    const numeric = toFiniteNumber(value);
+    if (numeric === null) {
         return String(value);
     }
-    const fractionDigits = getFractionDigits(precision);
-    switch (format) {
-        case 'percent':
-            if (!ratioPercent) {
-                return `${new Intl.NumberFormat(undefined, { maximumFractionDigits: 1, ...fractionDigits }).format(numeric)}%`;
-            }
-            return new Intl.NumberFormat(undefined, {
-                style: 'percent',
-                maximumFractionDigits: 1,
-                ...fractionDigits,
-            }).format(numeric);
-        case 'currency':
-            return new Intl.NumberFormat(undefined, {
-                style: 'currency',
-                currency: 'USD',
-                // Whole dollars unless the measure asks for decimals — cents were
-                // unrepresentable before, because this was hardcoded to 0.
-                maximumFractionDigits: 0,
-                ...fractionDigits,
-            }).format(numeric);
+    const style = resolveStyle(spec);
+    const precision = clampDecimals(spec?.precision);
+    const units = style === ReportValueFormat.Percent
+        ? ReportNumberUnits.None
+        : options.units ?? resolveUnits(spec?.units, numeric, precision ?? SCALED_DECIMALS);
+    const scale = UNIT_SCALES.get(units);
+    const decimals = clampDecimals(options.decimals) ?? precision;
+    const formatter = numberFormat(context.locale, {
+        ...styleOptions(style, context, decimals, !!scale),
+        ...(options.signed ? SIGNED : {}),
+    });
+    const text = writeNumber(formatter, (numeric === 0 ? 0 : numeric) / (scale?.divisor ?? 1), scale?.suffix);
+    return style === ReportValueFormat.Percent && !context.ratioPercent ? `${text}%` : text;
+}
+function isEmptyValue(value) {
+    return value === null
+        || value === undefined
+        || value === ''
+        || value === '-'
+        || (typeof value === 'number' && !Number.isFinite(value));
+}
+// The value format a slot names, or null when it names none (or only date).
+function valueFormat(spec) {
+    return Object.values(ReportValueFormat).find((format) => format === spec?.format) ?? null;
+}
+function resolveStyle(spec) {
+    return valueFormat(spec) ?? ReportValueFormat.Number;
+}
+// A usable decimal count, or null. A stored value outside the schema's bounds
+// is brought inside them rather than thrown on by Intl.
+function clampDecimals(decimals) {
+    return typeof decimals === 'number' && Number.isFinite(decimals)
+        ? Math.min(MAX_PRECISION, Math.max(0, Math.round(decimals)))
+        : null;
+}
+function styleOptions(style, context, decimals, scaled) {
+    const fractionDigits = fractionDigitOptions(decimals, defaultDecimals(style, scaled));
+    switch (style) {
+        case ReportValueFormat.Currency:
+            return { ...currencyOptions(context.currency), ...fractionDigits };
+        case ReportValueFormat.Percent:
+            return context.ratioPercent ? { style: 'percent', ...fractionDigits } : fractionDigits;
+        default:
+            return fractionDigits;
+    }
+}
+function currencyOptions(currency) {
+    return { style: 'currency', currency, currencyDisplay: 'symbol' };
+}
+// The most decimals a style shows when nothing pins them; null leaves Intl's
+// own default.
+function defaultDecimals(style, scaled) {
+    if (scaled) {
+        return SCALED_DECIMALS;
+    }
+    switch (style) {
+        case ReportValueFormat.Percent:
+            return PERCENT_DECIMALS;
+        case ReportValueFormat.Currency:
+            return CURRENCY_DECIMALS;
         default:
-            return new Intl.NumberFormat(undefined, fractionDigits).format(numeric);
+            return null;
+    }
+}
+// Pinned decimals set both bounds. Otherwise a maximum also sets the minimum
+// to zero, so no engine throws on a maximum below a currency's own minimum.
+function fractionDigitOptions(pinned, maximum) {
+    if (pinned !== null) {
+        return { minimumFractionDigits: pinned, maximumFractionDigits: pinned };
+    }
+    return maximum === null ? {} : { minimumFractionDigits: 0, maximumFractionDigits: maximum };
+}
+// The formatted value, with the units letter after its digits. A negative
+// whose shown digits are all zero is written as zero, so no '-0' appears.
+function writeNumber(formatter, value, suffix) {
+    if (value >= 0 && !suffix) {
+        return formatter.format(value);
+    }
+    const parts = formatter.formatToParts(value);
+    if (value < 0 && !hasNonZeroDigit(formatter, parts)) {
+        return writeNumber(formatter, 0, suffix);
+    }
+    if (!suffix) {
+        return parts.map((part) => part.value).join('');
+    }
+    const last = parts.reduce((found, part, index) => NUMBER_PARTS.has(part.type) ? index : found, -1);
+    return [
+        ...parts.slice(0, last + 1).map((part) => part.value),
+        suffix,
+        ...parts.slice(last + 1).map((part) => part.value),
+    ].join('');
+}
+// Compared with the locale's own zero, so a numbering system other than
+// 0-9 is read correctly.
+function hasNonZeroDigit(formatter, parts) {
+    const zero = formatter.formatToParts(0).find((part) => part.type === 'integer')?.value ?? '0';
+    return parts.some((part) => DIGIT_PARTS.has(part.type)
+        && Array.from(part.value).some((character) => character !== zero));
+}
+// Output values: a column the server marks in ComponentData.outputs (a
+// compared value, a rank, a share) written by what it is. The data stays raw;
+// every number still goes through formatNumber. The rules:
+// - The format: a slot's own explicit format always wins. Otherwise a current,
+//   prior or change column takes its source measure's format; a percent change
+//   is a percent; a rank is a whole number; a share is a percent to 1 decimal.
+//   An own precision or units still applies over those defaults.
+// - Signs: a change and a percent change are signed ('+579', '-31.1%').
+// - Points: a change of a percent-format value, and any share change, is a
+//   difference of two rates, so it prints in percentage points, signed and to
+//   1 decimal unless a precision pins others: 0.1 reads '+10.0 pp'.
+// - Missing: a missing prior, or a change or percent change left empty by
+//   one, prints '—' titled with the floor ('No baseline: no data before
+//   Mar 3, 2026'), or for a rank or a share with the period the row was
+//   absent from ('No rank in the prior period'); a percent change over a prior of 0 prints 'n/a' titled
+//   'Prior was 0'. Any other missing value prints '—' (or the caller's empty).
+// - Rank change: prior minus current, so a rise is positive: '▲ 2', '▼ 1',
+//   '–' for none, and 'new' for an empty change whose prior rank is missing
+//   or not passed (a row always has a current rank, so only the prior lacks).
+// A percent change and a share are 0-1 fractions whatever the report's
+// percentFormat: the server computes them, never a stored value.
+// A missing comparison value prints EMPTY_VALUE whatever the caller's empty.
+const NOT_APPLICABLE_VALUE = 'n/a';
+const NEW_RANK_VALUE = 'new';
+const RANK_UNCHANGED_VALUE = '–';
+const RANK_UP_MARK = '▲';
+const RANK_DOWN_MARK = '▼';
+const POINTS_SUFFIX = 'pp';
+const NO_PRIOR_RANK_TITLE = 'No rank in the prior period';
+const NO_PRIOR_SHARE_TITLE = 'No share in the prior period';
+// Percentage points and a share are written to one decimal unless pinned.
+const POINTS_DECIMALS = 1;
+const SHARE_DECIMALS = 1;
+const RANK_DEFAULT_SPEC = Object.freeze({ format: ReportValueFormat.Number, precision: 0 });
+const SHARE_DEFAULT_SPEC = Object.freeze({
+    format: ReportValueFormat.Percent,
+    precision: SHARE_DECIMALS,
+});
+const PERCENT_CHANGE_DEFAULT_SPEC = Object.freeze({ format: ReportValueFormat.Percent });
+// One output value, written by the rules above. Without output metadata (a
+// plain measure column, an older server) it is formatNumber with the slot's
+// own format.
+export function formatOutputValue(value, output, spec, context, options = {}) {
+    if (!output) {
+        return plainOutput(formatNumber(value, spec, context, { empty: options.empty }));
+    }
+    if (output.kind === 'rank' && output.role === 'change') {
+        return formatRankChange(value, spec, context, options);
+    }
+    const role = output.role;
+    const effective = outputFormatSpec(output, spec, options.measureSpec);
+    if (isEmptyValue(value)) {
+        return missingOutput(output, context, options);
+    }
+    if (role === 'change' && isPointsChange(output, effective)) {
+        return plainOutput(formatPoints(value, output, effective, context));
+    }
+    const signed = role === 'change' || role === 'percent_change';
+    const ratioContext = role === 'percent_change' || output.kind === 'share'
+        ? { ...context, ratioPercent: true }
+        : context;
+    return plainOutput(formatNumber(value, effective, ratioContext, { signed }));
+}
+// The alias of the output that plays `role` in the same lane as `alias`: the
+// same measure and kind, and (for a prior, change or percent change) the same
+// prior lane. A measure compares against one lane only (two compares on one
+// value are two measures), so a current value's lane is whichever one its
+// measure's prior columns carry, lane 2 as readily as lane 1. A change column
+// finds its prior this way to pass as OutputValueOptions.prior. null when the
+// server sends no such column.
+export function laneOutputAlias(outputs, alias, role) {
+    const source = outputs?.[alias];
+    if (!source) {
+        return null;
+    }
+    const anyLane = source.role === 'current' || source.offset === null;
+    const found = Object.entries(outputs ?? {}).find(([, meta]) => meta.measure === source.measure
+        && meta.kind === source.kind
+        && meta.role === role
+        && (role === 'current' || (anyLane ? meta.offset !== null : meta.offset === source.offset)));
+    return found ? found[0] : null;
+}
+function plainOutput(text) {
+    return { text, title: null };
+}
+// The format an output is written in: the slot's own explicit format, else
+// the default for what it holds, with any own precision or units over it.
+function outputFormatSpec(output, own, measureSpec) {
+    if (valueFormat(own) !== null) {
+        return own;
+    }
+    if (output.kind === 'rank') {
+        return withOwnDigits(RANK_DEFAULT_SPEC, own);
+    }
+    if (output.kind === 'share') {
+        return withOwnDigits(SHARE_DEFAULT_SPEC, own);
+    }
+    if (output.role === 'percent_change') {
+        return withOwnDigits(PERCENT_CHANGE_DEFAULT_SPEC, own);
+    }
+    return measureSpec ? withOwnDigits(measureSpec, own) : own ?? null;
+}
+// The base format with the slot's own precision and units over it.
+function withOwnDigits(base, own) {
+    return {
+        ...base,
+        ...((own?.precision ?? null) !== null ? { precision: own.precision } : {}),
+        ...((own?.units ?? null) !== null ? { units: own.units } : {}),
+    };
+}
+// A change between two rates: a share's, or a percent-format value's.
+function isPointsChange(output, spec) {
+    return output.kind === 'share' || resolveStyle(spec) === ReportValueFormat.Percent;
+}
+// A rate change in percentage points. A share and a 0-1 percent are scaled
+// x100; an older server's percent values already are.
+function formatPoints(value, output, spec, context) {
+    const numeric = toFiniteNumber(value);
+    if (numeric === null) {
+        return String(value);
     }
+    const points = output.kind === 'share' || context.ratioPercent ? numeric * 100 : numeric;
+    const decimals = clampDecimals(spec?.precision) ?? POINTS_DECIMALS;
+    const text = formatNumber(points, { format: ReportValueFormat.Number }, context, { decimals, signed: true });
+    return `${text} ${POINTS_SUFFIX}`;
+}
+// A missing output value. A missing prior, or a delta a missing prior left
+// empty, has no baseline; a percent change over a zero prior has none to
+// divide by.
+function missingOutput(output, context, options) {
+    const role = output.role;
+    if (role === 'prior') {
+        return { text: EMPTY_VALUE, title: missingPriorTitle(output, options.floor, context.locale) };
+    }
+    if (role === 'change' || role === 'percent_change') {
+        const prior = options.prior;
+        if (role === 'percent_change' && toFiniteNumber(prior) === 0) {
+            return { text: NOT_APPLICABLE_VALUE, title: 'Prior was 0' };
+        }
+        return {
+            text: EMPTY_VALUE,
+            title: prior !== undefined && isEmptyValue(prior)
+                ? missingPriorTitle(output, options.floor, context.locale)
+                : null,
+        };
+    }
+    return plainOutput(options.empty ?? EMPTY_VALUE);
+}
+// Why a prior is missing. A value's prior is missing when its window ends
+// before the data starts. A rank's or a share's is missing when the row had
+// no rank or share in the prior period, whatever the floor.
+function missingPriorTitle(output, floor, locale) {
+    if (output.kind === 'rank') {
+        return NO_PRIOR_RANK_TITLE;
+    }
+    if (output.kind === 'share') {
+        return NO_PRIOR_SHARE_TITLE;
+    }
+    return noBaselineTitle(floor, locale);
+}
+function noBaselineTitle(floor, locale) {
+    const day = floor ? formatDay(floor, locale) : '';
+    return day ? `No baseline: no data before ${day}` : 'No baseline';
+}
+// A rank change: prior rank minus current, so moving up is positive.
+function formatRankChange(value, spec, context, options) {
+    if (isEmptyValue(value)) {
+        return isEmptyValue(options.prior)
+            ? { text: NEW_RANK_VALUE, title: NO_PRIOR_RANK_TITLE }
+            : plainOutput(EMPTY_VALUE);
+    }
+    const numeric = toFiniteNumber(value);
+    if (numeric === null) {
+        return plainOutput(String(value));
+    }
+    const rankSpec = valueFormat(spec) !== null ? spec : withOwnDigits(RANK_DEFAULT_SPEC, spec);
+    const places = formatNumber(Math.abs(numeric), rankSpec, context);
+    if (places === formatNumber(0, rankSpec, context)) {
+        return plainOutput(RANK_UNCHANGED_VALUE);
+    }
+    return plainOutput(`${numeric > 0 ? RANK_UP_MARK : RANK_DOWN_MARK} ${places}`);
+}
+// A chart's value axis takes a format only when every measure on it agrees on
+// the style (each measure's format, number when it names none) and at least
+// one of them names a format. The first measure that does gives the axis its
+// precision and units. Otherwise null: the axis keeps its default ticks on
+// screen and in PowerPoint, and each series still formats its own tooltips.
+export function axisNumberFormat(measures) {
+    const style = measures.length ? resolveStyle(measures[0]) : null;
+    if (style === null || measures.some((measure) => resolveStyle(measure) !== style)) {
+        return null;
+    }
+    const formatted = measures.find((measure) => hasNumberFormat(measure));
+    return formatted ? numberFormatSpec(formatted) : null;
+}
+function numberFormatSpec(spec) {
+    return {
+        ...(spec.format !== undefined ? { format: spec.format } : {}),
+        ...(spec.precision !== undefined ? { precision: spec.precision } : {}),
+        ...(spec.units !== undefined ? { units: spec.units } : {}),
+    };
+}
+// How a chart's value axis writes its ticks: the units decided once from the
+// axis peak, and the decimals the precision pins, else as many as the axis's
+// tick step needs (a percent axis up to 0.12% steps by 0.02%, two decimals).
+// Pinned decimals keep the ticks distinct, and PowerPoint can only pin them.
+export function resolveChartNumberFormat(spec, peak, context) {
+    const style = resolveStyle(spec);
+    const precision = clampDecimals(spec.precision);
+    const units = style === ReportValueFormat.Percent
+        ? ReportNumberUnits.None
+        : resolveUnits(spec.units, peak, precision ?? SCALED_DECIMALS);
+    return { units, decimals: precision ?? axisDecimals(style, units, peak, context) };
+}
+// The decimals the axis's nice tick step needs. A plain, unabbreviated number
+// pins none (null): its ticks keep their own decimals. An unscaled currency
+// axis that needs decimals shows cents, and a K/M axis keeps its step's
+// decimals ('$0.5M', not '$0.50M').
+function axisDecimals(style, units, peak, context) {
+    const scale = UNIT_SCALES.get(units);
+    if (style === ReportValueFormat.Number && !scale) {
+        return null;
+    }
+    const shownPeak = style === ReportValueFormat.Percent && context.ratioPercent
+        ? Math.abs(peak) * 100
+        : Math.abs(peak) / (scale?.divisor ?? 1);
+    const step = niceStep(shownPeak / AXIS_TICKS);
+    const decimals = step > 0 ? clampDecimals(-Math.floor(Math.log10(step))) ?? 0 : 0;
+    return style === ReportValueFormat.Currency && decimals > 0 && !scale ? CURRENCY_AXIS_DECIMALS : decimals;
+}
+// ECharts' nice(): the round number (1, 2, 3, 5 or 10 times a power of ten) a
+// rough tick step snaps to.
+function niceStep(rough) {
+    if (!(rough > 0) || !Number.isFinite(rough)) {
+        return 0;
+    }
+    const exponent = Math.floor(Math.log10(rough));
+    const power = Math.pow(10, exponent);
+    const fraction = rough / power;
+    let nice = 10;
+    if (fraction < 1.5) {
+        nice = 1;
+    }
+    else if (fraction < 2.5) {
+        nice = 2;
+    }
+    else if (fraction < 4) {
+        nice = 3;
+    }
+    else if (fraction < 7) {
+        nice = 5;
+    }
+    return nice * power;
+}
+// PowerPoint's number format code for a formatted value axis, matching the
+// screen's ticks: '#,##0.0%' (percent), '"$"#,##0' (currency),
+// '#,##0.0,"K"' (thousands), '#,##0" $"' (fr-CA currency). A plain number
+// whose decimals are not pinned keeps chartAxisFormatCode's code. The code's
+// separators follow the opening machine's locale; the currency symbol and its
+// side follow the report's.
+export function numberFormatCode(spec, context, chart, series, stacked) {
+    const style = resolveStyle(spec);
+    const scale = style === ReportValueFormat.Percent ? undefined : UNIT_SCALES.get(chart.units);
+    if (style === ReportValueFormat.Number && !scale && chart.decimals === null) {
+        return chartAxisFormatCode(series, stacked);
+    }
+    const decimals = chart.decimals ?? 0;
+    const digits = `#,##0${decimals > 0 ? `.${'0'.repeat(decimals)}` : ''}`;
+    if (style === ReportValueFormat.Percent) {
+        return `${digits}${context.ratioPercent ? '%' : '"%"'}`;
+    }
+    const scaled = `${digits}${scale?.commas ?? ''}`;
+    const unit = scale?.suffix ?? '';
+    if (style !== ReportValueFormat.Currency) {
+        return unit ? `${scaled}"${unit}"` : scaled;
+    }
+    const symbol = currencySymbol(context);
+    return symbol.prefix
+        ? `"${symbol.text}"${scaled}${unit ? `"${unit}"` : ''}`
+        : `${scaled}"${unit}${symbol.text}"`;
+}
+const CURRENCY_SYMBOLS = new Map();
+function currencySymbol(context) {
+    const key = `${context.locale}|${context.currency}`;
+    let symbol = CURRENCY_SYMBOLS.get(key);
+    if (!symbol) {
+        const parts = numberFormat(context.locale, currencyOptions(context.currency)).formatToParts(1);
+        const currency = parts.findIndex((part) => part.type === 'currency');
+        const first = parts.findIndex((part) => NUMBER_PARTS.has(part.type));
+        const last = parts.reduce((found, part, index) => NUMBER_PARTS.has(part.type) ? index : found, -1);
+        const prefix = currency < first;
+        const text = (prefix ? parts.slice(Math.max(currency, 0), first) : parts.slice(last + 1))
+            .map((part) => part.value)
+            .join('')
+            .replace(/"/g, '');
+        symbol = { prefix, text };
+        CURRENCY_SYMBOLS.set(key, symbol);
+    }
+    return symbol;
+}
+// Every decimal a number has, grouped, in the locale: what ECharts prints by
+// default (its addCommas), but in the report's locale, so a chart's axis and
+// tooltip read like the rest of the report. 1234.5 reads 1,234.5 in en-US and
+// 1 234,5 in fr-CA. A non-numeric string is shown as it came, and anything
+// else non-numeric as '-', as ECharts shows it. As there, an infinite value
+// reads 'Infinity' and negative zero (a tick a float error leaves just below
+// zero) reads '0'.
+const PLAIN_NUMBER = { maximumFractionDigits: 20 };
+export function formatPlainNumber(value, locale) {
+    const numeric = typeof value === 'number'
+        ? value
+        : typeof value === 'string' && value.trim() !== '' ? Number(value) : NaN;
+    if (Number.isNaN(numeric)) {
+        return typeof value === 'string' ? value : '-';
+    }
+    if (!Number.isFinite(numeric)) {
+        return String(numeric);
+    }
+    return numberFormat(locale, PLAIN_NUMBER).format(numeric === 0 ? 0 : numeric);
 }
 // The axis peak at which a native chart's value axis gains thousands
 // separators. From here up the ticks are whole numbers in practice; below it
@@ -61,15 +626,19 @@ export const AXIS_SEPARATOR_THRESHOLD = 1000;
 // (where ticks are whole numbers) gets '#,##0', and a smaller range keeps
 // 'General' so fractional ticks (0.25, 0.5) are not rounded away.
 //
-// The peak counts a missing value as 0. A stacked chart's peak is its tallest
-// stack: the largest sum, per category, of every series' absolute value.
+// The peak is chartValuePeak's.
 export function chartAxisFormatCode(series, stacked) {
+    return chartValuePeak(series, stacked) >= AXIS_SEPARATOR_THRESHOLD ? '#,##0' : 'General';
+}
+// The largest magnitude a chart's value axis has to reach. A missing value
+// counts as 0. A stacked chart's peak is its tallest stack: the largest sum,
+// per category, of every series' absolute value.
+export function chartValuePeak(series, stacked) {
     const magnitudes = series.map((values) => values.map((value) => Math.abs(value ?? 0)));
-    const peak = stacked
+    return stacked
         ? Math.max(0, ...(magnitudes[0] ?? []).map((_, index) => magnitudes
             .reduce((sum, values) => sum + (values[index] ?? 0), 0)))
         : Math.max(0, ...magnitudes.flat());
-    return peak >= AXIS_SEPARATOR_THRESHOLD ? '#,##0' : 'General';
 }
 // The zone every date in a report is read in. The server resolves it (the
 // report's own zone, else the application's default reporting zone) and sends
@@ -80,6 +649,52 @@ export function chartAxisFormatCode(series, stacked) {
 export function resolveReportTimezone(report) {
     return report.effectiveTimezone ?? report.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
 }
+// The date shapes a report writes, each in the report's locale.
+// 'Jan 5, 2026' / '5 janv. 2026': a date cell, a filter bound.
+export const DAY_SHORT = { year: 'numeric', month: 'short', day: 'numeric' };
+// 'January 5, 2026' / '5 janvier 2026': an export cover's date line.
+export const DAY_LONG = { year: 'numeric', month: 'long', day: 'numeric' };
+// 'January' / 'janvier': a monthly period label (its year is added apart).
+export const MONTH_LONG = { month: 'long' };
+// 'January 2026' / 'janvier 2026': a monthly period label written in full.
+export const MONTH_YEAR = { year: 'numeric', month: 'long' };
+// 'Jan 5' / '5 janv.': a daily or weekly period label.
+export const MONTH_DAY = { month: 'short', day: 'numeric' };
+// A date in the locale. With a zone, the day it falls on there; without one,
+// the browser's zone, which keeps a calendar day parsed as local midnight
+// unshifted. It never throws, since a pipe or an export calls it per cell: an
+// invalid Date reads '', a malformed locale ('en_CA') reads the fallback
+// locale, and an unknown zone reads UTC, which still names a real day.
+export function formatLocalDate(date, locale, options, timeZone) {
+    if (Number.isNaN(date.getTime())) {
+        return '';
+    }
+    try {
+        return writeDate(dateFormat(locale, options, timeZone), date);
+    }
+    catch {
+        return formatFallbackDate(date, resolveReportLocale(locale), options, timeZone);
+    }
+}
+function formatFallbackDate(date, locale, options, timeZone) {
+    try {
+        return writeDate(dateFormat(locale, options, timeZone), date);
+    }
+    catch {
+        return writeDate(dateFormat(locale, options, 'UTC'), date);
+    }
+}
+// Intl writes a year below 1000 with only the digits it has ('Jan 1, 1'); a
+// date's year is always written with four ('Jan 1, 0001'), so a sentinel day
+// still reads as a date. Only such a year pays for formatToParts.
+function writeDate(formatter, date) {
+    if (date.getUTCFullYear() > 1000) {
+        return formatter.format(date);
+    }
+    return formatter.formatToParts(date)
+        .map((part) => part.type === 'year' ? part.value.padStart(4, '0') : part.value)
+        .join('');
+}
 const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
 const DATE_TIME_PATTERN = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(\.\d+)?$/;
 // A report row's date cell as a calendar day in the report's zone.
@@ -95,31 +710,276 @@ const DATE_TIME_PATTERN = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(\.\d+)?$/
 // - Anything else is shown as it came, and so is a value that has the shape
 //   but names no real day (a zero date '0000-00-00', or '2026-02-30'): one
 //   bad cell must not throw out of a pipe or abort an export.
-export function formatReportDate(value, timezone) {
+// The day is written in the report's locale: 'Jan 5, 2026' in en-US, '5 janv.
+// 2026' in fr-CA.
+export function formatReportDate(value, timezone, locale) {
     if (value === null || value === undefined || value === '') {
         return '';
     }
     const text = String(value);
     if (DATE_ONLY_PATTERN.test(text)) {
         const day = parseISO(text);
-        return isValid(day) ? format(day, 'MMM d, yyyy') : text;
+        return isValid(day) ? formatLocalDate(day, locale, DAY_SHORT) : text;
     }
     const dateTime = DATE_TIME_PATTERN.exec(text);
     if (!dateTime) {
         return text;
     }
     const instant = parseISO(`${dateTime[1]}T${dateTime[2]}Z`);
-    if (!isValid(instant)) {
-        return text;
+    return isValid(instant) ? formatLocalDate(instant, locale, DAY_SHORT, timezone) : text;
+}
+// The time of day an instant falls at in the report's zone: '2:23 PM' in
+// en-US, '14 h 23' in fr-CA.
+export const TIME_SHORT = { hour: 'numeric', minute: '2-digit' };
+// A window's inclusive days, as the server sends them: 'yyyy-MM-dd' calendar
+// days already in the report's zone. Like a date cell they are read as local
+// midnight and written with NO zone, so a viewer in any zone sees the days
+// sent. Both days: Intl's range in the locale ('Sep 1 – 30, 2026' in en-US,
+// '1–30 sept. 2026' in fr-CA, one date when they are the same day). One day:
+// an open window ('Since Sep 1, 2026', 'Through Sep 30, 2026'). Neither, or
+// days that are not real ones: ''.
+export function formatDayRange(start, end, locale, options = DAY_SHORT) {
+    const first = parseDay(start);
+    const last = parseDay(end);
+    if (first && last) {
+        return writeDayRange(first, last, locale, options);
+    }
+    if (first) {
+        return `Since ${formatLocalDate(first, locale, options)}`;
+    }
+    return last ? `Through ${formatLocalDate(last, locale, options)}` : '';
+}
+// The time a window ending today is cut at: the server's UTC
+// 'yyyy-MM-dd HH:mm:ss' instant, as a time of day in the report's zone. ''
+// for none, or for a value of another shape.
+export function formatThroughTime(through, timezone, locale) {
+    const dateTime = through ? DATE_TIME_PATTERN.exec(through) : null;
+    const instant = dateTime ? parseISO(`${dateTime[1]}T${dateTime[2]}Z`) : null;
+    return instant && isValid(instant) ? formatLocalDate(instant, locale, TIME_SHORT, timezone) : '';
+}
+// A comparison or timeframe window in one line: its days, and the time it is
+// cut at when it ends today on a date-and-time column ('Oct 1 – 2, 2026,
+// until 2:23 PM').
+export function formatDayWindow(meta, timezone, locale) {
+    const days = formatDayRange(meta.start, meta.end, locale);
+    const time = formatThroughTime(meta.through, timezone, locale);
+    return days && time ? `${days}, until ${time}` : days;
+}
+// One 'yyyy-MM-dd' day in the locale, written with no zone: 'Sep 1, 2026'.
+function formatDay(day, locale) {
+    const date = parseDay(day);
+    return date ? formatLocalDate(date, locale, DAY_SHORT) : '';
+}
+// A 'yyyy-MM-dd' day as local midnight, or null when it is not a real day.
+function parseDay(day) {
+    if (!day || !DATE_ONLY_PATTERN.test(day)) {
+        return null;
     }
-    // An unknown zone makes date-fns-tz throw; UTC still names a real day.
+    const date = parseISO(day);
+    return isValid(date) ? date : null;
+}
+// Intl's range writes the shared month and year once. A malformed locale
+// reads the fallback; a runtime that cannot write ranges joins two dates.
+function writeDayRange(first, last, locale, options) {
+    const [from, to] = first <= last ? [first, last] : [last, first];
+    for (const tag of [locale, resolveReportLocale(locale)]) {
+        try {
+            return dateFormat(tag, options).formatRange(from, to);
+        }
+        catch {
+            // The next locale, then the joined dates.
+        }
+    }
+    return `${formatLocalDate(from, locale, options)} – ${formatLocalDate(to, locale, options)}`;
+}
+// English names for a locale and a currency, for the settings selects. The
+// interface stays English whatever the report's locale: 'fr-CA' reads
+// 'Canadian French', 'CAD' reads 'Canadian Dollar'. A runtime without the
+// names shows the code.
+export function localeName(tag) {
+    return displayName('language', tag);
+}
+export function currencyName(code) {
+    return displayName('currency', code);
+}
+function displayName(type, code) {
     try {
-        return formatInTimeZone(instant, timezone, 'MMM d, yyyy');
+        return new Intl.DisplayNames(['en'], { type }).of(code) ?? code;
     }
     catch {
-        return formatInTimeZone(instant, 'UTC', 'MMM d, yyyy');
+        return code;
     }
 }
+// Comparison, window and KPI wording. The server sends codes and fields,
+// never sentences (a window's description is for the agent and the exports'
+// notes, not the screen); the interface words them here, in English like
+// every other label, with any day written in the report's locale.
+const GRANULARITY_UNITS = {
+    day: { one: 'day', many: 'days' },
+    week: { one: 'week', many: 'weeks' },
+    month: { one: 'month', many: 'months' },
+    quarter: { one: 'quarter', many: 'quarters' },
+    year: { one: 'year', many: 'years' },
+};
+// What a prior lane is called: always so for a named period, and for the
+// previous period when the server names no unit for it.
+const AGAINST_PHRASES = {
+    previous_period: 'previous period',
+    previous_week: 'previous week',
+    previous_month: 'previous month',
+    previous_quarter: 'previous quarter',
+    previous_year: 'previous year',
+    range: 'custom range',
+};
+// A prior lane's label, from its offset rather than from the measure, so a
+// chart regrouped by the viewer says what it now compares. A named period
+// reads by its name whatever shift carries it ('vs previous quarter' for 3
+// months, 'vs previous year' for 364 days or 52 weeks, 'vs custom range').
+// Only the previous period is worded from its unit and count: 'vs previous
+// week', 'vs previous 3 months', 'vs previous 8 days' (a day-length shift).
+export function comparisonOffsetLabel(offset) {
+    return `vs ${offsetPhrase(offset)}`;
+}
+function offsetPhrase(offset) {
+    if (offset.against !== 'previous_period' || !offset.unit || !offset.count) {
+        return AGAINST_PHRASES[offset.against] ?? AGAINST_PHRASES.previous_period;
+    }
+    return offset.count === 1
+        ? `previous ${GRANULARITY_UNITS[offset.unit].one}`
+        : `previous ${offset.count} ${GRANULARITY_UNITS[offset.unit].many}`;
+}
+// One comparison note as a sentence. The comparison, when given, names the
+// period compared with (its first prior lane).
+export function comparisonNoteText(code, comparison) {
+    const offset = comparison?.offsets?.[0] ?? null;
+    const compared = offset ? `Compared with the ${offsetPhrase(offset)}` : null;
+    switch (code) {
+        case 'no_window':
+            return 'Pick a date range to see the comparison.';
+        case 'unit_inferred':
+            return compared
+                ? `${compared}, judged from the dates picked.`
+                : 'The period compared with was judged from the dates picked.';
+        case 'window_in_future':
+            return 'The date range starts after today, so there is nothing to compare yet.';
+        case 'other_date_filter':
+            return 'A date filter on another column also applies to both periods.';
+        case 'grain_followed':
+            return compared
+                ? `${compared}, following the grouping picked.`
+                : 'The comparison follows the grouping picked.';
+        default:
+            return '';
+    }
+}
+// What a windowed value is: 'Rolling 3-month total', 'Month-to-date total',
+// 'Running total since the start of the data', then its days when the server
+// sends them ('Rolling 7-day average, Sep 24 – 30, 2026'). granularity is the
+// grouping the rows are drawn at (ComponentData.granularity), which names a
+// rolling window authored in periods of the axis.
+export function windowText(meta, locale, granularity) {
+    const days = formatDayRange(meta.start, meta.end, locale);
+    const phrase = windowPhrase(meta, granularity ?? null);
+    return days ? `${phrase}, ${days}` : phrase;
+}
+function windowPhrase(meta, granularity) {
+    const value = meta.average ? 'average' : 'total';
+    switch (meta.kind) {
+        case 'running':
+            return meta.fromBeginning ? `Running ${value} since the start of the data` : `Running ${value}`;
+        case 'to_date': {
+            const reset = meta.resetEvery ? GRANULARITY_UNITS[meta.resetEvery].one : null;
+            return reset ? `${capitalize(reset)}-to-date ${value}` : `To-date ${value}`;
+        }
+        case 'rolling': {
+            const unit = meta.unit ?? granularity;
+            const span = meta.periods ? `${meta.periods}-${unit ? GRANULARITY_UNITS[unit].one : 'period'} ` : '';
+            return `Rolling ${span}${value}`;
+        }
+        default:
+            return capitalize(value);
+    }
+}
+// One window note as a sentence.
+export function windowNoteText(code, meta, locale, granularity) {
+    switch (code) {
+        case 'snapped_start': {
+            const start = meta.start ? formatDay(meta.start, locale) : '';
+            return start
+                ? `The start was moved to ${start}, the start of its period, so the first period is whole.`
+                : 'The start was moved to the start of its period, so the first period is whole.';
+        }
+        case 'span_converted':
+            return spanConvertedText(meta, granularity ?? null);
+        case 'grain_too_coarse':
+            return 'The grouping is coarser than the window, so it has no values at this grouping.';
+        case 'equal_grain_plain':
+            return 'At this grouping each window is a single period, so the values are the plain ones.';
+        case 'own_filter_caps_lead_in':
+            return 'The query\'s own date condition starts the window, so earlier rows are not counted.';
+        case 'week_by_monday':
+            return 'A week that spans two periods counts toward the period its Monday falls in.';
+        case 'incomplete_head':
+            return 'The first periods are blank because there are not enough earlier rows to fill a whole window.';
+        default:
+            return '';
+    }
+}
+// '3 months are shown as 13 weeks at this grouping.'
+function spanConvertedText(meta, granularity) {
+    if (!meta.periods || !meta.unit || !meta.drawnPeriods) {
+        return 'The window\'s span was converted to the grouping shown.';
+    }
+    const authored = unitCount(meta.periods, meta.unit);
+    const drawn = granularity
+        ? unitCount(meta.drawnPeriods, granularity)
+        : `${meta.drawnPeriods} ${meta.drawnPeriods === 1 ? 'period' : 'periods'}`;
+    return `${authored} ${meta.periods === 1 ? 'is' : 'are'} shown as ${drawn} at this grouping.`;
+}
+function unitCount(count, unit) {
+    return `${count} ${count === 1 ? GRANULARITY_UNITS[unit].one : GRANULARITY_UNITS[unit].many}`;
+}
+// Why a KPI's delta reads as it does, as a sentence. The baseline is named
+// by what the value is compared against: the same period last year for a
+// year-on-year comparison, else the period before.
+export function kpiNoteText(code, against) {
+    const baseline = kpiBaselineText(against);
+    switch (code) {
+        case 'no_prior_data':
+            return `No baseline: ${baseline} has no data.`;
+        case 'up_from_zero':
+            return `New: ${baseline} was 0.`;
+        case 'no_change':
+            return `No change from ${baseline}.`;
+        case 'no_data_either':
+            return 'No data in either period.';
+        case 'sign_change':
+            return 'The value crossed zero, so there is no percent change.';
+        default:
+            return '';
+    }
+}
+// The window a KPI's value is compared with, as a noun phrase. An unknown or
+// missing comparison reads as neutral wording rather than a wrong period.
+function kpiBaselineText(against) {
+    switch (against) {
+        case 'previous_period':
+            return 'the previous period';
+        case 'previous_week':
+            return 'the previous week';
+        case 'previous_month':
+            return 'the previous month';
+        case 'previous_quarter':
+            return 'the previous quarter';
+        case 'previous_year':
+            return 'the same period last year';
+        default:
+            return 'the comparison period';
+    }
+}
+function capitalize(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
 // A short, human label for a zone: its city plus the current abbreviation,
 // e.g. 'America/New_York' reads 'New York (EDT)'. UTC stays 'UTC', and an
 // unknown zone is shown as its id. An 'Etc/' zone names no city, and its POSIX
@@ -154,4 +1014,4 @@ export function getZonedNow(timezone) {
         return now;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format.js","sourceRoot":"","sources":["../../../../src/app/reports/format.ts"],"names":[],"mappings":"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","sourcesContent":["import { format, isValid, parseISO } from 'date-fns';\nimport { formatInTimeZone, toZonedTime } from 'date-fns-tz';\n\nimport { Report } from './interfaces/report.interface';\n\n\n// Measure-value formatting shared by the KPI renderer and the exports — the\n// config's `format` (number | percent | currency) and `precision` mean the same\n// thing on screen, in PowerPoint and in PDF.\n\n// percent takes a 0-1 ratio and shows it as a percentage: 0.3 reads 30%. With\n// no precision it shows at most one decimal (0.037 reads 3.7%); a named\n// precision counts the decimals of the percentage, not of the ratio, so\n// precision 1 shows 0.3 as 30.0%. An older server sends percent values already\n// x100 (38.5 for 38.5%); its reports carry no `percentFormat`, and the caller\n// passes ratioPercent false so the value is printed as it came, with a % sign.\n//\n// When the measure names a precision it is pinned as BOTH the minimum and the\n// maximum, so a column of rates lines up instead of each value showing however\n// many decimals it happens to need. Undefined leaves each format's own default\n// alone.\nfunction getFractionDigits(precision?: number): Intl.NumberFormatOptions {\n  return Number.isFinite(precision)\n    ? { minimumFractionDigits: precision, maximumFractionDigits: precision }\n    : {};\n}\n\nexport function formatMeasureValue(\n  value: unknown,\n  format?: string,\n  precision?: number,\n  ratioPercent = true,\n): string {\n  if (value === null || value === undefined || value === '') {\n    return '—';\n  }\n\n  const numeric = Number(value);\n  if (!Number.isFinite(numeric)) {\n    return String(value);\n  }\n\n  const fractionDigits = getFractionDigits(precision);\n\n  switch (format) {\n    case 'percent':\n      if (!ratioPercent) {\n        return `${new Intl.NumberFormat(undefined, { maximumFractionDigits: 1, ...fractionDigits }).format(numeric)}%`;\n      }\n\n      return new Intl.NumberFormat(undefined, {\n        style: 'percent',\n        maximumFractionDigits: 1,\n        ...fractionDigits,\n      }).format(numeric);\n    case 'currency':\n      return new Intl.NumberFormat(undefined, {\n        style: 'currency',\n        currency: 'USD',\n        // Whole dollars unless the measure asks for decimals — cents were\n        // unrepresentable before, because this was hardcoded to 0.\n        maximumFractionDigits: 0,\n        ...fractionDigits,\n      }).format(numeric);\n    default:\n      return new Intl.NumberFormat(undefined, fractionDigits).format(numeric);\n  }\n}\n\n\n// The axis peak at which a native chart's value axis gains thousands\n// separators. From here up the ticks are whole numbers in practice; below it\n// neither the screen nor PowerPoint's 'General' shows a separator.\nexport const AXIS_SEPARATOR_THRESHOLD = 1000;\n\n// PowerPoint's number format for a native chart's value axis, matching what the\n// on-screen axis prints by default: thousands separators with each tick's own\n// decimals. Excel has no \"General with separators\", so an axis reaching 1,000\n// (where ticks are whole numbers) gets '#,##0', and a smaller range keeps\n// 'General' so fractional ticks (0.25, 0.5) are not rounded away.\n//\n// The peak counts a missing value as 0. A stacked chart's peak is its tallest\n// stack: the largest sum, per category, of every series' absolute value.\nexport function chartAxisFormatCode(series: (number | null)[][], stacked: boolean): string {\n  const magnitudes = series.map((values) => values.map((value) => Math.abs(value ?? 0)));\n\n  const peak = stacked\n    ? Math.max(0, ...(magnitudes[0] ?? []).map((_, index) => magnitudes\n      .reduce((sum, values) => sum + (values[index] ?? 0), 0)))\n    : Math.max(0, ...magnitudes.flat());\n\n  return peak >= AXIS_SEPARATOR_THRESHOLD ? '#,##0' : 'General';\n}\n\n\n// The zone every date in a report is read in. The server resolves it (the\n// report's own zone, else the application's default reporting zone) and sends\n// it as `effectiveTimezone`. A server too old to send the field still used a\n// report's pinned `timezone`, so that comes next; the browser's zone is the last\n// fallback. This is the one place that chain lives, so every date the viewer\n// renders or resolves agrees with every other.\nexport function resolveReportTimezone(report: Pick<Report, 'effectiveTimezone' | 'timezone'>): string {\n  return report.effectiveTimezone ?? report.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;\n}\n\n\nconst DATE_ONLY_PATTERN = /^\\d{4}-\\d{2}-\\d{2}$/;\nconst DATE_TIME_PATTERN = /^(\\d{4}-\\d{2}-\\d{2})[ T](\\d{2}:\\d{2}:\\d{2})(\\.\\d+)?$/;\n\n// A report row's date cell as a calendar day in the report's zone.\n//\n// Report rows are raw database strings, not serialized models, so their shape\n// is the wire contract: a DATE column arrives as 'YYYY-MM-DD' and a\n// date-and-time column as 'YYYY-MM-DD HH:MM:SS' in UTC. Reading that shape\n// here does not re-derive a server rule; it only stops the browser guessing.\n// - A calendar day is never shifted: parseISO reads it as local midnight, so\n//   the day printed is the day stored, whatever the zone.\n// - An instant is pinned to UTC with an explicit 'Z', then shown as the day it\n//   fell on in the report's zone, the same day the filters and time buckets use.\n// - Anything else is shown as it came, and so is a value that has the shape\n//   but names no real day (a zero date '0000-00-00', or '2026-02-30'): one\n//   bad cell must not throw out of a pipe or abort an export.\nexport function formatReportDate(value: unknown, timezone: string): string {\n  if (value === null || value === undefined || value === '') {\n    return '';\n  }\n\n  const text = String(value);\n\n  if (DATE_ONLY_PATTERN.test(text)) {\n    const day = parseISO(text);\n\n    return isValid(day) ? format(day, 'MMM d, yyyy') : text;\n  }\n\n  const dateTime = DATE_TIME_PATTERN.exec(text);\n  if (!dateTime) {\n    return text;\n  }\n\n  const instant = parseISO(`${dateTime[1]}T${dateTime[2]}Z`);\n  if (!isValid(instant)) {\n    return text;\n  }\n\n  // An unknown zone makes date-fns-tz throw; UTC still names a real day.\n  try {\n    return formatInTimeZone(instant, timezone, 'MMM d, yyyy');\n  } catch {\n    return formatInTimeZone(instant, 'UTC', 'MMM d, yyyy');\n  }\n}\n\n\n// A short, human label for a zone: its city plus the current abbreviation,\n// e.g. 'America/New_York' reads 'New York (EDT)'. UTC stays 'UTC', and an\n// unknown zone is shown as its id. An 'Etc/' zone names no city, and its POSIX\n// sign is the reverse of the offset ('Etc/GMT+5' is GMT-5), so it reads as the\n// abbreviation alone: 'Etc/UTC' is 'UTC', 'Etc/GMT+5' is 'GMT-5'.\nexport function getTimezoneLabel(timezone: string): string {\n  if (timezone === 'UTC') {\n    return timezone;\n  }\n\n  const segments = timezone.split('/');\n\n  try {\n    const abbreviation = formatInTimeZone(new Date(), timezone, 'zzz');\n\n    return segments[0] === 'Etc'\n      ? abbreviation\n      : `${segments[segments.length - 1].replace(/_/g, ' ')} (${abbreviation})`;\n  } catch {\n    return timezone;\n  }\n}\n\n\n// \"Now\" as a Date whose local fields read the wall clock in the given zone, so\n// date-fns calendar arithmetic (startOfWeek, startOfMonth, ...) and\n// dateBoundString() land on the zone's calendar day rather than the browser's.\n// An unknown zone falls back to the browser's clock.\nexport function getZonedNow(timezone: string): Date {\n  const now = new Date();\n\n  try {\n    const zoned = toZonedTime(now, timezone);\n\n    return Number.isNaN(zoned.getTime()) ? now : zoned;\n  } catch {\n    return now;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format.js","sourceRoot":"","sources":["../../../../src/app/reports/format.ts"],"names":[],"mappings":"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","sourcesContent":["import { isValid, parseISO } from 'date-fns';\nimport { formatInTimeZone, toZonedTime } from 'date-fns-tz';\n\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  ChartGranularity,\n  ChartMeasure,\n  ComparisonAgainst,\n  ComparisonNoteCode,\n  ComparisonOffset,\n  ComponentComparison,\n  KpiNoteCode,\n  NumberFormatSpec,\n  OutputMeta,\n  OutputRole,\n  Report,\n  ReportCurrencyCode,\n  ReportFormatContext,\n  ReportLocaleTag,\n  WindowMeta,\n  WindowNoteCode,\n} from './interfaces/report.interface';\n\n\n// What a report reads when the server names no usable locale or currency: an\n// older server that sends neither, or a value this browser's Intl cannot use.\n// Never the browser's own locale, so every viewer of a report sees the same text.\nexport const REPORT_FALLBACK_LOCALE: ReportLocaleTag = 'en-US';\nexport const REPORT_FALLBACK_CURRENCY: ReportCurrencyCode = 'USD';\n\nexport const DEFAULT_FORMAT_CONTEXT: Readonly<ReportFormatContext> = Object.freeze({\n  locale: REPORT_FALLBACK_LOCALE,\n  currency: REPORT_FALLBACK_CURRENCY,\n  ratioPercent: true,\n});\n\nconst CURRENCY_PATTERN = /^[A-Z]{3}$/;\n\n\n// The server's resolved locale as one this browser can format in. A malformed\n// tag ('en_CA') makes supportedLocalesOf throw, and one Intl has no data for\n// ('xx-YY') comes back empty; both read the fallback.\nexport function resolveReportLocale(tag: string | null | undefined): ReportLocaleTag {\n  if (!tag) {\n    return REPORT_FALLBACK_LOCALE;\n  }\n\n  try {\n    return Intl.NumberFormat.supportedLocalesOf([tag])[0] ?? REPORT_FALLBACK_LOCALE;\n  } catch {\n    return REPORT_FALLBACK_LOCALE;\n  }\n}\n\n// The server's resolved currency as one Intl can label. The server decides\n// which codes name money; this only guards against a code Intl cannot take at\n// all. It is never checked against the runtime's own currency list, which\n// differs between browsers and leaves out codes the server offers (VEF, MRO),\n// so every viewer labels a report's money the same way.\nexport function resolveReportCurrency(code: string | null | undefined): ReportCurrencyCode {\n  if (!code || !CURRENCY_PATTERN.test(code)) {\n    return REPORT_FALLBACK_CURRENCY;\n  }\n\n  try {\n    numberFormat(REPORT_FALLBACK_LOCALE, { style: 'currency', currency: code });\n\n    return code;\n  } catch {\n    return REPORT_FALLBACK_CURRENCY;\n  }\n}\n\n// The one place a report's format context is built: the server's effective\n// locale and currency (absent on an older server, which then reads en-US/USD)\n// and whether its percent measures arrive as 0-1 ratios.\nexport function resolveFormatContext(\n  report: Pick<Report, 'effectiveLocale' | 'effectiveCurrency' | 'percentFormat'>,\n): ReportFormatContext {\n  return {\n    locale: resolveReportLocale(report.effectiveLocale),\n    currency: resolveReportCurrency(report.effectiveCurrency),\n    ratioPercent: report.percentFormat === 'ratio',\n  };\n}\n\n\n// Building an Intl formatter is far slower than using one, and a chart formats\n// every tick and tooltip value, so each distinct locale + options (+ zone) is\n// built once and reused.\nconst NUMBER_FORMATS = new Map<string, Intl.NumberFormat>();\nconst DATE_FORMATS = new Map<string, Intl.DateTimeFormat>();\n\nexport function numberFormat(locale: string, options: Intl.NumberFormatOptions): Intl.NumberFormat {\n  const key = `${locale}|${JSON.stringify(options)}`;\n  let formatter = NUMBER_FORMATS.get(key);\n\n  if (!formatter) {\n    formatter = new Intl.NumberFormat(locale, options);\n    NUMBER_FORMATS.set(key, formatter);\n  }\n\n  return formatter;\n}\n\n// No zone formats in the browser's own zone, which is right for a calendar day\n// parsed as local midnight: the day printed is the day stored.\nexport function dateFormat(\n  locale: string,\n  options: Intl.DateTimeFormatOptions,\n  timeZone?: string,\n): Intl.DateTimeFormat {\n  const key = `${locale}|${JSON.stringify(options)}|${timeZone ?? ''}`;\n  let formatter = DATE_FORMATS.get(key);\n\n  if (!formatter) {\n    formatter = new Intl.DateTimeFormat(locale, { ...options, timeZone });\n    DATE_FORMATS.set(key, formatter);\n  }\n\n  return formatter;\n}\n\n\n// Number formatting: the one engine behind every numeric slot (a chart\n// measure, a KPI measure, a list column, a cross-tab's cells), so a format\n// means the same thing on screen, in the PDF and in PowerPoint. The data stays\n// raw; only what is shown changes. The rules:\n// - Empty: null, undefined, '', '-' and a non-finite number print the caller's\n//   `empty` ('—' unless it names another).\n// - Numeric: a finite number, or a string that spells one plainly ('1234.50',\n//   '-3e2'). Anything else ('$1,234', an id with letters, ' ') prints as it\n//   came, since a column the SQL already formatted is text.\n// - Styles: number is a plain decimal; currency is the report's currency\n//   written in its locale with its symbol (USD reads '$1,235' in en-US and\n//   'US$1,235' in en-CA; EUR reads '1 235 €' in fr-FR); percent takes a 0-1\n//   ratio (0.3 reads 30%), or, from an older server that sends percent values\n//   already x100, a decimal with a % sign. Precision or units without a format\n//   mean number.\n// - Decimals: a precision pins both the minimum and the maximum, so a column\n//   of rates lines up. Without one: at most one for a percent and for an\n//   abbreviated value (1.2K), whole units for currency, the locale's default\n//   for a number.\n// - Units: thousands and millions divide and add a K or M after the digits\n//   ('$1.2K', '1,2K $'); auto picks per value by size, and a value that would\n//   round to 1000K reads 1M. Units never apply to a percent.\n// - Negatives keep the locale's leading minus. A negative that rounds to zero\n//   prints as zero, never '-0'.\n// - Rounding is Intl's, on the digits shown. Every value is written in the\n//   context's locale, never the browser's.\n\n// The most decimals a precision pins: the server's schema bound.\nconst MAX_PRECISION = 6;\n// At most one decimal for a percent, and for an abbreviated value (1.2K).\nconst PERCENT_DECIMALS = 1;\nconst SCALED_DECIMALS = 1;\n// Money shows whole units unless a precision asks for decimals.\nconst CURRENCY_DECIMALS = 0;\n// A currency axis whose ticks need decimals shows cents, not tenths.\nconst CURRENCY_AXIS_DECIMALS = 2;\n// What a missing value prints unless the caller names its own.\nconst EMPTY_VALUE = '—';\n// The tick count a value axis aims for, as ECharts' splitNumber default.\nconst AXIS_TICKS = 5;\n\n// A change's sign: a plus on a positive value, nothing on zero.\nconst SIGNED: Intl.NumberFormatOptions = { signDisplay: 'exceptZero' };\n\nconst NUMERIC_PATTERN = /^\\s*[-+]?(\\d+\\.?\\d*|\\.\\d+)([eE][-+]?\\d+)?\\s*$/;\n// The formatToParts types that carry a number's digits and separators.\nconst NUMBER_PARTS = new Set<Intl.NumberFormatPartTypes>(['integer', 'group', 'decimal', 'fraction']);\nconst DIGIT_PARTS = new Set<Intl.NumberFormatPartTypes>(['integer', 'fraction']);\n\n// A numeric format's units once decided: auto is resolved to one of these.\nexport type ResolvedUnits = ReportNumberUnits.None | ReportNumberUnits.Thousands | ReportNumberUnits.Millions;\n\ninterface UnitScale {\n  divisor: number;\n  suffix: string;\n  // The PowerPoint/Excel scaling commas: each one divides by 1,000.\n  commas: string;\n}\n\nconst UNIT_SCALES = new Map<ResolvedUnits, UnitScale>([\n  [ReportNumberUnits.Thousands, { divisor: 1e3, suffix: 'K', commas: ',' }],\n  [ReportNumberUnits.Millions, { divisor: 1e6, suffix: 'M', commas: ',,' }],\n]);\n\nexport interface FormatNumberOptions {\n  // What an empty value prints: '—' for a KPI or a tooltip, '' for a cell.\n  empty?: string;\n  // Units already decided for the whole chart, in place of the spec's own.\n  units?: ResolvedUnits;\n  // Decimals already decided for the whole chart, pinned as min and max. null\n  // leaves the spec's own.\n  decimals?: number | null;\n  // Writes a plus before a positive value, as a change reads ('+12%'). Zero,\n  // and a value whose shown digits are all zero, stays unsigned.\n  signed?: boolean;\n}\n\n// How a chart's value axis writes its ticks, decided once per chart.\nexport interface ChartNumberFormat {\n  units: ResolvedUnits;\n  // Pinned decimals, or null for a plain number whose ticks keep their own.\n  decimals: number | null;\n}\n\n// The value as a finite number when it is one or plainly spells one, else\n// null.\nexport function toFiniteNumber(value: unknown): number | null {\n  if (typeof value === 'number') {\n    return Number.isFinite(value) ? value : null;\n  }\n\n  if (typeof value !== 'string' || !NUMERIC_PATTERN.test(value)) {\n    return null;\n  }\n\n  const numeric = Number(value);\n\n  return Number.isFinite(numeric) ? numeric : null;\n}\n\n// Whether a slot asks to be formatted at all. A slot without these keys, or a\n// list column whose format is date, keeps its own rendering. Units none is the\n// same as no units key, as it is on the server.\nexport function hasNumberFormat(spec?: NumberFormatSpec | null): boolean {\n  if (!spec || spec.format === ReportListColumnFormat.Date) {\n    return false;\n  }\n\n  return valueFormat(spec) !== null\n    || (spec.precision ?? null) !== null\n    || ((spec.units ?? ReportNumberUnits.None) !== ReportNumberUnits.None);\n}\n\n// The units a value is written in. auto decides by the magnitude: a million\n// and up reads M, a thousand and up K, unless the value would then round to\n// 1000K at these decimals, which reads 1M instead.\nexport function resolveUnits(\n  units: ReportNumberUnits | null | undefined,\n  magnitude: number,\n  decimals: number,\n): ResolvedUnits {\n  switch (units) {\n    case ReportNumberUnits.Thousands:\n    case ReportNumberUnits.Millions:\n      return units;\n    case ReportNumberUnits.Auto:\n      return autoUnits(Math.abs(magnitude), decimals);\n    default:\n      return ReportNumberUnits.None;\n  }\n}\n\nfunction autoUnits(magnitude: number, decimals: number): ResolvedUnits {\n  if (magnitude >= 1e6) {\n    return ReportNumberUnits.Millions;\n  }\n\n  if (magnitude < 1e3) {\n    return ReportNumberUnits.None;\n  }\n\n  return roundTo(magnitude / 1e3, decimals) >= 1000\n    ? ReportNumberUnits.Millions\n    : ReportNumberUnits.Thousands;\n}\n\n// The value rounded as Intl rounds it for display, so the K-to-M promotion\n// agrees with the digits actually shown.\nfunction roundTo(value: number, decimals: number): number {\n  const digits = clampDecimals(decimals) ?? 0;\n\n  // A fixed locale only so Number() can parse the rounded digits back.\n  return Number(numberFormat(REPORT_FALLBACK_LOCALE, {\n    useGrouping: false,\n    minimumFractionDigits: 0,\n    maximumFractionDigits: digits,\n  }).format(value));\n}\n\n// One value, written by the rules above.\nexport function formatNumber(\n  value: unknown,\n  spec: NumberFormatSpec | null | undefined,\n  context: ReportFormatContext,\n  options: FormatNumberOptions = {},\n): string {\n  if (isEmptyValue(value)) {\n    return options.empty ?? EMPTY_VALUE;\n  }\n\n  const numeric = toFiniteNumber(value);\n  if (numeric === null) {\n    return String(value);\n  }\n\n  const style = resolveStyle(spec);\n  const precision = clampDecimals(spec?.precision);\n  const units = style === ReportValueFormat.Percent\n    ? ReportNumberUnits.None\n    : options.units ?? resolveUnits(spec?.units, numeric, precision ?? SCALED_DECIMALS);\n  const scale = UNIT_SCALES.get(units);\n  const decimals = clampDecimals(options.decimals) ?? precision;\n  const formatter = numberFormat(context.locale, {\n    ...styleOptions(style, context, decimals, !!scale),\n    ...(options.signed ? SIGNED : {}),\n  });\n  const text = writeNumber(formatter, (numeric === 0 ? 0 : numeric) / (scale?.divisor ?? 1), scale?.suffix);\n\n  return style === ReportValueFormat.Percent && !context.ratioPercent ? `${text}%` : text;\n}\n\nfunction isEmptyValue(value: unknown): boolean {\n  return value === null\n    || value === undefined\n    || value === ''\n    || value === '-'\n    || (typeof value === 'number' && !Number.isFinite(value));\n}\n\n// The value format a slot names, or null when it names none (or only date).\nfunction valueFormat(spec: NumberFormatSpec | null | undefined): ReportValueFormat | null {\n  return Object.values(ReportValueFormat).find((format) => format === spec?.format) ?? null;\n}\n\nfunction resolveStyle(spec: NumberFormatSpec | null | undefined): ReportValueFormat {\n  return valueFormat(spec) ?? ReportValueFormat.Number;\n}\n\n// A usable decimal count, or null. A stored value outside the schema's bounds\n// is brought inside them rather than thrown on by Intl.\nfunction clampDecimals(decimals: number | null | undefined): number | null {\n  return typeof decimals === 'number' && Number.isFinite(decimals)\n    ? Math.min(MAX_PRECISION, Math.max(0, Math.round(decimals)))\n    : null;\n}\n\nfunction styleOptions(\n  style: ReportValueFormat,\n  context: ReportFormatContext,\n  decimals: number | null,\n  scaled: boolean,\n): Intl.NumberFormatOptions {\n  const fractionDigits = fractionDigitOptions(decimals, defaultDecimals(style, scaled));\n\n  switch (style) {\n    case ReportValueFormat.Currency:\n      return { ...currencyOptions(context.currency), ...fractionDigits };\n    case ReportValueFormat.Percent:\n      return context.ratioPercent ? { style: 'percent', ...fractionDigits } : fractionDigits;\n    default:\n      return fractionDigits;\n  }\n}\n\nfunction currencyOptions(currency: ReportCurrencyCode): Intl.NumberFormatOptions {\n  return { style: 'currency', currency, currencyDisplay: 'symbol' };\n}\n\n// The most decimals a style shows when nothing pins them; null leaves Intl's\n// own default.\nfunction defaultDecimals(style: ReportValueFormat, scaled: boolean): number | null {\n  if (scaled) {\n    return SCALED_DECIMALS;\n  }\n\n  switch (style) {\n    case ReportValueFormat.Percent:\n      return PERCENT_DECIMALS;\n    case ReportValueFormat.Currency:\n      return CURRENCY_DECIMALS;\n    default:\n      return null;\n  }\n}\n\n// Pinned decimals set both bounds. Otherwise a maximum also sets the minimum\n// to zero, so no engine throws on a maximum below a currency's own minimum.\nfunction fractionDigitOptions(pinned: number | null, maximum: number | null): Intl.NumberFormatOptions {\n  if (pinned !== null) {\n    return { minimumFractionDigits: pinned, maximumFractionDigits: pinned };\n  }\n\n  return maximum === null ? {} : { minimumFractionDigits: 0, maximumFractionDigits: maximum };\n}\n\n// The formatted value, with the units letter after its digits. A negative\n// whose shown digits are all zero is written as zero, so no '-0' appears.\nfunction writeNumber(formatter: Intl.NumberFormat, value: number, suffix?: string): string {\n  if (value >= 0 && !suffix) {\n    return formatter.format(value);\n  }\n\n  const parts = formatter.formatToParts(value);\n\n  if (value < 0 && !hasNonZeroDigit(formatter, parts)) {\n    return writeNumber(formatter, 0, suffix);\n  }\n\n  if (!suffix) {\n    return parts.map((part) => part.value).join('');\n  }\n\n  const last = parts.reduce((found, part, index) => NUMBER_PARTS.has(part.type) ? index : found, -1);\n\n  return [\n    ...parts.slice(0, last + 1).map((part) => part.value),\n    suffix,\n    ...parts.slice(last + 1).map((part) => part.value),\n  ].join('');\n}\n\n// Compared with the locale's own zero, so a numbering system other than\n// 0-9 is read correctly.\nfunction hasNonZeroDigit(formatter: Intl.NumberFormat, parts: Intl.NumberFormatPart[]): boolean {\n  const zero = formatter.formatToParts(0).find((part) => part.type === 'integer')?.value ?? '0';\n\n  return parts.some((part) => DIGIT_PARTS.has(part.type)\n    && Array.from(part.value).some((character) => character !== zero));\n}\n\n\n// Output values: a column the server marks in ComponentData.outputs (a\n// compared value, a rank, a share) written by what it is. The data stays raw;\n// every number still goes through formatNumber. The rules:\n// - The format: a slot's own explicit format always wins. Otherwise a current,\n//   prior or change column takes its source measure's format; a percent change\n//   is a percent; a rank is a whole number; a share is a percent to 1 decimal.\n//   An own precision or units still applies over those defaults.\n// - Signs: a change and a percent change are signed ('+579', '-31.1%').\n// - Points: a change of a percent-format value, and any share change, is a\n//   difference of two rates, so it prints in percentage points, signed and to\n//   1 decimal unless a precision pins others: 0.1 reads '+10.0 pp'.\n// - Missing: a missing prior, or a change or percent change left empty by\n//   one, prints '—' titled with the floor ('No baseline: no data before\n//   Mar 3, 2026'), or for a rank or a share with the period the row was\n//   absent from ('No rank in the prior period'); a percent change over a prior of 0 prints 'n/a' titled\n//   'Prior was 0'. Any other missing value prints '—' (or the caller's empty).\n// - Rank change: prior minus current, so a rise is positive: '▲ 2', '▼ 1',\n//   '–' for none, and 'new' for an empty change whose prior rank is missing\n//   or not passed (a row always has a current rank, so only the prior lacks).\n// A percent change and a share are 0-1 fractions whatever the report's\n// percentFormat: the server computes them, never a stored value.\n\n// A missing comparison value prints EMPTY_VALUE whatever the caller's empty.\nconst NOT_APPLICABLE_VALUE = 'n/a';\nconst NEW_RANK_VALUE = 'new';\nconst RANK_UNCHANGED_VALUE = '–';\nconst RANK_UP_MARK = '▲';\nconst RANK_DOWN_MARK = '▼';\nconst POINTS_SUFFIX = 'pp';\nconst NO_PRIOR_RANK_TITLE = 'No rank in the prior period';\nconst NO_PRIOR_SHARE_TITLE = 'No share in the prior period';\n// Percentage points and a share are written to one decimal unless pinned.\nconst POINTS_DECIMALS = 1;\nconst SHARE_DECIMALS = 1;\n\nconst RANK_DEFAULT_SPEC: Readonly<NumberFormatSpec> = Object.freeze({ format: ReportValueFormat.Number, precision: 0 });\nconst SHARE_DEFAULT_SPEC: Readonly<NumberFormatSpec> = Object.freeze({\n  format: ReportValueFormat.Percent,\n  precision: SHARE_DECIMALS,\n});\nconst PERCENT_CHANGE_DEFAULT_SPEC: Readonly<NumberFormatSpec> = Object.freeze({ format: ReportValueFormat.Percent });\n\nexport interface OutputValueOptions {\n  // The source measure's format (OutputMeta.measure's slot), which a current,\n  // prior or change column takes when its own slot names none.\n  measureSpec?: NumberFormatSpec | null;\n  // The row's prior value in the same lane (see laneOutputAlias), for a change\n  // or a percent change: it tells a missing baseline ('—') from a zero one\n  // ('n/a'), and a new rank from an unranked row. Leave it out when unknown.\n  prior?: unknown;\n  // ComponentData.comparison.floor: the first day with data, named in the\n  // no-baseline title.\n  floor?: string | null;\n  // What a missing current or plain value prints ('' for a cell). A missing\n  // comparison value always prints '—'.\n  empty?: string;\n}\n\n// An output value as shown, and why it reads so when that is not obvious\n// (null otherwise): for a tooltip or a title attribute.\nexport interface FormattedOutputValue {\n  text: string;\n  title: string | null;\n}\n\n// One output value, written by the rules above. Without output metadata (a\n// plain measure column, an older server) it is formatNumber with the slot's\n// own format.\nexport function formatOutputValue(\n  value: unknown,\n  output: OutputMeta | null | undefined,\n  spec: NumberFormatSpec | null | undefined,\n  context: ReportFormatContext,\n  options: OutputValueOptions = {},\n): FormattedOutputValue {\n  if (!output) {\n    return plainOutput(formatNumber(value, spec, context, { empty: options.empty }));\n  }\n\n  if (output.kind === 'rank' && output.role === 'change') {\n    return formatRankChange(value, spec, context, options);\n  }\n\n  const role = output.role;\n  const effective = outputFormatSpec(output, spec, options.measureSpec);\n\n  if (isEmptyValue(value)) {\n    return missingOutput(output, context, options);\n  }\n\n  if (role === 'change' && isPointsChange(output, effective)) {\n    return plainOutput(formatPoints(value, output, effective, context));\n  }\n\n  const signed = role === 'change' || role === 'percent_change';\n  const ratioContext = role === 'percent_change' || output.kind === 'share'\n    ? { ...context, ratioPercent: true }\n    : context;\n\n  return plainOutput(formatNumber(value, effective, ratioContext, { signed }));\n}\n\n// The alias of the output that plays `role` in the same lane as `alias`: the\n// same measure and kind, and (for a prior, change or percent change) the same\n// prior lane. A measure compares against one lane only (two compares on one\n// value are two measures), so a current value's lane is whichever one its\n// measure's prior columns carry, lane 2 as readily as lane 1. A change column\n// finds its prior this way to pass as OutputValueOptions.prior. null when the\n// server sends no such column.\nexport function laneOutputAlias(\n  outputs: Record<string, OutputMeta> | null | undefined,\n  alias: string,\n  role: OutputRole,\n): string | null {\n  const source = outputs?.[alias];\n\n  if (!source) {\n    return null;\n  }\n\n  const anyLane = source.role === 'current' || source.offset === null;\n  const found = Object.entries(outputs ?? {}).find(([, meta]) => meta.measure === source.measure\n    && meta.kind === source.kind\n    && meta.role === role\n    && (role === 'current' || (anyLane ? meta.offset !== null : meta.offset === source.offset)));\n\n  return found ? found[0] : null;\n}\n\nfunction plainOutput(text: string): FormattedOutputValue {\n  return { text, title: null };\n}\n\n// The format an output is written in: the slot's own explicit format, else\n// the default for what it holds, with any own precision or units over it.\nfunction outputFormatSpec(\n  output: OutputMeta,\n  own: NumberFormatSpec | null | undefined,\n  measureSpec: NumberFormatSpec | null | undefined,\n): NumberFormatSpec | null {\n  if (valueFormat(own) !== null) {\n    return own;\n  }\n\n  if (output.kind === 'rank') {\n    return withOwnDigits(RANK_DEFAULT_SPEC, own);\n  }\n\n  if (output.kind === 'share') {\n    return withOwnDigits(SHARE_DEFAULT_SPEC, own);\n  }\n\n  if (output.role === 'percent_change') {\n    return withOwnDigits(PERCENT_CHANGE_DEFAULT_SPEC, own);\n  }\n\n  return measureSpec ? withOwnDigits(measureSpec, own) : own ?? null;\n}\n\n// The base format with the slot's own precision and units over it.\nfunction withOwnDigits(base: NumberFormatSpec, own: NumberFormatSpec | null | undefined): NumberFormatSpec {\n  return {\n    ...base,\n    ...((own?.precision ?? null) !== null ? { precision: own.precision } : {}),\n    ...((own?.units ?? null) !== null ? { units: own.units } : {}),\n  };\n}\n\n// A change between two rates: a share's, or a percent-format value's.\nfunction isPointsChange(output: OutputMeta, spec: NumberFormatSpec | null): boolean {\n  return output.kind === 'share' || resolveStyle(spec) === ReportValueFormat.Percent;\n}\n\n// A rate change in percentage points. A share and a 0-1 percent are scaled\n// x100; an older server's percent values already are.\nfunction formatPoints(\n  value: unknown,\n  output: OutputMeta,\n  spec: NumberFormatSpec | null,\n  context: ReportFormatContext,\n): string {\n  const numeric = toFiniteNumber(value);\n  if (numeric === null) {\n    return String(value);\n  }\n\n  const points = output.kind === 'share' || context.ratioPercent ? numeric * 100 : numeric;\n  const decimals = clampDecimals(spec?.precision) ?? POINTS_DECIMALS;\n  const text = formatNumber(points, { format: ReportValueFormat.Number }, context, { decimals, signed: true });\n\n  return `${text} ${POINTS_SUFFIX}`;\n}\n\n// A missing output value. A missing prior, or a delta a missing prior left\n// empty, has no baseline; a percent change over a zero prior has none to\n// divide by.\nfunction missingOutput(\n  output: OutputMeta,\n  context: ReportFormatContext,\n  options: OutputValueOptions,\n): FormattedOutputValue {\n  const role = output.role;\n\n  if (role === 'prior') {\n    return { text: EMPTY_VALUE, title: missingPriorTitle(output, options.floor, context.locale) };\n  }\n\n  if (role === 'change' || role === 'percent_change') {\n    const prior = options.prior;\n\n    if (role === 'percent_change' && toFiniteNumber(prior) === 0) {\n      return { text: NOT_APPLICABLE_VALUE, title: 'Prior was 0' };\n    }\n\n    return {\n      text: EMPTY_VALUE,\n      title: prior !== undefined && isEmptyValue(prior)\n        ? missingPriorTitle(output, options.floor, context.locale)\n        : null,\n    };\n  }\n\n  return plainOutput(options.empty ?? EMPTY_VALUE);\n}\n\n// Why a prior is missing. A value's prior is missing when its window ends\n// before the data starts. A rank's or a share's is missing when the row had\n// no rank or share in the prior period, whatever the floor.\nfunction missingPriorTitle(\n  output: OutputMeta,\n  floor: string | null | undefined,\n  locale: ReportLocaleTag,\n): string {\n  if (output.kind === 'rank') {\n    return NO_PRIOR_RANK_TITLE;\n  }\n\n  if (output.kind === 'share') {\n    return NO_PRIOR_SHARE_TITLE;\n  }\n\n  return noBaselineTitle(floor, locale);\n}\n\nfunction noBaselineTitle(floor: string | null | undefined, locale: ReportLocaleTag): string {\n  const day = floor ? formatDay(floor, locale) : '';\n\n  return day ? `No baseline: no data before ${day}` : 'No baseline';\n}\n\n// A rank change: prior rank minus current, so moving up is positive.\nfunction formatRankChange(\n  value: unknown,\n  spec: NumberFormatSpec | null | undefined,\n  context: ReportFormatContext,\n  options: OutputValueOptions,\n): FormattedOutputValue {\n  if (isEmptyValue(value)) {\n    return isEmptyValue(options.prior)\n      ? { text: NEW_RANK_VALUE, title: NO_PRIOR_RANK_TITLE }\n      : plainOutput(EMPTY_VALUE);\n  }\n\n  const numeric = toFiniteNumber(value);\n  if (numeric === null) {\n    return plainOutput(String(value));\n  }\n\n  const rankSpec = valueFormat(spec) !== null ? spec : withOwnDigits(RANK_DEFAULT_SPEC, spec);\n  const places = formatNumber(Math.abs(numeric), rankSpec, context);\n\n  if (places === formatNumber(0, rankSpec, context)) {\n    return plainOutput(RANK_UNCHANGED_VALUE);\n  }\n\n  return plainOutput(`${numeric > 0 ? RANK_UP_MARK : RANK_DOWN_MARK} ${places}`);\n}\n\n\n// A chart's value axis takes a format only when every measure on it agrees on\n// the style (each measure's format, number when it names none) and at least\n// one of them names a format. The first measure that does gives the axis its\n// precision and units. Otherwise null: the axis keeps its default ticks on\n// screen and in PowerPoint, and each series still formats its own tooltips.\nexport function axisNumberFormat(measures: ChartMeasure[]): NumberFormatSpec | null {\n  const style = measures.length ? resolveStyle(measures[0]) : null;\n\n  if (style === null || measures.some((measure) => resolveStyle(measure) !== style)) {\n    return null;\n  }\n\n  const formatted = measures.find((measure) => hasNumberFormat(measure));\n\n  return formatted ? numberFormatSpec(formatted) : null;\n}\n\nfunction numberFormatSpec(spec: NumberFormatSpec): NumberFormatSpec {\n  return {\n    ...(spec.format !== undefined ? { format: spec.format } : {}),\n    ...(spec.precision !== undefined ? { precision: spec.precision } : {}),\n    ...(spec.units !== undefined ? { units: spec.units } : {}),\n  };\n}\n\n// How a chart's value axis writes its ticks: the units decided once from the\n// axis peak, and the decimals the precision pins, else as many as the axis's\n// tick step needs (a percent axis up to 0.12% steps by 0.02%, two decimals).\n// Pinned decimals keep the ticks distinct, and PowerPoint can only pin them.\nexport function resolveChartNumberFormat(\n  spec: NumberFormatSpec,\n  peak: number,\n  context: ReportFormatContext,\n): ChartNumberFormat {\n  const style = resolveStyle(spec);\n  const precision = clampDecimals(spec.precision);\n  const units = style === ReportValueFormat.Percent\n    ? ReportNumberUnits.None\n    : resolveUnits(spec.units, peak, precision ?? SCALED_DECIMALS);\n\n  return { units, decimals: precision ?? axisDecimals(style, units, peak, context) };\n}\n\n// The decimals the axis's nice tick step needs. A plain, unabbreviated number\n// pins none (null): its ticks keep their own decimals. An unscaled currency\n// axis that needs decimals shows cents, and a K/M axis keeps its step's\n// decimals ('$0.5M', not '$0.50M').\nfunction axisDecimals(\n  style: ReportValueFormat,\n  units: ResolvedUnits,\n  peak: number,\n  context: ReportFormatContext,\n): number | null {\n  const scale = UNIT_SCALES.get(units);\n\n  if (style === ReportValueFormat.Number && !scale) {\n    return null;\n  }\n\n  const shownPeak = style === ReportValueFormat.Percent && context.ratioPercent\n    ? Math.abs(peak) * 100\n    : Math.abs(peak) / (scale?.divisor ?? 1);\n  const step = niceStep(shownPeak / AXIS_TICKS);\n  const decimals = step > 0 ? clampDecimals(-Math.floor(Math.log10(step))) ?? 0 : 0;\n\n  return style === ReportValueFormat.Currency && decimals > 0 && !scale ? CURRENCY_AXIS_DECIMALS : decimals;\n}\n\n// ECharts' nice(): the round number (1, 2, 3, 5 or 10 times a power of ten) a\n// rough tick step snaps to.\nfunction niceStep(rough: number): number {\n  if (!(rough > 0) || !Number.isFinite(rough)) {\n    return 0;\n  }\n\n  const exponent = Math.floor(Math.log10(rough));\n  const power = Math.pow(10, exponent);\n  const fraction = rough / power;\n  let nice = 10;\n  if (fraction < 1.5) {\n    nice = 1;\n  } else if (fraction < 2.5) {\n    nice = 2;\n  } else if (fraction < 4) {\n    nice = 3;\n  } else if (fraction < 7) {\n    nice = 5;\n  }\n\n  return nice * power;\n}\n\n// PowerPoint's number format code for a formatted value axis, matching the\n// screen's ticks: '#,##0.0%' (percent), '\"$\"#,##0' (currency),\n// '#,##0.0,\"K\"' (thousands), '#,##0\" $\"' (fr-CA currency). A plain number\n// whose decimals are not pinned keeps chartAxisFormatCode's code. The code's\n// separators follow the opening machine's locale; the currency symbol and its\n// side follow the report's.\nexport function numberFormatCode(\n  spec: NumberFormatSpec,\n  context: ReportFormatContext,\n  chart: ChartNumberFormat,\n  series: (number | null)[][],\n  stacked: boolean,\n): string {\n  const style = resolveStyle(spec);\n  const scale = style === ReportValueFormat.Percent ? undefined : UNIT_SCALES.get(chart.units);\n\n  if (style === ReportValueFormat.Number && !scale && chart.decimals === null) {\n    return chartAxisFormatCode(series, stacked);\n  }\n\n  const decimals = chart.decimals ?? 0;\n  const digits = `#,##0${decimals > 0 ? `.${'0'.repeat(decimals)}` : ''}`;\n\n  if (style === ReportValueFormat.Percent) {\n    return `${digits}${context.ratioPercent ? '%' : '\"%\"'}`;\n  }\n\n  const scaled = `${digits}${scale?.commas ?? ''}`;\n  const unit = scale?.suffix ?? '';\n\n  if (style !== ReportValueFormat.Currency) {\n    return unit ? `${scaled}\"${unit}\"` : scaled;\n  }\n\n  const symbol = currencySymbol(context);\n\n  return symbol.prefix\n    ? `\"${symbol.text}\"${scaled}${unit ? `\"${unit}\"` : ''}`\n    : `${scaled}\"${unit}${symbol.text}\"`;\n}\n\n// The currency symbol as the locale writes it beside a number, with the space\n// between them, and which side it sits on: '$' before in en-US, ' $' after in\n// fr-CA. Quotes are dropped, as a format code cannot hold them.\ninterface CurrencySymbol {\n  prefix: boolean;\n  text: string;\n}\n\nconst CURRENCY_SYMBOLS = new Map<string, CurrencySymbol>();\n\nfunction currencySymbol(context: ReportFormatContext): CurrencySymbol {\n  const key = `${context.locale}|${context.currency}`;\n  let symbol = CURRENCY_SYMBOLS.get(key);\n\n  if (!symbol) {\n    const parts = numberFormat(context.locale, currencyOptions(context.currency)).formatToParts(1);\n    const currency = parts.findIndex((part) => part.type === 'currency');\n    const first = parts.findIndex((part) => NUMBER_PARTS.has(part.type));\n    const last = parts.reduce((found, part, index) => NUMBER_PARTS.has(part.type) ? index : found, -1);\n    const prefix = currency < first;\n    const text = (prefix ? parts.slice(Math.max(currency, 0), first) : parts.slice(last + 1))\n      .map((part) => part.value)\n      .join('')\n      .replace(/\"/g, '');\n\n    symbol = { prefix, text };\n    CURRENCY_SYMBOLS.set(key, symbol);\n  }\n\n  return symbol;\n}\n\n\n// Every decimal a number has, grouped, in the locale: what ECharts prints by\n// default (its addCommas), but in the report's locale, so a chart's axis and\n// tooltip read like the rest of the report. 1234.5 reads 1,234.5 in en-US and\n// 1 234,5 in fr-CA. A non-numeric string is shown as it came, and anything\n// else non-numeric as '-', as ECharts shows it. As there, an infinite value\n// reads 'Infinity' and negative zero (a tick a float error leaves just below\n// zero) reads '0'.\nconst PLAIN_NUMBER: Intl.NumberFormatOptions = { maximumFractionDigits: 20 };\n\nexport function formatPlainNumber(value: unknown, locale: ReportLocaleTag): string {\n  const numeric = typeof value === 'number'\n    ? value\n    : typeof value === 'string' && value.trim() !== '' ? Number(value) : NaN;\n\n  if (Number.isNaN(numeric)) {\n    return typeof value === 'string' ? value : '-';\n  }\n\n  if (!Number.isFinite(numeric)) {\n    return String(numeric);\n  }\n\n  return numberFormat(locale, PLAIN_NUMBER).format(numeric === 0 ? 0 : numeric);\n}\n\n\n// The axis peak at which a native chart's value axis gains thousands\n// separators. From here up the ticks are whole numbers in practice; below it\n// neither the screen nor PowerPoint's 'General' shows a separator.\nexport const AXIS_SEPARATOR_THRESHOLD = 1000;\n\n// PowerPoint's number format for a native chart's value axis, matching what the\n// on-screen axis prints by default: thousands separators with each tick's own\n// decimals. Excel has no \"General with separators\", so an axis reaching 1,000\n// (where ticks are whole numbers) gets '#,##0', and a smaller range keeps\n// 'General' so fractional ticks (0.25, 0.5) are not rounded away.\n//\n// The peak is chartValuePeak's.\nexport function chartAxisFormatCode(series: (number | null)[][], stacked: boolean): string {\n  return chartValuePeak(series, stacked) >= AXIS_SEPARATOR_THRESHOLD ? '#,##0' : 'General';\n}\n\n// The largest magnitude a chart's value axis has to reach. A missing value\n// counts as 0. A stacked chart's peak is its tallest stack: the largest sum,\n// per category, of every series' absolute value.\nexport function chartValuePeak(series: (number | null)[][], stacked: boolean): number {\n  const magnitudes = series.map((values) => values.map((value) => Math.abs(value ?? 0)));\n\n  return stacked\n    ? Math.max(0, ...(magnitudes[0] ?? []).map((_, index) => magnitudes\n      .reduce((sum, values) => sum + (values[index] ?? 0), 0)))\n    : Math.max(0, ...magnitudes.flat());\n}\n\n\n// The zone every date in a report is read in. The server resolves it (the\n// report's own zone, else the application's default reporting zone) and sends\n// it as `effectiveTimezone`. A server too old to send the field still used a\n// report's pinned `timezone`, so that comes next; the browser's zone is the last\n// fallback. This is the one place that chain lives, so every date the viewer\n// renders or resolves agrees with every other.\nexport function resolveReportTimezone(report: Pick<Report, 'effectiveTimezone' | 'timezone'>): string {\n  return report.effectiveTimezone ?? report.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;\n}\n\n\n// The date shapes a report writes, each in the report's locale.\n// 'Jan 5, 2026' / '5 janv. 2026': a date cell, a filter bound.\nexport const DAY_SHORT: Intl.DateTimeFormatOptions = { year: 'numeric', month: 'short', day: 'numeric' };\n// 'January 5, 2026' / '5 janvier 2026': an export cover's date line.\nexport const DAY_LONG: Intl.DateTimeFormatOptions = { year: 'numeric', month: 'long', day: 'numeric' };\n// 'January' / 'janvier': a monthly period label (its year is added apart).\nexport const MONTH_LONG: Intl.DateTimeFormatOptions = { month: 'long' };\n// 'January 2026' / 'janvier 2026': a monthly period label written in full.\nexport const MONTH_YEAR: Intl.DateTimeFormatOptions = { year: 'numeric', month: 'long' };\n// 'Jan 5' / '5 janv.': a daily or weekly period label.\nexport const MONTH_DAY: Intl.DateTimeFormatOptions = { month: 'short', day: 'numeric' };\n\n// A date in the locale. With a zone, the day it falls on there; without one,\n// the browser's zone, which keeps a calendar day parsed as local midnight\n// unshifted. It never throws, since a pipe or an export calls it per cell: an\n// invalid Date reads '', a malformed locale ('en_CA') reads the fallback\n// locale, and an unknown zone reads UTC, which still names a real day.\nexport function formatLocalDate(\n  date: Date,\n  locale: ReportLocaleTag,\n  options: Intl.DateTimeFormatOptions,\n  timeZone?: string,\n): string {\n  if (Number.isNaN(date.getTime())) {\n    return '';\n  }\n\n  try {\n    return writeDate(dateFormat(locale, options, timeZone), date);\n  } catch {\n    return formatFallbackDate(date, resolveReportLocale(locale), options, timeZone);\n  }\n}\n\nfunction formatFallbackDate(\n  date: Date,\n  locale: ReportLocaleTag,\n  options: Intl.DateTimeFormatOptions,\n  timeZone?: string,\n): string {\n  try {\n    return writeDate(dateFormat(locale, options, timeZone), date);\n  } catch {\n    return writeDate(dateFormat(locale, options, 'UTC'), date);\n  }\n}\n\n// Intl writes a year below 1000 with only the digits it has ('Jan 1, 1'); a\n// date's year is always written with four ('Jan 1, 0001'), so a sentinel day\n// still reads as a date. Only such a year pays for formatToParts.\nfunction writeDate(formatter: Intl.DateTimeFormat, date: Date): string {\n  if (date.getUTCFullYear() > 1000) {\n    return formatter.format(date);\n  }\n\n  return formatter.formatToParts(date)\n    .map((part) => part.type === 'year' ? part.value.padStart(4, '0') : part.value)\n    .join('');\n}\n\n\nconst DATE_ONLY_PATTERN = /^\\d{4}-\\d{2}-\\d{2}$/;\nconst DATE_TIME_PATTERN = /^(\\d{4}-\\d{2}-\\d{2})[ T](\\d{2}:\\d{2}:\\d{2})(\\.\\d+)?$/;\n\n// A report row's date cell as a calendar day in the report's zone.\n//\n// Report rows are raw database strings, not serialized models, so their shape\n// is the wire contract: a DATE column arrives as 'YYYY-MM-DD' and a\n// date-and-time column as 'YYYY-MM-DD HH:MM:SS' in UTC. Reading that shape\n// here does not re-derive a server rule; it only stops the browser guessing.\n// - A calendar day is never shifted: parseISO reads it as local midnight, so\n//   the day printed is the day stored, whatever the zone.\n// - An instant is pinned to UTC with an explicit 'Z', then shown as the day it\n//   fell on in the report's zone, the same day the filters and time buckets use.\n// - Anything else is shown as it came, and so is a value that has the shape\n//   but names no real day (a zero date '0000-00-00', or '2026-02-30'): one\n//   bad cell must not throw out of a pipe or abort an export.\n// The day is written in the report's locale: 'Jan 5, 2026' in en-US, '5 janv.\n// 2026' in fr-CA.\nexport function formatReportDate(\n  value: unknown,\n  timezone: string,\n  locale: ReportLocaleTag,\n): string {\n  if (value === null || value === undefined || value === '') {\n    return '';\n  }\n\n  const text = String(value);\n\n  if (DATE_ONLY_PATTERN.test(text)) {\n    const day = parseISO(text);\n\n    return isValid(day) ? formatLocalDate(day, locale, DAY_SHORT) : text;\n  }\n\n  const dateTime = DATE_TIME_PATTERN.exec(text);\n  if (!dateTime) {\n    return text;\n  }\n\n  const instant = parseISO(`${dateTime[1]}T${dateTime[2]}Z`);\n\n  return isValid(instant) ? formatLocalDate(instant, locale, DAY_SHORT, timezone) : text;\n}\n\n\n// The time of day an instant falls at in the report's zone: '2:23 PM' in\n// en-US, '14 h 23' in fr-CA.\nexport const TIME_SHORT: Intl.DateTimeFormatOptions = { hour: 'numeric', minute: '2-digit' };\n\n// A window's inclusive days, as the server sends them: 'yyyy-MM-dd' calendar\n// days already in the report's zone. Like a date cell they are read as local\n// midnight and written with NO zone, so a viewer in any zone sees the days\n// sent. Both days: Intl's range in the locale ('Sep 1 – 30, 2026' in en-US,\n// '1–30 sept. 2026' in fr-CA, one date when they are the same day). One day:\n// an open window ('Since Sep 1, 2026', 'Through Sep 30, 2026'). Neither, or\n// days that are not real ones: ''.\nexport function formatDayRange(\n  start: string | null | undefined,\n  end: string | null | undefined,\n  locale: ReportLocaleTag,\n  options: Intl.DateTimeFormatOptions = DAY_SHORT,\n): string {\n  const first = parseDay(start);\n  const last = parseDay(end);\n\n  if (first && last) {\n    return writeDayRange(first, last, locale, options);\n  }\n\n  if (first) {\n    return `Since ${formatLocalDate(first, locale, options)}`;\n  }\n\n  return last ? `Through ${formatLocalDate(last, locale, options)}` : '';\n}\n\n// The time a window ending today is cut at: the server's UTC\n// 'yyyy-MM-dd HH:mm:ss' instant, as a time of day in the report's zone. ''\n// for none, or for a value of another shape.\nexport function formatThroughTime(\n  through: string | null | undefined,\n  timezone: string,\n  locale: ReportLocaleTag,\n): string {\n  const dateTime = through ? DATE_TIME_PATTERN.exec(through) : null;\n  const instant = dateTime ? parseISO(`${dateTime[1]}T${dateTime[2]}Z`) : null;\n\n  return instant && isValid(instant) ? formatLocalDate(instant, locale, TIME_SHORT, timezone) : '';\n}\n\n// A comparison or timeframe window in one line: its days, and the time it is\n// cut at when it ends today on a date-and-time column ('Oct 1 – 2, 2026,\n// until 2:23 PM').\nexport function formatDayWindow(\n  meta: { start: string | null; end: string | null; through?: string | null },\n  timezone: string,\n  locale: ReportLocaleTag,\n): string {\n  const days = formatDayRange(meta.start, meta.end, locale);\n  const time = formatThroughTime(meta.through, timezone, locale);\n\n  return days && time ? `${days}, until ${time}` : days;\n}\n\n// One 'yyyy-MM-dd' day in the locale, written with no zone: 'Sep 1, 2026'.\nfunction formatDay(day: string, locale: ReportLocaleTag): string {\n  const date = parseDay(day);\n\n  return date ? formatLocalDate(date, locale, DAY_SHORT) : '';\n}\n\n// A 'yyyy-MM-dd' day as local midnight, or null when it is not a real day.\nfunction parseDay(day: string | null | undefined): Date | null {\n  if (!day || !DATE_ONLY_PATTERN.test(day)) {\n    return null;\n  }\n\n  const date = parseISO(day);\n\n  return isValid(date) ? date : null;\n}\n\n// Intl's range writes the shared month and year once. A malformed locale\n// reads the fallback; a runtime that cannot write ranges joins two dates.\nfunction writeDayRange(first: Date, last: Date, locale: ReportLocaleTag, options: Intl.DateTimeFormatOptions): string {\n  const [from, to] = first <= last ? [first, last] : [last, first];\n\n  for (const tag of [locale, resolveReportLocale(locale)]) {\n    try {\n      return dateFormat(tag, options).formatRange(from, to);\n    } catch {\n      // The next locale, then the joined dates.\n    }\n  }\n\n  return `${formatLocalDate(from, locale, options)} – ${formatLocalDate(to, locale, options)}`;\n}\n\n\n// English names for a locale and a currency, for the settings selects. The\n// interface stays English whatever the report's locale: 'fr-CA' reads\n// 'Canadian French', 'CAD' reads 'Canadian Dollar'. A runtime without the\n// names shows the code.\nexport function localeName(tag: ReportLocaleTag): string {\n  return displayName('language', tag);\n}\n\nexport function currencyName(code: ReportCurrencyCode): string {\n  return displayName('currency', code);\n}\n\nfunction displayName(type: 'language' | 'currency', code: string): string {\n  try {\n    return new Intl.DisplayNames(['en'], { type }).of(code) ?? code;\n  } catch {\n    return code;\n  }\n}\n\n\n// Comparison, window and KPI wording. The server sends codes and fields,\n// never sentences (a window's description is for the agent and the exports'\n// notes, not the screen); the interface words them here, in English like\n// every other label, with any day written in the report's locale.\n\nconst GRANULARITY_UNITS: Record<ChartGranularity, { one: string; many: string }> = {\n  day: { one: 'day', many: 'days' },\n  week: { one: 'week', many: 'weeks' },\n  month: { one: 'month', many: 'months' },\n  quarter: { one: 'quarter', many: 'quarters' },\n  year: { one: 'year', many: 'years' },\n};\n\n// What a prior lane is called: always so for a named period, and for the\n// previous period when the server names no unit for it.\nconst AGAINST_PHRASES: Record<ComparisonAgainst, string> = {\n  previous_period: 'previous period',\n  previous_week: 'previous week',\n  previous_month: 'previous month',\n  previous_quarter: 'previous quarter',\n  previous_year: 'previous year',\n  range: 'custom range',\n};\n\n// A prior lane's label, from its offset rather than from the measure, so a\n// chart regrouped by the viewer says what it now compares. A named period\n// reads by its name whatever shift carries it ('vs previous quarter' for 3\n// months, 'vs previous year' for 364 days or 52 weeks, 'vs custom range').\n// Only the previous period is worded from its unit and count: 'vs previous\n// week', 'vs previous 3 months', 'vs previous 8 days' (a day-length shift).\nexport function comparisonOffsetLabel(offset: ComparisonOffset): string {\n  return `vs ${offsetPhrase(offset)}`;\n}\n\nfunction offsetPhrase(offset: ComparisonOffset): string {\n  if (offset.against !== 'previous_period' || !offset.unit || !offset.count) {\n    return AGAINST_PHRASES[offset.against] ?? AGAINST_PHRASES.previous_period;\n  }\n\n  return offset.count === 1\n    ? `previous ${GRANULARITY_UNITS[offset.unit].one}`\n    : `previous ${offset.count} ${GRANULARITY_UNITS[offset.unit].many}`;\n}\n\n// One comparison note as a sentence. The comparison, when given, names the\n// period compared with (its first prior lane).\nexport function comparisonNoteText(\n  code: ComparisonNoteCode,\n  comparison?: ComponentComparison | null,\n): string {\n  const offset = comparison?.offsets?.[0] ?? null;\n  const compared = offset ? `Compared with the ${offsetPhrase(offset)}` : null;\n\n  switch (code) {\n    case 'no_window':\n      return 'Pick a date range to see the comparison.';\n    case 'unit_inferred':\n      return compared\n        ? `${compared}, judged from the dates picked.`\n        : 'The period compared with was judged from the dates picked.';\n    case 'window_in_future':\n      return 'The date range starts after today, so there is nothing to compare yet.';\n    case 'other_date_filter':\n      return 'A date filter on another column also applies to both periods.';\n    case 'grain_followed':\n      return compared\n        ? `${compared}, following the grouping picked.`\n        : 'The comparison follows the grouping picked.';\n    default:\n      return '';\n  }\n}\n\n// What a windowed value is: 'Rolling 3-month total', 'Month-to-date total',\n// 'Running total since the start of the data', then its days when the server\n// sends them ('Rolling 7-day average, Sep 24 – 30, 2026'). granularity is the\n// grouping the rows are drawn at (ComponentData.granularity), which names a\n// rolling window authored in periods of the axis.\nexport function windowText(\n  meta: WindowMeta,\n  locale: ReportLocaleTag,\n  granularity?: ChartGranularity | null,\n): string {\n  const days = formatDayRange(meta.start, meta.end, locale);\n  const phrase = windowPhrase(meta, granularity ?? null);\n\n  return days ? `${phrase}, ${days}` : phrase;\n}\n\nfunction windowPhrase(meta: WindowMeta, granularity: ChartGranularity | null): string {\n  const value = meta.average ? 'average' : 'total';\n\n  switch (meta.kind) {\n    case 'running':\n      return meta.fromBeginning ? `Running ${value} since the start of the data` : `Running ${value}`;\n    case 'to_date': {\n      const reset = meta.resetEvery ? GRANULARITY_UNITS[meta.resetEvery].one : null;\n\n      return reset ? `${capitalize(reset)}-to-date ${value}` : `To-date ${value}`;\n    }\n    case 'rolling': {\n      const unit = meta.unit ?? granularity;\n      const span = meta.periods ? `${meta.periods}-${unit ? GRANULARITY_UNITS[unit].one : 'period'} ` : '';\n\n      return `Rolling ${span}${value}`;\n    }\n    default:\n      return capitalize(value);\n  }\n}\n\n// One window note as a sentence.\nexport function windowNoteText(\n  code: WindowNoteCode,\n  meta: WindowMeta,\n  locale: ReportLocaleTag,\n  granularity?: ChartGranularity | null,\n): string {\n  switch (code) {\n    case 'snapped_start': {\n      const start = meta.start ? formatDay(meta.start, locale) : '';\n\n      return start\n        ? `The start was moved to ${start}, the start of its period, so the first period is whole.`\n        : 'The start was moved to the start of its period, so the first period is whole.';\n    }\n    case 'span_converted':\n      return spanConvertedText(meta, granularity ?? null);\n    case 'grain_too_coarse':\n      return 'The grouping is coarser than the window, so it has no values at this grouping.';\n    case 'equal_grain_plain':\n      return 'At this grouping each window is a single period, so the values are the plain ones.';\n    case 'own_filter_caps_lead_in':\n      return 'The query\\'s own date condition starts the window, so earlier rows are not counted.';\n    case 'week_by_monday':\n      return 'A week that spans two periods counts toward the period its Monday falls in.';\n    case 'incomplete_head':\n      return 'The first periods are blank because there are not enough earlier rows to fill a whole window.';\n    default:\n      return '';\n  }\n}\n\n// '3 months are shown as 13 weeks at this grouping.'\nfunction spanConvertedText(meta: WindowMeta, granularity: ChartGranularity | null): string {\n  if (!meta.periods || !meta.unit || !meta.drawnPeriods) {\n    return 'The window\\'s span was converted to the grouping shown.';\n  }\n\n  const authored = unitCount(meta.periods, meta.unit);\n  const drawn = granularity\n    ? unitCount(meta.drawnPeriods, granularity)\n    : `${meta.drawnPeriods} ${meta.drawnPeriods === 1 ? 'period' : 'periods'}`;\n\n  return `${authored} ${meta.periods === 1 ? 'is' : 'are'} shown as ${drawn} at this grouping.`;\n}\n\nfunction unitCount(count: number, unit: ChartGranularity): string {\n  return `${count} ${count === 1 ? GRANULARITY_UNITS[unit].one : GRANULARITY_UNITS[unit].many}`;\n}\n\n// Why a KPI's delta reads as it does, as a sentence. The baseline is named\n// by what the value is compared against: the same period last year for a\n// year-on-year comparison, else the period before.\nexport function kpiNoteText(code: KpiNoteCode, against?: ComparisonAgainst | null): string {\n  const baseline = kpiBaselineText(against);\n\n  switch (code) {\n    case 'no_prior_data':\n      return `No baseline: ${baseline} has no data.`;\n    case 'up_from_zero':\n      return `New: ${baseline} was 0.`;\n    case 'no_change':\n      return `No change from ${baseline}.`;\n    case 'no_data_either':\n      return 'No data in either period.';\n    case 'sign_change':\n      return 'The value crossed zero, so there is no percent change.';\n    default:\n      return '';\n  }\n}\n\n// The window a KPI's value is compared with, as a noun phrase. An unknown or\n// missing comparison reads as neutral wording rather than a wrong period.\nfunction kpiBaselineText(against: ComparisonAgainst | null | undefined): string {\n  switch (against) {\n    case 'previous_period':\n      return 'the previous period';\n    case 'previous_week':\n      return 'the previous week';\n    case 'previous_month':\n      return 'the previous month';\n    case 'previous_quarter':\n      return 'the previous quarter';\n    case 'previous_year':\n      return 'the same period last year';\n    default:\n      return 'the comparison period';\n  }\n}\n\nfunction capitalize(text: string): string {\n  return text.charAt(0).toUpperCase() + text.slice(1);\n}\n\n\n// A short, human label for a zone: its city plus the current abbreviation,\n// e.g. 'America/New_York' reads 'New York (EDT)'. UTC stays 'UTC', and an\n// unknown zone is shown as its id. An 'Etc/' zone names no city, and its POSIX\n// sign is the reverse of the offset ('Etc/GMT+5' is GMT-5), so it reads as the\n// abbreviation alone: 'Etc/UTC' is 'UTC', 'Etc/GMT+5' is 'GMT-5'.\nexport function getTimezoneLabel(timezone: string): string {\n  if (timezone === 'UTC') {\n    return timezone;\n  }\n\n  const segments = timezone.split('/');\n\n  try {\n    const abbreviation = formatInTimeZone(new Date(), timezone, 'zzz');\n\n    return segments[0] === 'Etc'\n      ? abbreviation\n      : `${segments[segments.length - 1].replace(/_/g, ' ')} (${abbreviation})`;\n  } catch {\n    return timezone;\n  }\n}\n\n\n// \"Now\" as a Date whose local fields read the wall clock in the given zone, so\n// date-fns calendar arithmetic (startOfWeek, startOfMonth, ...) and\n// dateBoundString() land on the zone's calendar day rather than the browser's.\n// An unknown zone falls back to the browser's clock.\nexport function getZonedNow(timezone: string): Date {\n  const now = new Date();\n\n  try {\n    const zoned = toZonedTime(now, timezone);\n\n    return Number.isNaN(zoned.getTime()) ? now : zoned;\n  } catch {\n    return now;\n  }\n}\n"]}