@eternl/formats 0.1.0

package/README.md

@@ -0,0 +1,132 @@
+# @eternl/formats
+
+Locale-aware display formatting and CSV-safe number helpers for browser-based dashboards and exports.
+
+## Installation
+
+```bash
+npm install @eternl/formats
+```
+
+## Quick Start
+
+```ts
+import Big from 'big.js'
+import {
+  buildCsv,
+  csvCurrencyCode,
+  formatCsvDate,
+  formatCsvNumber,
+  formatCsvPercent,
+  formatDisplayCurrency,
+  formatDisplayPercent,
+  formatDisplayCompact
+}                             from '@eternl/formats'
+
+const amount = new Big('1234567.890123')
+
+const priceUS = formatDisplayCurrency(amount, {
+  locale: 'en-US',
+  currencyCode: 'USD',
+  minDecimals: 2,
+  maxDecimals: 2,
+  useSymbol: true
+}) // "$1,234,567.89"
+
+const priceDE = formatDisplayCurrency(amount, {
+  locale: 'de-DE',
+  currencyCode: 'EUR',
+  minDecimals: 2,
+  maxDecimals: 2,
+  useSymbol: true
+}) // "1.234.567,89 €"
+
+const adaDisplay = formatDisplayCurrency('123456789.123456', {
+  locale: 'en-US',
+  currencyCode: 'ADA',
+  customSymbols: { ADA: '₳' },
+  minDecimals: 2,
+  maxDecimals: 6
+}) // "₳123,456,789.123456"
+
+const pctDisplay = formatDisplayPercent('0.125', {
+  locale: 'en-US',
+  minDecimals: 1,
+  maxDecimals: 2
+}) // "12.5%"
+
+const compact = formatDisplayCompact('9876543', {
+  locale: 'en-US',
+  compact: true,
+  maxDecimals: 1
+}) // "9.9M"
+
+const csvNumber = formatCsvNumber(amount, { maxDecimals: 6, trimTrailingZeros: true })
+const csvPercent = formatCsvPercent('0.125')
+const csvCurrency = csvCurrencyCode('ADA', { ADA: '₳' }, false)
+
+const rows = [
+  { ts: new Date('2025-10-06T12:00:00Z'), amount, currency: 'ADA', ratio: '0.125' }
+]
+
+const csv = buildCsv(rows, [
+  { header: 'date', accessor: (row) => row.ts, formatter: (value) => formatCsvDate(value as Date) },
+  { header: 'amount', accessor: (row) => row.amount, formatter: (value) => formatCsvNumber(value as Big, { maxDecimals: 6 }) },
+  { header: 'currency', accessor: (row) => row.currency, formatter: (value) => csvCurrencyCode(String(value), { ADA: '₳' }, false) },
+  { header: 'percent', accessor: (row) => row.ratio, formatter: (value) => formatCsvPercent(value as string, { maxDecimals: 4 }) }
+])
+```
+
+The generated CSV is fully ASCII (`.` decimal separator, no grouping) and imports cleanly into Google Sheets, Koinly, and CoinTracking.
+
+## Display Formatting
+
+- `formatDisplayNumber` handles localized decimals with grouping, optional sign display, and rounding controls.
+- `formatDisplayCurrency` combines `Intl.NumberFormat` with optional custom symbols (₳, ₿, etc.). Spacing from the host locale is preserved unless a custom symbol removes it.
+- `formatDisplayPercent` multiplies by 100 for display while respecting locale decimal and percent symbols.
+- `formatDisplayCompact` applies configurable K/M/B/T suffixes using precise `big.js` arithmetic (no scientific notation).
+
+Common options:
+
+```ts
+{
+  minDecimals?: number
+  maxDecimals?: number
+  precision?: number        // significant digits
+  roundingMode?: 'roundDown' | 'roundHalfUp' | 'roundHalfEven' | 'roundUp'
+  trimTrailingZeros?: boolean
+  signDisplay?: 'auto' | 'always' | 'exceptZero' | 'never' | 'negative'
+  useGrouping?: boolean
+}
+```
+
+## CSV Formatting
+
+- `formatCsvNumber` outputs plain ASCII digits and a dot decimal separator, honoring min/max decimals, precision, and trimming.
+- `formatCsvPercent` multiplies the ratio by 100 and emits an unadorned numeric string (no `%`).
+- `csvCurrencyCode` keeps currency symbols or codes in a dedicated column so numeric fields stay clean.
+
+```ts
+formatCsvNumber('0.00000001', { maxDecimals: 8 }) // "0.00000001"
+formatCsvPercent('0.125', { maxDecimals: 4 })      // "12.5"
+csvCurrencyCode('btc', { BTC: '₿' }, true)        // "₿"
+```
+
+## CSV Builder
+
+`buildCsv(rows, columns, delimiter = ',', lineEnding = '\n')` applies per-column accessors and formatters, quoting fields with delimiters, quotes, or newlines (RFC 4180). Numeric results produced by `formatCsvNumber` never require quoting, so imports remain numeric.
+
+## Date Helpers
+
+- `formatDisplayDate(input, locale, options)` caches `Intl.DateTimeFormat` instances.
+- `formatCsvDate(input)` emits ISO-8601 strings: `YYYY-MM-DD` for midnight UTC, otherwise `YYYY-MM-DDTHH:mm:ssZ`.
+
+## Development
+
+```bash
+npm run lint   # type-check
+npm test       # run Vitest suite
+npm run build  # emit ESM + CJS bundles into dist/
+```
+
+The test suite covers locale differences, rounding edge cases, percent handling, large/small magnitudes, and CSV quoting rules.

