@firestitch/report 18.6.0 → 18.7.0

package/esm2022/app/reports/format.mjs

@@ -1,51 +1,434 @@
-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%.
-//
-// 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) {
-    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;
+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':
-            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));
+    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 new Intl.NumberFormat(undefined, fractionDigits).format(numeric);
+            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 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));
+}
+// 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
 // neither the screen nor PowerPoint's 'General' shows a separator.
@@ -56,23 +439,74 @@ 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
-// it as `effectiveTimezone`; the browser's zone is only the fallback for a
-// server too old to send the field. This is the one place that fallback lives,
-// so every date the viewer renders or resolves agrees with every other.
+// it as `effectiveTimezone`. A server too old to send the field still used a
+// report's pinned `timezone`, so that comes next; the browser's zone is the last
+// fallback. This is the one place that chain lives, so every date the viewer
+// renders or resolves agrees with every other.
 export function resolveReportTimezone(report) {
-    return report.effectiveTimezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+    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+)?$/;
@@ -89,29 +523,40 @@ 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;
-    }
-    // An unknown zone makes date-fns-tz throw; UTC still names a real day.
+    return isValid(instant) ? formatLocalDate(instant, locale, DAY_SHORT, timezone) : text;
+}
+// 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;
     }
 }
 // A short, human label for a zone: its city plus the current abbreviation,
@@ -148,4 +593,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":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK5D,4EAA4E;AAC5E,gFAAgF;AAChF,6CAA6C;AAE7C,8EAA8E;AAC9E,wEAAwE;AACxE,wEAAwE;AACxE,kCAAkC;AAClC,EAAE;AACF,8EAA8E;AAC9E,+EAA+E;AAC/E,+EAA+E;AAC/E,SAAS;AACT,SAAS,iBAAiB,CAAC,SAAkB;IAC3C,OAAO,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;QAC/B,CAAC,CAAC,EAAE,qBAAqB,EAAE,SAAS,EAAE,qBAAqB,EAAE,SAAS,EAAE;QACxE,CAAC,CAAC,EAAE,CAAC;AACT,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,KAAc,EAAE,MAAe,EAAE,SAAkB;IACpF,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QAC1D,OAAO,GAAG,CAAC;IACb,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QAC9B,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED,MAAM,cAAc,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;IAEpD,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,SAAS;YACZ,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE;gBACtC,KAAK,EAAE,SAAS;gBAChB,qBAAqB,EAAE,CAAC;gBACxB,GAAG,cAAc;aAClB,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACrB,KAAK,UAAU;YACb,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE;gBACtC,KAAK,EAAE,UAAU;gBACjB,QAAQ,EAAE,KAAK;gBACf,kEAAkE;gBAClE,2DAA2D;gBAC3D,qBAAqB,EAAE,CAAC;gBACxB,GAAG,cAAc;aAClB,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACrB;YACE,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC5E,CAAC;AACH,CAAC;AAGD,qEAAqE;AACrE,6EAA6E;AAC7E,mEAAmE;AACnE,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,CAAC;AAE7C,gFAAgF;AAChF,8EAA8E;AAC9E,8EAA8E;AAC9E,0EAA0E;AAC1E,kEAAkE;AAClE,EAAE;AACF,8EAA8E;AAC9E,yEAAyE;AACzE,MAAM,UAAU,mBAAmB,CAAC,MAA2B,EAAE,OAAgB;IAC/E,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAEvF,MAAM,IAAI,GAAG,OAAO;QAClB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,UAAU;aAChE,MAAM,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC3D,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;IAEtC,OAAO,IAAI,IAAI,wBAAwB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;AAChE,CAAC;AAGD,0EAA0E;AAC1E,8EAA8E;AAC9E,2EAA2E;AAC3E,+EAA+E;AAC/E,wEAAwE;AACxE,MAAM,UAAU,qBAAqB,CAAC,MAAyC;IAC7E,OAAO,MAAM,CAAC,iBAAiB,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC,eAAe,EAAE,CAAC,QAAQ,CAAC;AACtF,CAAC;AAGD,MAAM,iBAAiB,GAAG,qBAAqB,CAAC;AAChD,MAAM,iBAAiB,GAAG,sDAAsD,CAAC;AAEjF,mEAAmE;AACnE,EAAE;AACF,8EAA8E;AAC9E,oEAAoE;AACpE,2EAA2E;AAC3E,6EAA6E;AAC7E,6EAA6E;AAC7E,0DAA0D;AAC1D,+EAA+E;AAC/E,iFAAiF;AACjF,4EAA4E;AAC5E,2EAA2E;AAC3E,8DAA8D;AAC9D,MAAM,UAAU,gBAAgB,CAAC,KAAc,EAAE,QAAgB;IAC/D,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QAC1D,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAE3B,IAAI,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAE3B,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC1D,CAAC;IAED,MAAM,QAAQ,GAAG,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9C,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC3D,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,uEAAuE;IACvE,IAAI,CAAC;QACH,OAAO,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC;IAC5D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC;IACzD,CAAC;AACH,CAAC;AAGD,2EAA2E;AAC3E,0EAA0E;AAC1E,+EAA+E;AAC/E,+EAA+E;AAC/E,kEAAkE;AAClE,MAAM,UAAU,gBAAgB,CAAC,QAAgB;IAC/C,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;QACvB,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAErC,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,gBAAgB,CAAC,IAAI,IAAI,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QAEnE,OAAO,QAAQ,CAAC,CAAC,CAAC,KAAK,KAAK;YAC1B,CAAC,CAAC,YAAY;YACd,CAAC,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,YAAY,GAAG,CAAC;IAC9E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,QAAQ,CAAC;IAClB,CAAC;AACH,CAAC;AAGD,+EAA+E;AAC/E,oEAAoE;AACpE,+EAA+E;AAC/E,qDAAqD;AACrD,MAAM,UAAU,WAAW,CAAC,QAAgB;IAC1C,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;IAEvB,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAEzC,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;IACrD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,CAAC;IACb,CAAC;AACH,CAAC","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%.\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(value: unknown, format?: string, precision?: number): 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      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`; the browser's zone is only the fallback for a\n// server too old to send the field. This is the one place that fallback lives,\n// so every date the viewer renders or resolves agrees with every other.\nexport function resolveReportTimezone(report: Pick<Report, 'effectiveTimezone'>): string {\n  return report.effectiveTimezone ?? 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  ChartMeasure,\n  NumberFormatSpec,\n  Report,\n  ReportCurrencyCode,\n  ReportFormatContext,\n  ReportLocaleTag,\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\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}\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, styleOptions(style, context, decimals, !!scale));\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// 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// 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// 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"]}