@svgrid/grid 1.0.0

package/dist/SvGridDropdown.svelte.d.ts

@@ -0,0 +1,40 @@
+/**
+   * Internal dropdown / listbox control used by the `list` and `chips` cell
+   * editors. We deliberately don't reuse the browser-native `<select>` -
+   * the native dropdown can't be styled to match the grid theme, picks up
+   * the OS color scheme, and on Windows draws the option list with an
+   * opaque white system surface that fights the dark theme.
+   *
+   * Modes:
+   *   single  - picking an option fires `onChange(value)` and `onCommit()`.
+   *   multi   - toggling fires `onChange(values: array)`; the user
+   *             presses Enter / clicks "Done" to fire `onCommit()`.
+   *
+   * Keyboard model:
+   *   ArrowDown / ArrowUp - move highlight (opens the panel if closed).
+   *   Enter              - single: toggle highlighted + commit.
+   *                        multi: toggle highlighted (stay open).
+   *   Escape             - close + onCancel.
+   *   Tab                - commit and let focus escape.
+   */
+import type { CellEditorOption } from './editors/cell-editors';
+type Props = {
+    options: ReadonlyArray<CellEditorOption>;
+    value: unknown;
+    multiple?: boolean;
+    placeholder?: string;
+    /** When provided, the trigger renders as removable chips of the current value(s). */
+    renderChipsInTrigger?: boolean;
+    /** Add a typeahead input at the top of the popover that filters the
+     *  option list as the user types. Used by the rich-select editor. */
+    searchable?: boolean;
+    /** Called with the new full value (scalar for single, array for multi). */
+    onChange?: (next: unknown) => void;
+    /** Called when the user finalizes the selection (single pick, Enter, blur with selection). */
+    onCommit?: () => void;
+    /** Called when the user dismisses (Escape, blur with no change). */
+    onCancel?: () => void;
+};
+declare const SvGridDropdown: import("svelte").Component<Props, {}, "">;
+type SvGridDropdown = ReturnType<typeof SvGridDropdown>;
+export default SvGridDropdown;

package/dist/a11y.contract.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/a11y.contract.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest';
+import { getGridCellA11yProps, getGridHeaderA11yProps, getGridRootA11yProps, getGridRowA11yProps, } from './a11y';
+function attrsToHtml(attrs) {
+    return Object.entries(attrs)
+        .map(([key, value]) => `${key}="${String(value)}"`)
+        .join(' ');
+}
+describe('a11y contract rendering', () => {
+    it('builds expected headless markup attributes', () => {
+        const root = getGridRootA11yProps();
+        const header = getGridHeaderA11yProps({
+            sortable: true,
+            sortDirection: 'descending',
+        });
+        const row = getGridRowA11yProps(1);
+        const cell = getGridCellA11yProps({
+            rowIndex: 1,
+            colIndex: 2,
+            selected: true,
+        });
+        const html = [
+            `<table ${attrsToHtml(root)}><thead>`,
+            `<tr ${attrsToHtml(row)}>`,
+            `<th ${attrsToHtml(header)}>Age</th>`,
+            `</tr></thead><tbody>`,
+            `<tr ${attrsToHtml(row)}><td ${attrsToHtml(cell)}>42</td></tr>`,
+            `</tbody></table>`,
+        ].join('');
+        expect(html).toContain('role="grid"');
+        expect(html).toContain('role="columnheader"');
+        expect(html).toContain('aria-sort="descending"');
+        expect(html).toContain('aria-selected="true"');
+        expect(html).toContain('aria-colindex="2"');
+    });
+    it('creates stable active descendant ids', async () => {
+        const { getGridCellDomId } = await import('./a11y');
+        expect(getGridCellDomId('svgrid', 3, 4)).toBe('svgrid_cell_3_4');
+    });
+});

package/dist/a11y.d.ts

