@perses-dev/components 0.54.0-beta.0 → 0.54.0-beta.1

package/dist/cjs/model/bits.js

@@ -0,0 +1,113 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get BITS_GROUP_CONFIG () {
+        return BITS_GROUP_CONFIG;
+    },
+    get BITS_UNIT_CONFIG () {
+        return BITS_UNIT_CONFIG;
+    },
+    get formatBits () {
+        return formatBits;
+    }
+});
+const _numbro = /*#__PURE__*/ _interop_require_default(require("numbro"));
+const _constants = require("./constants");
+const _utils = require("./utils");
+const _formatterCache = require("./formatterCache");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/**
+ * We support both SI (decimal) and IEC (binary) units for bits:
+ *
+ * SI/decimal (unit: 'decbits'):
+ * 1 Kb = 1000 bits (1000^1 bits)
+ * 1 Mb = 1,000,000 bits (1000^2 bits)
+ * etc.
+ *
+ * IEC/binary (unit: 'bits'):
+ * 1 Kib = 1024 bits (1024^1 bits)
+ * 1 Mib = 1,048,576 bits (1024^2 bits)
+ * etc.
+ */ const DEFAULT_NUMBRO_MANTISSA = 2;
+const BITS_GROUP_CONFIG = {
+    label: 'Bits',
+    decimalPlaces: true,
+    shortValues: true
+};
+const BITS_UNIT_CONFIG = {
+    bits: {
+        group: 'Bits',
+        label: 'Bits (IEC)'
+    },
+    decbits: {
+        group: 'Bits',
+        label: 'Bits (SI)'
+    }
+};
+function formatBits(bits, { unit = 'bits', shortValues, decimalPlaces }) {
+    const isDecimal = unit === 'decbits';
+    const threshold = isDecimal ? 1000 : 1024;
+    // If we're showing the entire value, we can use Intl.NumberFormat.
+    if (!(0, _utils.shouldShortenValues)(shortValues) || Math.abs(bits) < threshold) {
+        const formatterOptions = {
+            style: 'decimal',
+            useGrouping: true
+        };
+        if ((0, _utils.hasDecimalPlaces)(decimalPlaces)) {
+            formatterOptions.minimumFractionDigits = (0, _utils.limitDecimalPlaces)(decimalPlaces);
+            formatterOptions.maximumFractionDigits = (0, _utils.limitDecimalPlaces)(decimalPlaces);
+        } else {
+            // This can happen if bits is between -threshold and threshold (1000 for SI, 1024 for IEC)
+            if ((0, _utils.shouldShortenValues)(shortValues)) {
+                formatterOptions.maximumSignificantDigits = _constants.MAX_SIGNIFICANT_DIGITS;
+            }
+        }
+        const key = [
+            formatterOptions.style,
+            formatterOptions.useGrouping,
+            formatterOptions.maximumSignificantDigits,
+            decimalPlaces,
+            shortValues,
+            unit
+        ];
+        return `${(0, _formatterCache.getFormatterFromCache)(key, 'bits', formatterOptions, 'en-US')(bits)} bits`;
+    }
+    // If we're showing the shorten value, we use numbro.
+    // numbro is able to add units like Kb, Mb, Gb, etc. correctly.
+    const formatted = (0, _numbro.default)(bits).format({
+        output: 'byte',
+        base: isDecimal ? 'decimal' : 'binary',
+        spaceSeparated: true,
+        mantissa: (0, _utils.hasDecimalPlaces)(decimalPlaces) ? decimalPlaces : DEFAULT_NUMBRO_MANTISSA,
+        // trimMantissa trims trailing 0s
+        trimMantissa: !(0, _utils.hasDecimalPlaces)(decimalPlaces),
+        // optionalMantissa excludes all the decimal places if they're all zeros
+        optionalMantissa: !(0, _utils.hasDecimalPlaces)(decimalPlaces)
+    });
+    // Replace byte units with bit units
+    return formatted.replace(/KB/g, 'Kb').replace(/MB/g, 'Mb').replace(/GB/g, 'Gb').replace(/TB/g, 'Tb').replace(/PB/g, 'Pb').replace(/EB/g, 'Eb').replace(/KiB/g, 'Kib').replace(/MiB/g, 'Mib').replace(/GiB/g, 'Gib').replace(/TiB/g, 'Tib').replace(/PiB/g, 'Pib').replace(/EiB/g, 'Eib');
+}

package/dist/cjs/model/bytes.js