package/dist/cjs/constants.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DECIMAL_DOT = exports.DECIMAL_EMPTY = exports.DECIMAL_ZERO = exports.DEFAULT_SIGN_PLUS = exports.DEFAULT_SIGN_MINUS = exports.COMPACT_ORDER = exports.DISPLAY_SIGN_NONE = exports.DISPLAY_SIGN_PLUS = exports.DISPLAY_SIGN_MINUS = exports.DISPLAY_SIGNS = exports.STYLE_PERCENT = exports.STYLE_CURRENCY = exports.STYLE_DECIMAL = void 0;
+const types_1 = require("./types");
+exports.STYLE_DECIMAL = types_1.NUMBER_STYLES.decimal;
+exports.STYLE_CURRENCY = types_1.NUMBER_STYLES.currency;
+exports.STYLE_PERCENT = types_1.NUMBER_STYLES.percent;
+exports.DISPLAY_SIGNS = {
+    minus: 'minus',
+    plus: 'plus',
+    none: 'none'
+};
+exports.DISPLAY_SIGN_MINUS = exports.DISPLAY_SIGNS.minus;
+exports.DISPLAY_SIGN_PLUS = exports.DISPLAY_SIGNS.plus;
+exports.DISPLAY_SIGN_NONE = exports.DISPLAY_SIGNS.none;
+exports.COMPACT_ORDER = [...types_1.COMPACT_UNITS].reverse();
+exports.DEFAULT_SIGN_MINUS = '-';
+exports.DEFAULT_SIGN_PLUS = '+';
+exports.DECIMAL_ZERO = '0';
+exports.DECIMAL_EMPTY = '';
+exports.DECIMAL_DOT = '.';