@@ -0,0 +1,38 @@
+export type GridSortDirection = 'ascending' | 'descending' | 'none' | 'other';
+export type GridColumnA11yInput = {
+    sortable?: boolean;
+    sortDirection?: GridSortDirection;
+};
+export type GridCellA11yInput = {
+    colIndex?: number;
+    rowIndex?: number;
+    selected?: boolean;
+    id?: string;
+};
+export declare function getGridRootA11yProps(input?: {
+    activeDescendantId?: string | null;
+    rowCount?: number;
+    colCount?: number;
+}): {
+    readonly 'aria-colcount'?: number | undefined;
+    readonly 'aria-rowcount'?: number | undefined;
+    readonly 'aria-activedescendant'?: string | undefined;
+    readonly role: "grid";
+    readonly tabindex: 0;
+};
+export declare function getGridHeaderA11yProps(input?: GridColumnA11yInput): {
+    readonly 'aria-sort'?: GridSortDirection | undefined;
+    readonly role: "columnheader";
+};
+export declare function getGridRowA11yProps(rowIndex?: number): {
+    readonly 'aria-rowindex'?: number | undefined;
+    readonly role: "row";
+};
+export declare function getGridCellA11yProps(input?: GridCellA11yInput): {
+    readonly 'aria-selected'?: boolean | undefined;
+    readonly 'aria-rowindex'?: number | undefined;
+    readonly 'aria-colindex'?: number | undefined;
+    readonly id?: string | undefined;
+    readonly role: "gridcell";
+};
+export declare function getGridCellDomId(baseId: string, rowIndex: number, colIndex: number): string;

package/dist/a11y.js

@@ -0,0 +1,37 @@
+export function getGridRootA11yProps(input = {}) {
+    return {
+        role: 'grid',
+        tabindex: 0,
+        ...(input.activeDescendantId
+            ? { 'aria-activedescendant': input.activeDescendantId }
+            : {}),
+        ...(input.rowCount !== undefined ? { 'aria-rowcount': input.rowCount } : {}),
+        ...(input.colCount !== undefined ? { 'aria-colcount': input.colCount } : {}),
+    };
+}
+export function getGridHeaderA11yProps(input = {}) {
+    const { sortable = false, sortDirection = 'none' } = input;
+    return {
+        role: 'columnheader',
+        ...(sortable ? { 'aria-sort': sortDirection } : {}),
+    };
+}
+export function getGridRowA11yProps(rowIndex) {
+    return {
+        role: 'row',
+        ...(rowIndex !== undefined ? { 'aria-rowindex': rowIndex } : {}),
+    };
+}
+export function getGridCellA11yProps(input = {}) {
+    const { colIndex, rowIndex, selected = false, id } = input;
+    return {
+        role: 'gridcell',
+        ...(id ? { id } : {}),
+        ...(colIndex !== undefined ? { 'aria-colindex': colIndex } : {}),
+        ...(rowIndex !== undefined ? { 'aria-rowindex': rowIndex } : {}),
+        ...(selected ? { 'aria-selected': true } : {}),
+    };
+}
+export function getGridCellDomId(baseId, rowIndex, colIndex) {
+    return `${baseId}_cell_${rowIndex}_${colIndex}`;
+}

package/dist/a11y.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/a11y.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import { getGridCellA11yProps, getGridHeaderA11yProps, getGridRootA11yProps, getGridRowA11yProps, } from './a11y';
+describe('a11y helpers', () => {
+    it('returns grid role props', () => {
+        expect(getGridRootA11yProps({
+            activeDescendantId: 'svgrid_cell_0_0',
+            rowCount: 10,
+            colCount: 5,
+        })).toEqual({
+            role: 'grid',
+            tabindex: 0,
+            'aria-activedescendant': 'svgrid_cell_0_0',
+            'aria-rowcount': 10,
+            'aria-colcount': 5,
+        });
+    });
+    it('returns header sort semantics', () => {
+        expect(getGridHeaderA11yProps({
+            sortable: true,
+            sortDirection: 'ascending',
+        })).toEqual({
+            role: 'columnheader',
+            'aria-sort': 'ascending',
+        });
+    });
+    it('returns row and cell indices for accessibility metadata', () => {
+        expect(getGridRowA11yProps(2)).toEqual({
+            role: 'row',
+            'aria-rowindex': 2,
+        });
+        expect(getGridCellA11yProps({
+            id: 'svgrid_cell_2_3',
+            rowIndex: 2,
+            colIndex: 3,
+            selected: true,
+        })).toEqual({
+            role: 'gridcell',
+            id: 'svgrid_cell_2_3',
+            'aria-colindex': 3,
+            'aria-rowindex': 2,
+            'aria-selected': true,
+        });
+    });
+});