@@ -0,0 +1,115 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get BYTES_GROUP_CONFIG () {
+        return BYTES_GROUP_CONFIG;
+    },
+    get BYTES_UNIT_CONFIG () {
+        return BYTES_UNIT_CONFIG;
+    },
+    get formatBytes () {
+        return formatBytes;
+    }
+});
+const _numbro = /*#__PURE__*/ _interop_require_default(require("numbro"));
+const _constants = require("./constants");
+const _utils = require("./utils");
+const _formatterCache = require("./formatterCache");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/**
+ * We support both SI (decimal) and IEC (binary) units for bytes:
+ *
+ * SI/decimal (unit: 'decbytes'):
+ * 1 KB = 1000 bytes (1000^1 bytes)
+ * 1 MB = 1,000,000 bytes (1000^2 bytes)
+ * etc.
+ *
+ * IEC/binary (unit: 'bytes'):
+ * 1 KiB = 1024 bytes (1024^1 bytes)
+ * 1 MiB = 1,048,576 bytes (1024^2 bytes)
+ * etc.
+ */ const DEFAULT_NUMBRO_MANTISSA = 2;
+const BYTES_GROUP_CONFIG = {
+    label: 'Bytes',
+    decimalPlaces: true,
+    shortValues: true
+};
+const BYTES_UNIT_CONFIG = {
+    bytes: {
+        group: 'Bytes',
+        label: 'Bytes (IEC)'
+    },
+    decbytes: {
+        group: 'Bytes',
+        label: 'Bytes (SI)'
+    }
+};
+function formatBytes(bytes, { unit = 'bytes', shortValues, decimalPlaces }) {
+    const isDecimal = unit === 'decbytes';
+    const threshold = isDecimal ? 1000 : 1024;
+    // If we're showing the entire value, we can use Intl.NumberFormat.
+    if (!(0, _utils.shouldShortenValues)(shortValues) || Math.abs(bytes) < threshold) {
+        const formatterOptions = {
+            style: 'unit',
+            unit: 'byte',
+            unitDisplay: 'long',
+            useGrouping: true
+        };
+        if ((0, _utils.hasDecimalPlaces)(decimalPlaces)) {
+            formatterOptions.minimumFractionDigits = (0, _utils.limitDecimalPlaces)(decimalPlaces);
+            formatterOptions.maximumFractionDigits = (0, _utils.limitDecimalPlaces)(decimalPlaces);
+        } else {
+            // This can happen if bytes is between -threshold and threshold (1000 for SI, 1024 for IEC)
+            if ((0, _utils.shouldShortenValues)(shortValues)) {
+                formatterOptions.maximumSignificantDigits = _constants.MAX_SIGNIFICANT_DIGITS;
+            }
+        }
+        const key = [
+            formatterOptions.style,
+            formatterOptions.unit,
+            formatterOptions.unitDisplay,
+            formatterOptions.useGrouping,
+            formatterOptions.maximumSignificantDigits,
+            decimalPlaces,
+            shortValues,
+            unit
+        ];
+        return (0, _formatterCache.getFormatterFromCache)(key, 'bytes', formatterOptions, 'en-US')(bytes);
+    }
+    // If we're showing the shorten value, we use numbro.
+    // numbro is able to add units like KB, MB, GB, etc. correctly.
+    return (0, _numbro.default)(bytes).format({
+        output: 'byte',
+        base: isDecimal ? 'decimal' : 'binary',
+        spaceSeparated: true,
+        mantissa: (0, _utils.hasDecimalPlaces)(decimalPlaces) ? decimalPlaces : DEFAULT_NUMBRO_MANTISSA,
+        // trimMantissa trims trailing 0s
+        trimMantissa: !(0, _utils.hasDecimalPlaces)(decimalPlaces),
+        // optionalMantissa excludes all the decimal places if they're all zeros
+        optionalMantissa: !(0, _utils.hasDecimalPlaces)(decimalPlaces)
+    });
+}

package/dist/cjs/model/constants.js

@@ -0,0 +1,23 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MAX_SIGNIFICANT_DIGITS", {
+    enumerable: true,
+    get: function() {
+        return MAX_SIGNIFICANT_DIGITS;
+    }
+});
+const MAX_SIGNIFICANT_DIGITS = 3;

package/dist/cjs/model/currency.js