package/dist/cjs/csv.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCsv = exports.csvCurrencyCode = exports.formatCsvPercent = exports.formatCsvNumber = void 0;
+const constants_1 = require("./constants");
+const date_1 = require("./date");
+const numeric_1 = require("./internal/numeric");
+const stringifyNumericParts = (parts) => {
+    const fraction = parts.fraction.length > 0 ? `${constants_1.DECIMAL_DOT}${parts.fraction}` : constants_1.DECIMAL_EMPTY;
+    const integer = parts.integer || constants_1.DECIMAL_ZERO;
+    const prefix = parts.isNegative ? constants_1.DEFAULT_SIGN_MINUS : constants_1.DECIMAL_EMPTY;
+    const value = `${prefix}${integer}${fraction}`;
+    return value;
+};
+const formatCsvNumber = (value, options = {}) => {
+    const parts = (0, numeric_1.computeNumericParts)(value, options);
+    return stringifyNumericParts(parts);
+};
+exports.formatCsvNumber = formatCsvNumber;
+const formatCsvPercent = (value, options = {}) => {
+    const scaled = (0, numeric_1.normalizeNumeric)(value).times(100);
+    const parts = (0, numeric_1.computeNumericParts)(scaled, options);
+    return stringifyNumericParts(parts);
+};
+exports.formatCsvPercent = formatCsvPercent;
+const csvCurrencyCode = (code, customSymbols, useSymbol) => {
+    const trimmed = code.trim();
+    if (!trimmed) {
+        return constants_1.DECIMAL_EMPTY;
+    }
+    const normalized = trimmed.toUpperCase();
+    if (useSymbol) {
+        const symbol = customSymbols?.[normalized];
+        if (symbol) {
+            return symbol;
+        }
+    }
+    return normalized;
+};
+exports.csvCurrencyCode = csvCurrencyCode;
+const escapeCsvField = (value, delimiter) => {
+    const needsQuoting = value.includes(delimiter)
+        || value.includes('\n')
+        || value.includes('\r')
+        || value.includes('"');
+    if (!needsQuoting) {
+        return value;
+    }
+    const escaped = value.replace(/"/g, '""');
+    return `"${escaped}"`;
+};
+const defaultFormatter = (value) => {
+    if (value === null || value === undefined) {
+        return constants_1.DECIMAL_EMPTY;
+    }
+    if (value instanceof Date) {
+        return (0, date_1.formatCsvDate)(value);
+    }
+    if (typeof value === 'number') {
+        return (0, exports.formatCsvNumber)(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    return String(value);
+};
+const buildCsv = (rows, columns, delimiter = ',', lineEnding = '\n') => {
+    const headerLine = columns.map((col) => escapeCsvField(col.header, delimiter)).join(delimiter);
+    const lines = [headerLine];
+    for (const row of rows) {
+        const fields = columns.map((col) => {
+            const raw = col.accessor(row);
+            const formatted = col.formatter ? col.formatter(raw) : defaultFormatter(raw);
+            const stringValue = formatted ?? constants_1.DECIMAL_EMPTY;
+            return escapeCsvField(stringValue, delimiter);
+        });
+        lines.push(fields.join(delimiter));
+    }
+    return `${lines.join(lineEnding)}${lineEnding}`;
+};
+exports.buildCsv = buildCsv;

package/dist/cjs/date.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCsvDate = exports.formatDisplayDate = void 0;
+const errors_1 = require("./errors");
+const intl_cache_1 = require("./internal/intl-cache");
+const toDate = (value) => {
+    if (value instanceof Date) {
+        const timestamp = value.getTime();
+        if (Number.isNaN(timestamp)) {
+            throw (0, errors_1.toRangeError)(errors_1.FormatError.DateValueInvalid);
+        }
+        return new Date(timestamp);
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw (0, errors_1.toRangeError)(errors_1.FormatError.DateNumberNonFinite);
+        }
+        const date = new Date(value);
+        if (Number.isNaN(date.getTime())) {
+            throw (0, errors_1.toRangeError)(errors_1.FormatError.DateValueInvalid);
+        }
+        return date;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            throw (0, errors_1.toRangeError)(errors_1.FormatError.DateStringEmpty);
+        }
+        const date = new Date(trimmed);
+        if (Number.isNaN(date.getTime())) {
+            throw (0, errors_1.toRangeError)(errors_1.FormatError.InvalidDateString);
+        }
+        return date;
+    }
+    throw (0, errors_1.toTypeError)(errors_1.FormatError.UnsupportedDateInput);
+};
+const formatDisplayDate = (date, locale, options) => {
+    if (!locale) {
+        throw (0, errors_1.toError)(errors_1.FormatError.MissingLocale);
+    }
+    const parsed = toDate(date);
+    const formatter = (0, intl_cache_1.getDateFormat)(locale, options);
+    return formatter.format(parsed);
+};
+exports.formatDisplayDate = formatDisplayDate;
+const formatCsvDate = (date) => {
+    const parsed = toDate(date);
+    const iso = parsed.toISOString();
+    const datePart = iso.slice(0, 10);
+    const hasTime = parsed.getUTCHours() !== 0
+        || parsed.getUTCMinutes() !== 0
+        || parsed.getUTCSeconds() !== 0
+        || parsed.getUTCMilliseconds() !== 0;
+    if (!hasTime) {
+        return datePart;
+    }
+    const timePart = iso.slice(11);
+    const withoutMillis = timePart.replace(/\.\d+Z$/, 'Z');
+    return `${datePart}T${withoutMillis}`;
+};
+exports.formatCsvDate = formatCsvDate;

package/dist/cjs/display.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDisplayCompact = exports.formatDisplayPercent = exports.formatDisplayCurrency = exports.formatDisplayNumber = void 0;
+const big_js_1 = __importDefault(require("big.js"));
+const numeric_1 = require("./internal/numeric");
+const intl_cache_1 = require("./internal/intl-cache");
+const errors_1 = require("./errors");
+const constants_1 = require("./constants");
+const types_1 = require("./types");
+const DEFAULT_COMPACT_THRESHOLDS = {
+    K: new big_js_1.default(1000),
+    M: new big_js_1.default(1000000),
+    B: new big_js_1.default(1000000000),
+    T: new big_js_1.default(1000000000000)
+};
+const DEFAULT_COMPACT_SUFFIXES = {
+    K: 'K',
+    M: 'M',
+    B: 'B',
+    T: 'T'
+};
+const resolveSignKind = (isNegative, isZero, signDisplay) => {
+    const mode = signDisplay ?? types_1.SIGN_DISPLAYS.auto;
+    switch (mode) {
+        case types_1.SIGN_DISPLAYS.always: return isNegative ? constants_1.DISPLAY_SIGN_MINUS : constants_1.DISPLAY_SIGN_PLUS;
+        case types_1.SIGN_DISPLAYS.exceptZero: return isNegative ? constants_1.DISPLAY_SIGN_MINUS : (isZero ? constants_1.DISPLAY_SIGN_NONE : constants_1.DISPLAY_SIGN_PLUS);
+        case types_1.SIGN_DISPLAYS.never: return constants_1.DISPLAY_SIGN_NONE;
+        case types_1.SIGN_DISPLAYS.negative: return isNegative ? constants_1.DISPLAY_SIGN_MINUS : constants_1.DISPLAY_SIGN_NONE;
+        case types_1.SIGN_DISPLAYS.auto:
+        default: return isNegative ? constants_1.DISPLAY_SIGN_MINUS : constants_1.DISPLAY_SIGN_NONE;
+    }
+};
+const resolveCurrencyToken = (template, options) => {
+    const code = options.currencyCode?.toUpperCase() ?? '';
+    if (options.useSymbol === false) {
+        return { value: code, fromCustom: false };
+    }
+    const custom = code ? options.customSymbols?.[code] : undefined;
+    if (custom) {
+        return { value: custom, fromCustom: true };
+    }
+    if (template && template !== code) {
+        return { value: template, fromCustom: false };
+    }
+    return { value: code, fromCustom: false };
+};
+const resolveCompact = (value, options) => {
+    if (!options.compact) {
+        return { value };
+    }
+    const abs = value.abs();
+    let chosen;
+    for (const unit of constants_1.COMPACT_ORDER) {
+        const overrideThreshold = options.compactThresholds?.[unit];
+        const threshold = overrideThreshold !== undefined
+            ? (0, numeric_1.normalizeNumeric)(overrideThreshold)
+            : DEFAULT_COMPACT_THRESHOLDS[unit];
+        if (abs.gte(threshold)) {
+            chosen = unit;
+            break;
+        }
+    }
+    if (!chosen) {
+        return { value };
+    }
+    const threshold = options.compactThresholds?.[chosen]
+        ? (0, numeric_1.normalizeNumeric)(options.compactThresholds[chosen])
+        : DEFAULT_COMPACT_THRESHOLDS[chosen];
+    const suffix = options.compactSuffixes?.[chosen] ?? DEFAULT_COMPACT_SUFFIXES[chosen];
+    const scaled = threshold.eq(0) ? value : value.div(threshold);
+    return { value: scaled, suffix };
+};
+const buildNumberFormatOptions = (options) => {
+    const nfOptions = {
+        style: options.style,
+        useGrouping: options.useGrouping !== false
+    };
+    if (options.signDisplay && options.signDisplay !== types_1.SIGN_DISPLAYS.negative) {
+        nfOptions.signDisplay = options.signDisplay;
+    }
+    if (options.minDecimals !== undefined) {
+        nfOptions.minimumFractionDigits = options.minDecimals;
+    }
+    if (options.maxDecimals !== undefined) {
+        nfOptions.maximumFractionDigits = options.maxDecimals;
+    }
+    if (options.style === constants_1.STYLE_CURRENCY && options.currencyCode) {
+        nfOptions.currency = options.currencyCode;
+        nfOptions.currencyDisplay = options.useSymbol === false ? 'code' : 'symbol';
+    }
+    return nfOptions;
+};
+const formatFromPattern = (options, integerPart, fractionPart, sign, suffix) => {
+    const nfOptions = buildNumberFormatOptions(options);
+    const pattern = (0, intl_cache_1.getNumberFormatPattern)(options.locale, nfOptions);
+    const parts = sign === constants_1.DISPLAY_SIGN_MINUS ? pattern.negative : pattern.positive;
+    const useGrouping = options.useGrouping !== false;
+    const groupedInteger = (0, numeric_1.applyGrouping)(integerPart, {
+        separator: pattern.groupSeparator,
+        primary: pattern.grouping.primary,
+        secondary: pattern.grouping.secondary
+    }, useGrouping);
+    const hasFraction = fractionPart.length > 0;
+    let result = '';
+    let integerInjected = false;
+    let currencyMeta;
+    let previousType;
+    for (const part of parts) {
+        switch (part.type) {
+            case 'integer': {
+                if (!integerInjected) {
+                    result += groupedInteger;
+                    integerInjected = true;
+                }
+                break;
+            }
+            case 'group':
+                break;
+            case 'decimal': {
+                if (hasFraction) {
+                    result += pattern.decimalSeparator;
+                }
+                break;
+            }
+            case 'fraction': {
+                if (hasFraction) {
+                    result += fractionPart;
+                }
+                break;
+            }
+            case 'minusSign': {
+                if (sign === constants_1.DISPLAY_SIGN_MINUS) {
+                    result += pattern.minusSign ?? part.value ?? constants_1.DEFAULT_SIGN_MINUS;
+                }
+                break;
+            }
+            case 'plusSign': {
+                if (sign === constants_1.DISPLAY_SIGN_PLUS) {
+                    result += pattern.plusSign ?? part.value ?? constants_1.DEFAULT_SIGN_PLUS;
+                }
+                break;
+            }
+            case 'currency': {
+                currencyMeta = currencyMeta ?? resolveCurrencyToken(part.value, options);
+                result += currencyMeta.value;
+                break;
+            }
+            case 'percentSign': {
+                result += part.value;
+                break;
+            }
+            case 'literal': {
+                if (previousType === 'currency' && currencyMeta?.fromCustom && /^\s+$/.test(part.value)) {
+                    break;
+                }
+                result += part.value;
+                break;
+            }
+            default: {
+                result += part.value;
+                break;
+            }
+        }
+        previousType = part.type;
+    }
+    if (suffix) {
+        result += suffix;
+    }
+    return result;
+};
+const resolveDisplayOptions = (options, style) => {
+    if (!options.locale) {
+        throw (0, errors_1.toError)(errors_1.FormatError.MissingLocale);
+    }
+    if (style === constants_1.STYLE_CURRENCY && !options.currencyCode) {
+        throw (0, errors_1.toError)(errors_1.FormatError.MissingCurrencyCode);
+    }
+    return {
+        ...options,
+        style
+    };
+};
+const formatDisplayInternal = (value, options, style) => {
+    const resolved = resolveDisplayOptions(options, style);
+    const baseValue = style === constants_1.STYLE_PERCENT
+        ? (0, numeric_1.normalizeNumeric)(value).times(100)
+        : (0, numeric_1.normalizeNumeric)(value);
+    const { value: compactValue, suffix } = resolveCompact(baseValue, resolved);
+    const numericParts = (0, numeric_1.computeNumericParts)(compactValue, resolved);
+    const sign = resolveSignKind(numericParts.isNegative, numericParts.isZero, resolved.signDisplay);
+    return formatFromPattern(resolved, numericParts.integer, numericParts.fraction, sign, suffix);
+};
+const formatDisplayNumber = (value, options) => {
+    const style = options.style ?? constants_1.STYLE_DECIMAL;
+    return formatDisplayInternal(value, { ...options, style }, style);
+};
+exports.formatDisplayNumber = formatDisplayNumber;
+const formatDisplayCurrency = (value, options) => {
+    return formatDisplayInternal(value, { ...options, style: constants_1.STYLE_CURRENCY }, constants_1.STYLE_CURRENCY);
+};
+exports.formatDisplayCurrency = formatDisplayCurrency;
+const formatDisplayPercent = (value, options) => {
+    return formatDisplayInternal(value, { ...options, style: constants_1.STYLE_PERCENT }, constants_1.STYLE_PERCENT);
+};
+exports.formatDisplayPercent = formatDisplayPercent;
+const formatDisplayCompact = (value, options) => {
+    const style = options.style ?? constants_1.STYLE_DECIMAL;
+    return formatDisplayInternal(value, { ...options, compact: true, style }, style);
+};
+exports.formatDisplayCompact = formatDisplayCompact;

package/dist/cjs/errors.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toError = exports.toTypeError = exports.toRangeError = exports.getFormatErrorMessage = exports.FormatError = void 0;
+var FormatError;
+(function (FormatError) {
+    FormatError["NonNegativeIntegerRequired"] = "nonNegativeIntegerRequired";
+    FormatError["PositiveIntegerRequired"] = "positiveIntegerRequired";
+    FormatError["NumericValueNonFinite"] = "numericValueNonFinite";
+    FormatError["NumericStringEmpty"] = "numericStringEmpty";
+    FormatError["UnsupportedNumericInput"] = "unsupportedNumericInput";
+    FormatError["MaxDecimalsLessThanMinimum"] = "maxDecimalsLessThanMinimum";
+    FormatError["MissingLocale"] = "missingLocale";
+    FormatError["MissingCurrencyCode"] = "missingCurrencyCode";
+    FormatError["DateValueInvalid"] = "dateValueInvalid";
+    FormatError["DateStringEmpty"] = "dateStringEmpty";
+    FormatError["DateNumberNonFinite"] = "dateNumberNonFinite";
+    FormatError["InvalidDateString"] = "invalidDateString";
+    FormatError["UnsupportedDateInput"] = "unsupportedDateInput";
+})(FormatError || (exports.FormatError = FormatError = {}));
+const FORMAT_ERROR_MESSAGES = {
+    [FormatError.NonNegativeIntegerRequired]: '%label% must be a non-negative integer',
+    [FormatError.PositiveIntegerRequired]: '%label% must be a positive integer',
+    [FormatError.NumericValueNonFinite]: 'Numeric value must be a finite number',
+    [FormatError.NumericStringEmpty]: 'Numeric string cannot be empty',
+    [FormatError.UnsupportedNumericInput]: 'Unsupported numeric input type',
+    [FormatError.MaxDecimalsLessThanMinimum]: 'maxDecimals cannot be less than minDecimals',
+    [FormatError.MissingLocale]: 'Display formatting requires a locale',
+    [FormatError.MissingCurrencyCode]: 'Currency formatting requires a currencyCode',
+    [FormatError.DateValueInvalid]: 'Invalid date value',
+    [FormatError.DateStringEmpty]: 'Date string cannot be empty',
+    [FormatError.DateNumberNonFinite]: 'Date number must be finite',
+    [FormatError.InvalidDateString]: 'Invalid date string',
+    [FormatError.UnsupportedDateInput]: 'Unsupported date input type'
+};
+const applyDetails = (template, details) => {
+    if (!details) {
+        return template;
+    }
+    return Object.keys(details).reduce((message, key) => message.replace(new RegExp(`%${key}%`, 'g'), details[key]), template);
+};
+const getFormatErrorMessage = (code, details) => applyDetails(FORMAT_ERROR_MESSAGES[code], details);
+exports.getFormatErrorMessage = getFormatErrorMessage;
+const toRangeError = (code, details) => new RangeError((0, exports.getFormatErrorMessage)(code, details));
+exports.toRangeError = toRangeError;
+const toTypeError = (code, details) => new TypeError((0, exports.getFormatErrorMessage)(code, details));
+exports.toTypeError = toTypeError;
+const toError = (code, details) => new Error((0, exports.getFormatErrorMessage)(code, details));
+exports.toError = toError;

package/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTypeError = exports.toRangeError = exports.toError = exports.getFormatErrorMessage = exports.FormatError = exports.formatCsvDate = exports.formatDisplayDate = exports.buildCsv = exports.csvCurrencyCode = exports.formatCsvPercent = exports.formatCsvNumber = exports.formatDisplayCompact = exports.formatDisplayPercent = exports.formatDisplayCurrency = exports.formatDisplayNumber = void 0;
+var display_1 = require("./display");
+Object.defineProperty(exports, "formatDisplayNumber", { enumerable: true, get: function () { return display_1.formatDisplayNumber; } });
+Object.defineProperty(exports, "formatDisplayCurrency", { enumerable: true, get: function () { return display_1.formatDisplayCurrency; } });
+Object.defineProperty(exports, "formatDisplayPercent", { enumerable: true, get: function () { return display_1.formatDisplayPercent; } });
+Object.defineProperty(exports, "formatDisplayCompact", { enumerable: true, get: function () { return display_1.formatDisplayCompact; } });
+var csv_1 = require("./csv");
+Object.defineProperty(exports, "formatCsvNumber", { enumerable: true, get: function () { return csv_1.formatCsvNumber; } });
+Object.defineProperty(exports, "formatCsvPercent", { enumerable: true, get: function () { return csv_1.formatCsvPercent; } });
+Object.defineProperty(exports, "csvCurrencyCode", { enumerable: true, get: function () { return csv_1.csvCurrencyCode; } });
+Object.defineProperty(exports, "buildCsv", { enumerable: true, get: function () { return csv_1.buildCsv; } });
+var date_1 = require("./date");
+Object.defineProperty(exports, "formatDisplayDate", { enumerable: true, get: function () { return date_1.formatDisplayDate; } });
+Object.defineProperty(exports, "formatCsvDate", { enumerable: true, get: function () { return date_1.formatCsvDate; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "FormatError", { enumerable: true, get: function () { return errors_1.FormatError; } });
+Object.defineProperty(exports, "getFormatErrorMessage", { enumerable: true, get: function () { return errors_1.getFormatErrorMessage; } });
+Object.defineProperty(exports, "toError", { enumerable: true, get: function () { return errors_1.toError; } });
+Object.defineProperty(exports, "toRangeError", { enumerable: true, get: function () { return errors_1.toRangeError; } });
+Object.defineProperty(exports, "toTypeError", { enumerable: true, get: function () { return errors_1.toTypeError; } });

package/dist/cjs/internal/intl-cache.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDateFormat = exports.getNumberFormatPattern = exports.getNumberFormat = void 0;
+const numberFormatCache = new Map();
+const numberFormatMetaCache = new Map();
+const dateFormatCache = new Map();
+const serializeOptions = (options) => {
+    const entries = Object.entries(options)
+        .filter(([, value]) => value !== undefined)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([key, value]) => {
+        if (value
+            && typeof value === 'object'
+            && !Array.isArray(value)) {
+            return `${key}:{${serializeOptions(value)}}`;
+        }
+        if (Array.isArray(value)) {
+            return `${key}:[${value.join('|')}]`;
+        }
+        return `${key}:${String(value)}`;
+    });
+    return entries.join(',');
+};
+const buildNumberFormatKey = (locale, options) => `${locale}|${serializeOptions(options)}`;
+const buildDateFormatKey = (locale, options) => `${locale}|${options ? serializeOptions(options) : ''}`;
+const getNumberFormat = (locale, options) => {
+    const key = buildNumberFormatKey(locale, options);
+    const cached = numberFormatCache.get(key);
+    if (cached) {
+        return cached;
+    }
+    const nf = new Intl.NumberFormat(locale, options);
+    numberFormatCache.set(key, nf);
+    return nf;
+};
+exports.getNumberFormat = getNumberFormat;
+const deriveGrouping = (parts) => {
+    const integerParts = parts.filter((part) => part.type === 'integer');
+    if (integerParts.length <= 1) {
+        return { primary: 0 };
+    }
+    const lengths = integerParts.map((part) => part.value.length);
+    const primary = lengths[lengths.length - 1];
+    const secondary = lengths.length > 1 ? lengths[lengths.length - 2] : undefined;
+    if (secondary === primary) {
+        return { primary };
+    }
+    return { primary, secondary };
+};
+const analyzePattern = (nf) => {
+    const sampleValue = 1234567.89;
+    const positiveParts = nf.formatToParts(sampleValue);
+    const negativeParts = nf.formatToParts(-sampleValue);
+    const plusProbe = nf.formatToParts(1);
+    const groupSeparator = positiveParts.find((part) => part.type === 'group')?.value ?? '';
+    const decimalSeparator = positiveParts.find((part) => part.type === 'decimal')?.value ?? '.';
+    const grouping = deriveGrouping(positiveParts);
+    const minusSign = negativeParts.find((part) => part.type === 'minusSign')?.value;
+    const plusSign = plusProbe.find((part) => part.type === 'plusSign')?.value;
+    return {
+        positive: positiveParts,
+        negative: negativeParts,
+        groupSeparator,
+        decimalSeparator,
+        grouping,
+        minusSign,
+        plusSign
+    };
+};
+const getNumberFormatPattern = (locale, options) => {
+    const key = buildNumberFormatKey(locale, options);
+    const cached = numberFormatMetaCache.get(key);
+    if (cached) {
+        return cached;
+    }
+    const nf = (0, exports.getNumberFormat)(locale, options);
+    const pattern = analyzePattern(nf);
+    numberFormatMetaCache.set(key, pattern);
+    return pattern;
+};
+exports.getNumberFormatPattern = getNumberFormatPattern;
+const getDateFormat = (locale, options) => {
+    const key = buildDateFormatKey(locale, options);
+    const cached = dateFormatCache.get(key);
+    if (cached) {
+        return cached;
+    }
+    const df = new Intl.DateTimeFormat(locale, options);
+    dateFormatCache.set(key, df);
+    return df;
+};
+exports.getDateFormat = getDateFormat;