package/dist/cell-formatting.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Helpers for SvGrid column `format` presets (numbers, currency, percent, date patterns).
+ */
+/** Map shortcut date patterns to Intl options (merged with caller `options`). */
+export declare function resolveDatePattern(pattern: string | undefined, kind: 'date' | 'datetime'): Intl.DateTimeFormatOptions | undefined;
+type NumericFormatInput = {
+    type: 'number' | 'currency' | 'percent';
+    locales?: string | string[];
+    currency?: string;
+    /** When type is percent: treat value as 0–100 instead of Intl’s 0–1 fraction */
+    valueIsPercentPoints?: boolean;
+    options?: Intl.NumberFormatOptions;
+};
+export declare function getDateFormatter(locales: string | string[] | undefined, options: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+/** Format a numeric value for number / currency / percent column formats. */
+export declare function formatNumericWithConfig(value: unknown, config: NumericFormatInput): string;
+export {};

package/dist/cell-formatting.js

@@ -0,0 +1,141 @@
+/**
+* Helpers for SvGrid column `format` presets (numbers, currency, percent, date patterns).
+*/
+/** Map shortcut date patterns to Intl options (merged with caller `options`). */
+export function resolveDatePattern(pattern, kind) {
+    if (!pattern)
+        return undefined;
+    const p = pattern.trim();
+    switch (p) {
+        /** Short numeric local date (no weekday). */
+        case 'd':
+            return kind === 'datetime'
+                ? {
+                    year: 'numeric',
+                    month: 'numeric',
+                    day: 'numeric',
+                    hour: 'numeric',
+                    minute: 'numeric',
+                }
+                : { year: 'numeric', month: 'numeric', day: 'numeric' };
+        /** Long spelled-out date (+ time if datetime). */
+        case 'D':
+            return kind === 'datetime'
+                ? {
+                    weekday: 'long',
+                    year: 'numeric',
+                    month: 'long',
+                    day: 'numeric',
+                    hour: 'numeric',
+                    minute: 'numeric',
+                }
+                : { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
+        /** ISO-friendly yyyy-mm-dd (with time when datetime). */
+        case 'y-m-d':
+            return kind === 'datetime'
+                ? {
+                    year: 'numeric',
+                    month: '2-digit',
+                    day: '2-digit',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    hour12: false,
+                }
+                : { year: 'numeric', month: '2-digit', day: '2-digit' };
+        case 'medium':
+            return { dateStyle: 'medium', timeStyle: kind === 'datetime' ? 'short' : undefined };
+        case 'short':
+            return { dateStyle: 'short', timeStyle: kind === 'datetime' ? 'short' : undefined };
+        case 'long':
+            return { dateStyle: 'long', timeStyle: kind === 'datetime' ? 'short' : undefined };
+        default:
+            return undefined;
+    }
+}
+/**
+ * `Intl.NumberFormat` is one of the most expensive constructors in the
+ * platform - building one per cell on every scroll makes large grids
+ * noticeably stutter. Cache instances by config signature (locale + style
+ * + currency + options).
+ */
+const numberFormatterCache = new Map();
+function getNumberFormatter(locales, options) {
+    // Stable key - for normal column configs the options object is reused
+    // (declared in module scope), so this stringifies a small static shape.
+    const key = (Array.isArray(locales) ? locales.join(',') : locales ?? '') +
+        '|' +
+        (options.style ?? '') +
+        '|' +
+        (options.currency ?? '') +
+        '|' +
+        (options.minimumFractionDigits ?? '') +
+        '|' +
+        (options.maximumFractionDigits ?? '') +
+        '|' +
+        (options.useGrouping ?? '') +
+        '|' +
+        (options.currencyDisplay ?? '') +
+        '|' +
+        (options.notation ?? '');
+    let fmt = numberFormatterCache.get(key);
+    if (!fmt) {
+        fmt = new Intl.NumberFormat(locales, options);
+        numberFormatterCache.set(key, fmt);
+    }
+    return fmt;
+}
+/** Cache of `Intl.DateTimeFormat` by `(locale, options)` signature. */
+const dateFormatterCache = new Map();
+export function getDateFormatter(locales, options) {
+    const key = (Array.isArray(locales) ? locales.join(',') : locales ?? '') +
+        '|' +
+        (options.dateStyle ?? '') +
+        '|' +
+        (options.timeStyle ?? '') +
+        '|' +
+        (options.year ?? '') +
+        '|' +
+        (options.month ?? '') +
+        '|' +
+        (options.day ?? '') +
+        '|' +
+        (options.hour ?? '') +
+        '|' +
+        (options.minute ?? '') +
+        '|' +
+        (options.second ?? '') +
+        '|' +
+        (options.weekday ?? '') +
+        '|' +
+        (options.hour12 ?? '');
+    let fmt = dateFormatterCache.get(key);
+    if (!fmt) {
+        fmt = new Intl.DateTimeFormat(locales, options);
+        dateFormatterCache.set(key, fmt);
+    }
+    return fmt;
+}
+/** Format a numeric value for number / currency / percent column formats. */
+export function formatNumericWithConfig(value, config) {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n))
+        return String(value ?? '');
+    const locales = config.locales;
+    if (config.type === 'currency') {
+        return getNumberFormatter(locales, {
+            style: 'currency',
+            currency: config.currency ?? 'USD',
+            ...config.options,
+        }).format(n);
+    }
+    if (config.type === 'percent') {
+        const frac = config.valueIsPercentPoints === true ? n / 100 : n;
+        return getNumberFormatter(locales, {
+            style: 'percent',
+            minimumFractionDigits: 0,
+            maximumFractionDigits: 2,
+            ...config.options,
+        }).format(frac);
+    }
+    return getNumberFormatter(locales, config.options ?? {}).format(n);
+}