@@ -0,0 +1,126 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get CURRENCY_GROUP_CONFIG () {
+        return CURRENCY_GROUP_CONFIG;
+    },
+    get CURRENCY_UNIT_CONFIG () {
+        return CURRENCY_UNIT_CONFIG;
+    },
+    get formatCurrency () {
+        return formatCurrency;
+    }
+});
+const _lodash = require("lodash");
+const _constants = require("./constants");
+const _utils = require("./utils");
+const _formatterCache = require("./formatterCache");
+const CURRENCY_GROUP = 'Currency';
+const CURRENCY_GROUP_CONFIG = {
+    label: 'Currency',
+    decimalPlaces: true
+};
+const CURRENCY_UNIT_CONFIG = {
+    aud: {
+        group: CURRENCY_GROUP,
+        label: 'Australian Dollar (A$)'
+    },
+    cad: {
+        group: CURRENCY_GROUP,
+        label: 'Canadian Dollar (CA$)'
+    },
+    chf: {
+        group: CURRENCY_GROUP,
+        label: 'Swiss Franc (CHF)'
+    },
+    cny: {
+        group: CURRENCY_GROUP,
+        label: 'Renminbi (CN¥)'
+    },
+    eur: {
+        group: CURRENCY_GROUP,
+        label: 'Euro (€)'
+    },
+    gbp: {
+        group: CURRENCY_GROUP,
+        label: 'Pound (£)'
+    },
+    hkd: {
+        group: CURRENCY_GROUP,
+        label: 'Hong Kong Dollar (HK$)'
+    },
+    inr: {
+        group: CURRENCY_GROUP,
+        label: 'Indian Rupee (₹)'
+    },
+    jpy: {
+        group: CURRENCY_GROUP,
+        label: 'Yen (¥)'
+    },
+    krw: {
+        group: CURRENCY_GROUP,
+        label: 'South Korean Won (₩)'
+    },
+    nok: {
+        group: CURRENCY_GROUP,
+        label: 'Norwegian Krone (NOK)'
+    },
+    nzd: {
+        group: CURRENCY_GROUP,
+        label: 'New Zealand Dollar (NZ$)'
+    },
+    sek: {
+        group: CURRENCY_GROUP,
+        label: 'Swedish Krona (SEK)'
+    },
+    sgd: {
+        group: CURRENCY_GROUP,
+        label: 'Singapore Dollar (S$)'
+    },
+    usd: {
+        group: CURRENCY_GROUP,
+        label: 'US Dollar ($)'
+    }
+};
+function formatCurrency(value, { unit, decimalPlaces }) {
+    const formatterOptions = {
+        style: 'currency',
+        currency: (0, _lodash.toUpper)(unit),
+        currencyDisplay: 'symbol'
+    };
+    if ((0, _utils.hasDecimalPlaces)(decimalPlaces)) {
+        formatterOptions.minimumFractionDigits = (0, _utils.limitDecimalPlaces)(decimalPlaces);
+        formatterOptions.maximumFractionDigits = (0, _utils.limitDecimalPlaces)(decimalPlaces);
+    } else {
+        formatterOptions.maximumSignificantDigits = _constants.MAX_SIGNIFICANT_DIGITS;
+    }
+    const key = [
+        formatterOptions.style,
+        formatterOptions.currency,
+        formatterOptions.currencyDisplay,
+        formatterOptions.maximumSignificantDigits,
+        decimalPlaces,
+        unit
+    ];
+    return (0, _formatterCache.getFormatterFromCache)(key, 'currency', formatterOptions, 'en-US')(value);
+}

package/dist/cjs/model/date.js