package/dist/cell-formatting.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cell-formatting.test.js

@@ -0,0 +1,234 @@
+/**
+ * Unit tests for cell-formatting helpers.
+ *
+ * Covers every code path in:
+ *   - resolveDatePattern (every shortcut + datetime variant + unknown fallback)
+ *   - getDateFormatter (cache hit + cache miss path)
+ *   - formatNumericWithConfig (number, currency, percent + valueIsPercentPoints,
+ *     NaN/Infinity/null fallbacks, locale variants, option overrides)
+ *
+ * Locale assertions use partial substring matches where the exact Intl output
+ * differs between Node ICU builds.
+ */
+import { describe, expect, it } from 'vitest';
+import { formatNumericWithConfig, resolveDatePattern, getDateFormatter, } from './cell-formatting';
+describe('resolveDatePattern', () => {
+    it('returns undefined for missing pattern', () => {
+        expect(resolveDatePattern(undefined, 'date')).toBeUndefined();
+        expect(resolveDatePattern('', 'date')).toBeUndefined();
+    });
+    it('handles the "d" (short numeric) date pattern', () => {
+        expect(resolveDatePattern('d', 'date')).toEqual({
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+        });
+    });
+    it('handles the "d" datetime pattern (adds hour + minute)', () => {
+        const opts = resolveDatePattern('d', 'datetime');
+        expect(opts.hour).toBe('numeric');
+        expect(opts.minute).toBe('numeric');
+        expect(opts.year).toBe('numeric');
+    });
+    it('handles the "D" (long) date pattern', () => {
+        expect(resolveDatePattern('D', 'date')).toEqual({
+            weekday: 'long',
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+        });
+    });
+    it('handles the "D" datetime pattern with time', () => {
+        const opts = resolveDatePattern('D', 'datetime');
+        expect(opts.weekday).toBe('long');
+        expect(opts.month).toBe('long');
+        expect(opts.hour).toBe('numeric');
+    });
+    it('handles "y-m-d" ISO-friendly date pattern', () => {
+        expect(resolveDatePattern('y-m-d', 'date')).toEqual({
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+        });
+    });
+    it('handles "y-m-d" datetime pattern (24h, 2-digit)', () => {
+        const opts = resolveDatePattern('y-m-d', 'datetime');
+        expect(opts.hour).toBe('2-digit');
+        expect(opts.minute).toBe('2-digit');
+        expect(opts.hour12).toBe(false);
+    });
+    it('handles dateStyle shortcuts (medium, short, long) without timeStyle for date', () => {
+        expect(resolveDatePattern('medium', 'date')).toEqual({
+            dateStyle: 'medium',
+            timeStyle: undefined,
+        });
+        expect(resolveDatePattern('short', 'date')).toEqual({
+            dateStyle: 'short',
+            timeStyle: undefined,
+        });
+        expect(resolveDatePattern('long', 'date')).toEqual({
+            dateStyle: 'long',
+            timeStyle: undefined,
+        });
+    });
+    it('attaches timeStyle: short when kind is datetime for dateStyle shortcuts', () => {
+        expect(resolveDatePattern('medium', 'datetime')).toEqual({
+            dateStyle: 'medium',
+            timeStyle: 'short',
+        });
+        expect(resolveDatePattern('short', 'datetime')).toEqual({
+            dateStyle: 'short',
+            timeStyle: 'short',
+        });
+        expect(resolveDatePattern('long', 'datetime')).toEqual({
+            dateStyle: 'long',
+            timeStyle: 'short',
+        });
+    });
+    it('returns undefined for unknown patterns', () => {
+        expect(resolveDatePattern('weird', 'date')).toBeUndefined();
+        expect(resolveDatePattern('yyyy-mm', 'datetime')).toBeUndefined();
+    });
+    it('trims whitespace around the pattern', () => {
+        expect(resolveDatePattern('  d  ', 'date')).toEqual({
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+        });
+    });
+});
+describe('getDateFormatter', () => {
+    it('returns the same instance for repeated calls with the same signature', () => {
+        const a = getDateFormatter('en-US', { dateStyle: 'short' });
+        const b = getDateFormatter('en-US', { dateStyle: 'short' });
+        expect(a).toBe(b);
+    });
+    it('returns a different instance when the locale changes', () => {
+        const en = getDateFormatter('en-US', { dateStyle: 'short' });
+        const de = getDateFormatter('de-DE', { dateStyle: 'short' });
+        expect(en).not.toBe(de);
+    });
+    it('returns a different instance when options change', () => {
+        const a = getDateFormatter('en-US', { dateStyle: 'short' });
+        const b = getDateFormatter('en-US', { dateStyle: 'long' });
+        expect(a).not.toBe(b);
+    });
+    it('treats undefined locale and empty-array locale as distinct', () => {
+        const undefLocale = getDateFormatter(undefined, { dateStyle: 'short' });
+        const arrLocale = getDateFormatter([], { dateStyle: 'short' });
+        // Both produce a working formatter; just smoke-check they work.
+        expect(typeof undefLocale.format(new Date())).toBe('string');
+        expect(typeof arrLocale.format(new Date())).toBe('string');
+    });
+    it('keys correctly off every option dimension (smoke: each option produces a distinct cache entry)', () => {
+        // We exercise each conditional branch in the key construction so v8/c8
+        // counts the line as covered.
+        getDateFormatter('en-US', { year: 'numeric' });
+        getDateFormatter('en-US', { month: 'long' });
+        getDateFormatter('en-US', { day: '2-digit' });
+        getDateFormatter('en-US', { hour: '2-digit' });
+        getDateFormatter('en-US', { minute: '2-digit' });
+        getDateFormatter('en-US', { second: '2-digit' });
+        getDateFormatter('en-US', { weekday: 'short' });
+        getDateFormatter('en-US', { hour12: true });
+        getDateFormatter('en-US', { hour12: false });
+        getDateFormatter(['en-US', 'en-GB'], { dateStyle: 'short' });
+    });
+});
+describe('formatNumericWithConfig - number', () => {
+    it('formats a basic integer with default locale', () => {
+        expect(formatNumericWithConfig(1234, { type: 'number' })).toMatch(/1[\.,]?234/);
+    });
+    it('respects locale grouping and decimal separators', () => {
+        const de = formatNumericWithConfig(1234.5, { type: 'number', locales: 'de-DE' });
+        expect(de).toContain(',');
+        const en = formatNumericWithConfig(1234.5, { type: 'number', locales: 'en-US' });
+        expect(en).toContain('.');
+    });
+    it('forwards fraction-digit options', () => {
+        expect(formatNumericWithConfig(1.2345, {
+            type: 'number',
+            options: { minimumFractionDigits: 3, maximumFractionDigits: 3 },
+            locales: 'en-US',
+        })).toBe('1.235');
+    });
+    it('returns the raw String(value) for non-numeric input', () => {
+        expect(formatNumericWithConfig('abc', { type: 'number' })).toBe('abc');
+        expect(formatNumericWithConfig(NaN, { type: 'number' })).toBe('NaN');
+        expect(formatNumericWithConfig(Infinity, { type: 'number' })).toBe('Infinity');
+    });
+    it('treats null as 0 (Number(null) === 0) and undefined as String("")', () => {
+        // Number(null) === 0, so null formats as "0".
+        expect(formatNumericWithConfig(null, { type: 'number', locales: 'en-US' })).toBe('0');
+        // Number(undefined) === NaN -> falls back to String(undefined ?? '') -> "".
+        expect(formatNumericWithConfig(undefined, { type: 'number' })).toBe('');
+    });
+    it('accepts strings that parse to numbers', () => {
+        const result = formatNumericWithConfig('42', { type: 'number', locales: 'en-US' });
+        expect(result).toBe('42');
+    });
+});
+describe('formatNumericWithConfig - currency', () => {
+    it('defaults to USD when currency is omitted', () => {
+        const usd = formatNumericWithConfig(99.5, { type: 'currency', locales: 'en-US' });
+        expect(usd).toMatch(/\$99\.50/);
+    });
+    it('honors a custom currency', () => {
+        const eur = formatNumericWithConfig(99.5, {
+            type: 'currency',
+            currency: 'EUR',
+            locales: 'en-US',
+        });
+        expect(eur).toMatch(/€99\.50/);
+    });
+    it('merges caller options on top of currency defaults', () => {
+        const result = formatNumericWithConfig(1234.5, {
+            type: 'currency',
+            currency: 'USD',
+            locales: 'en-US',
+            options: { maximumFractionDigits: 0, minimumFractionDigits: 0 },
+        });
+        expect(result).toBe('$1,235');
+    });
+});
+describe('formatNumericWithConfig - percent', () => {
+    it('treats input as a 0..1 fraction by default', () => {
+        expect(formatNumericWithConfig(0.5, { type: 'percent', locales: 'en-US' })).toMatch(/50%/);
+    });
+    it('treats input as 0..100 points when valueIsPercentPoints is true', () => {
+        expect(formatNumericWithConfig(50, {
+            type: 'percent',
+            locales: 'en-US',
+            valueIsPercentPoints: true,
+        })).toMatch(/50%/);
+    });
+    it('respects fraction-digits override', () => {
+        const result = formatNumericWithConfig(0.123, {
+            type: 'percent',
+            locales: 'en-US',
+            options: { minimumFractionDigits: 1, maximumFractionDigits: 1 },
+        });
+        expect(result).toBe('12.3%');
+    });
+});
+describe('formatNumericWithConfig - cache reuse', () => {
+    it('reuses the cached Intl.NumberFormat instance across calls', () => {
+        // We can't access the cache directly, but we can verify that repeated
+        // calls with the same config produce identical output - any cache miss
+        // would still return the same string, so this is a smoke check.
+        const a = formatNumericWithConfig(10, { type: 'number', locales: 'en-US' });
+        const b = formatNumericWithConfig(10, { type: 'number', locales: 'en-US' });
+        expect(a).toBe(b);
+    });
+    it('handles array-of-locales input', () => {
+        const result = formatNumericWithConfig(1.5, {
+            type: 'number',
+            locales: ['en-US', 'en-GB'],
+        });
+        expect(result).toBe('1.5');
+    });
+    it('handles undefined locale (browser default)', () => {
+        const result = formatNumericWithConfig(1.5, { type: 'number' });
+        expect(typeof result).toBe('string');
+    });
+});

package/dist/chart-export.d.ts

@@ -0,0 +1,14 @@
+export type ChartExportOptions = {
+    /** Background color of the exported image. Default: the grid background. */
+    background?: string;
+    /** PNG pixel scale (1 = viewBox size). Default 2 (retina). */
+    scale?: number;
+};
+/** Serialize the chart SVG to a standalone, self-styled SVG string. */
+export declare function chartToSvgString(source: SVGSVGElement | HTMLElement, options?: ChartExportOptions): string;
+/** Download the chart as an `.svg` file. */
+export declare function downloadChartSvg(source: SVGSVGElement | HTMLElement, filename?: string, options?: ChartExportOptions): void;
+/** Rasterize the chart to a PNG `Blob`. */
+export declare function chartToPngBlob(source: SVGSVGElement | HTMLElement, options?: ChartExportOptions): Promise<Blob>;
+/** Download the chart as a `.png` file. */
+export declare function downloadChartPng(source: SVGSVGElement | HTMLElement, filename?: string, options?: ChartExportOptions): Promise<void>;