@@ -0,0 +1,297 @@
+// Copyright The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DATE_GROUP_CONFIG () {
+        return DATE_GROUP_CONFIG;
+    },
+    get DATE_UNIT_CONFIG () {
+        return DATE_UNIT_CONFIG;
+    },
+    get formatDate () {
+        return formatDate;
+    }
+});
+const DATE_GROUP = 'Date';
+const DATE_GROUP_CONFIG = {
+    label: 'Date & Time'
+};
+const DATE_UNIT_CONFIG = {
+    'datetime-iso': {
+        group: DATE_GROUP,
+        label: 'DateTime (GMT)'
+    },
+    'datetime-us': {
+        group: DATE_GROUP,
+        label: 'DateTime (US-East)'
+    },
+    'datetime-local': {
+        group: DATE_GROUP,
+        label: 'DateTime (Browser Local)'
+    },
+    'date-iso': {
+        group: DATE_GROUP,
+        label: 'Date (GMT)'
+    },
+    'date-us': {
+        group: DATE_GROUP,
+        label: 'Date (US-East)'
+    },
+    'date-local': {
+        group: DATE_GROUP,
+        label: 'Date (Browser Local)'
+    },
+    'time-local': {
+        group: DATE_GROUP,
+        label: 'Time (Browser Local)'
+    },
+    'time-iso': {
+        group: DATE_GROUP,
+        label: 'Time (GMT)'
+    },
+    'time-us': {
+        group: DATE_GROUP,
+        label: 'Time (US-East)'
+    },
+    'relative-time': {
+        group: DATE_GROUP,
+        label: 'Relative Time'
+    },
+    'unix-timestamp': {
+        group: DATE_GROUP,
+        label: 'Unix Timestamp (s)'
+    },
+    'unix-timestamp-ms': {
+        group: DATE_GROUP,
+        label: 'Unix Timestamp (ms)'
+    }
+};
+/**
+ * Converts a numeric value to a Date object.
+ * Handles both Unix timestamps (seconds) and millisecond timestamps.
+ */ function valueToDate(value) {
+    // Timestamp detection logic with special case handling
+    // Main threshold stays at 10 billion to maintain existing behavior
+    // Handle special edge cases explicitly
+    // Special case: negative timestamps
+    if (value < 0) {
+        // For negative values, check magnitude to distinguish seconds vs milliseconds
+        // Large negative values (> 1 billion in magnitude) are likely milliseconds
+        // Small negative values are likely seconds (rare edge case)
+        if (Math.abs(value) > 10000000000) {
+            return new Date(value); // milliseconds
+        } else {
+            return new Date(value * 1000); // seconds
+        }
+    }
+    // Special case: year 9999 in seconds (~253402300799)
+    // This is a very specific edge case for far-future timestamps
+    if (value >= 250000000000 && value <= 260000000000) {
+        // Check if this looks like year 9999 in seconds
+        const asSeconds = new Date(value * 1000);
+        const year = asSeconds.getUTCFullYear();
+        if (year >= 9999) {
+            return asSeconds; // seconds
+        }
+    }
+    const SECONDS_THRESHOLD = 10000000000; // ~year 2286 - original threshold
+    if (value < SECONDS_THRESHOLD) {
+        // Assume it's in seconds
+        return new Date(value * 1000);
+    } else {
+        // Assume it's in milliseconds
+        return new Date(value);
+    }
+}
+/**
+ * Formats a relative time string using the Intl.RelativeTimeFormat API.
+ */ function formatRelativeTime(date, referenceTime, locale) {
+    const referenceDate = new Date(referenceTime);
+    const diffMs = date.getTime() - referenceDate.getTime();
+    const units = [
+        {
+            unit: 'year',
+            ms: 1000 * 60 * 60 * 24 * 365
+        },
+        {
+            unit: 'month',
+            ms: 1000 * 60 * 60 * 24 * 30
+        },
+        {
+            unit: 'week',
+            ms: 1000 * 60 * 60 * 24 * 7
+        },
+        {
+            unit: 'day',
+            ms: 1000 * 60 * 60 * 24
+        },
+        {
+            unit: 'hour',
+            ms: 1000 * 60 * 60
+        },
+        {
+            unit: 'minute',
+            ms: 1000 * 60
+        },
+        {
+            unit: 'second',
+            ms: 1000
+        }
+    ];
+    for (const { unit, ms } of units){
+        // Determine the value for the current unit, ensuring it's an integer for Intl.RelativeTimeFormat
+        const value = Math.round(diffMs / ms);
+        // If the absolute value is 1 or more, use this unit
+        if (Math.abs(value) >= 1) {
+            const rtf = new Intl.RelativeTimeFormat(locale, {
+                numeric: 'auto'
+            });
+            return rtf.format(value, unit);
+        }
+    }
+    // If less than a second, show "now" or "0 seconds"
+    const rtf = new Intl.RelativeTimeFormat(locale, {
+        numeric: 'auto'
+    });
+    return rtf.format(0, 'second');
+}
+/**
+ * Gets the browser's preferred locale with comprehensive fallbacks.
+ */ const getBrowserLocale = ()=>{
+    if (typeof navigator !== 'undefined') {
+        if (navigator.language) return navigator.language;
+        if (navigator.languages && navigator.languages.length > 0) {
+            const firstLanguage = navigator.languages[0];
+            if (firstLanguage) return firstLanguage;
+        }
+        // Legacy fallbacks for older browsers
+        const nav = navigator;
+        if (nav.userLanguage) return nav.userLanguage;
+        if (nav.browserLanguage) return nav.browserLanguage;
+        if (nav.systemLanguage) return nav.systemLanguage;
+    }
+    // Node.js or server-side fallback, or if navigator is not available/empty
+    return Intl.DateTimeFormat().resolvedOptions().locale || 'en-US';
+};
+function formatDate(value, options = {}) {
+    const systemTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const { unit = 'datetime-local', locale = getBrowserLocale(), timeZone = systemTimeZone, referenceTime = Date.now() } = options;
+    // Handle raw timestamp display
+    if (unit === 'unix-timestamp') {
+        // Ensure it's in seconds. If it looks like milliseconds, convert.
+        const timestamp = value > 1000000000000 ? Math.floor(value / 1000) : value;
+        return timestamp.toString();
+    }
+    if (unit === 'unix-timestamp-ms') {
+        // Ensure it's in milliseconds. If it looks like seconds, convert.
+        // Use 100 billion as threshold - values < 100B are likely seconds, >= 100B are likely milliseconds
+        // This distinguishes between 999999999 (seconds) and 999999999000 (milliseconds)
+        const MILLISECONDS_THRESHOLD = 100000000000; // 100 billion
+        const timestamp = value < MILLISECONDS_THRESHOLD ? value * 1000 : value;
+        return Math.floor(timestamp).toString();
+    }
+    const date = valueToDate(value);
+    // Handle relative time
+    if (unit === 'relative-time') {
+        return formatRelativeTime(date, referenceTime, locale);
+    }
+    // Configure Intl.DateTimeFormat options based on unit
+    const formatOptions = {
+        timeZone
+    };
+    switch(unit){
+        case 'datetime-iso':
+            // datetime-iso should ALWAYS show GMT/UTC time
+            return date.toISOString();
+        case 'datetime-us':
+            {
+                // datetime-us should ALWAYS show date in US Eastern timezone
+                formatOptions.timeZone = 'America/New_York';
+                formatOptions.year = 'numeric';
+                formatOptions.month = '2-digit';
+                formatOptions.day = '2-digit';
+                formatOptions.hour = '2-digit';
+                formatOptions.minute = '2-digit';
+                formatOptions.second = '2-digit';
+                formatOptions.hour12 = true; // 12-hour format with AM/PM
+                const formatter = new Intl.DateTimeFormat('en-US', formatOptions);
+                return formatter.format(date);
+            }
+        case 'datetime-local':
+            // datetime-local should use the browser's local timezone (detected automatically)
+            // Don't override timeZone - let it use the detected system timezone
+            formatOptions.year = 'numeric';
+            formatOptions.month = '2-digit';
+            formatOptions.day = '2-digit';
+            formatOptions.hour = '2-digit';
+            formatOptions.minute = '2-digit';
+            formatOptions.second = '2-digit';
+            formatOptions.hour12 = false; // 24-hour format
+            break;
+        case 'date-iso':
+            // date-iso should ALWAYS show GMT/UTC date
+            return date.toISOString().split('T')[0];
+        case 'date-us':
+            {
+                // date-us should ALWAYS show date in US Eastern timezone
+                formatOptions.timeZone = 'America/New_York';
+                formatOptions.year = 'numeric';
+                formatOptions.month = '2-digit';
+                formatOptions.day = '2-digit';
+                const formatter = new Intl.DateTimeFormat('en-US', formatOptions);
+                return formatter.format(date);
+            }
+        case 'date-local':
+            formatOptions.year = 'numeric';
+            formatOptions.month = '2-digit';
+            formatOptions.day = '2-digit';
+            break;
+        case 'time-local':
+            formatOptions.hour = '2-digit';
+            formatOptions.minute = '2-digit';
+            formatOptions.second = '2-digit';
+            formatOptions.hour12 = false; // 24-hour format
+            break;
+        case 'time-iso':
+            // time-iso should ALWAYS show GMT/UTC time
+            return date.toISOString().split('T')[1].replace('Z', '');
+        case 'time-us':
+            {
+                // time-us should show time in US-East timezone (Eastern Time)
+                formatOptions.timeZone = 'America/New_York';
+                formatOptions.hour = '2-digit';
+                formatOptions.minute = '2-digit';
+                formatOptions.second = '2-digit';
+                formatOptions.hour12 = true;
+                return new Intl.DateTimeFormat('en-US', formatOptions).format(date);
+            }
+        default:
+            {
+                // This ensures that all DateUnits are handled at compile time.
+                const exhaustive = unit;
+                throw new Error(`Unknown date unit: ${exhaustive}`);
+            }
+    }
+    // For all other units, use Intl.DateTimeFormat with the specified locale and options
+    const formatter = new Intl.DateTimeFormat(locale, formatOptions);
+    return formatter.format(date);
+}