@svgrid/grid 1.1.2 → 1.2.3

package/dist/cell-formatting.test.js

@@ -1,234 +0,0 @@
-/**
- * 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/cell-render.test.d.ts

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

package/dist/cell-render.test.js

@@ -1,338 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createCellRender } from './cell-render';
-function makeRow(id, data) {
-    return {
-        id,
-        original: data,
-        getCellValueByColumnId: (colId) => data[colId],
-    };
-}
-function makeColumn(id, def = {}) {
-    return { id, columnDef: { ...def } };
-}
-function makeCtx(overrides = {}) {
-    return {
-        props: {},
-        grid: { id: 'grid' },
-        conditionalColumnStats: new Map(),
-        noteOverrides: {},
-        editorOptionsCache: {},
-        ...overrides,
-    };
-}
-describe('createCellRender / cellConditionalFormat', () => {
-    it('returns null when no conditionalFormats are configured', () => {
-        const cr = createCellRender(makeCtx());
-        const out = cr.cellConditionalFormat(makeRow('r1', { amt: 5 }), makeColumn('amt'), 5);
-        expect(out).toBeNull();
-    });
-    it('returns null when conditionalFormats is an empty array', () => {
-        const cr = createCellRender(makeCtx({ props: { conditionalFormats: [] } }));
-        expect(cr.cellConditionalFormat(makeRow('r', {}), makeColumn('amt'), 1)).toBeNull();
-    });
-    it('resolves a rule format against the value', () => {
-        const formats = [
-            {
-                type: 'rule',
-                columns: ['amt'],
-                when: ({ value }) => Number(value) > 10,
-                background: '#ff0000',
-                fontWeight: 700,
-            },
-        ];
-        const cr = createCellRender(makeCtx({ props: { conditionalFormats: formats } }));
-        const hit = cr.cellConditionalFormat(makeRow('r', { amt: 20 }), makeColumn('amt'), 20);
-        expect(hit?.background).toBe('#ff0000');
-        expect(hit?.fontWeight).toBe(700);
-        const miss = cr.cellConditionalFormat(makeRow('r', { amt: 1 }), makeColumn('amt'), 1);
-        expect(miss).toEqual({});
-    });
-    it('passes the precomputed column stat through to colorScale formats', () => {
-        const formats = [{ type: 'colorScale', min: '#fff', max: '#000' }];
-        const stats = new Map([['amt', { min: 0, max: 100 }]]);
-        const cr = createCellRender(makeCtx({ props: { conditionalFormats: formats }, conditionalColumnStats: stats }));
-        const out = cr.cellConditionalFormat(makeRow('r', { amt: 50 }), makeColumn('amt'), 50);
-        expect(out).not.toBeNull();
-        expect(out?.background).toBeDefined();
-    });
-});
-describe('createCellRender / computeRowClass', () => {
-    it('returns empty string when no rowClass configured', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computeRowClass(makeRow('r', {}), 0)).toBe('');
-    });
-    it('resolves a string rowClass', () => {
-        const rowClass = vi.fn(() => 'highlight');
-        const cr = createCellRender(makeCtx({ props: { rowClass } }));
-        const row = makeRow('r', { a: 1 });
-        expect(cr.computeRowClass(row, 3)).toBe('highlight');
-        expect(rowClass).toHaveBeenCalledWith({ row: row.original, rowIndex: 3 });
-    });
-    it('resolves an array / object rowClass', () => {
-        const cr = createCellRender(makeCtx({ props: { rowClass: () => ['a', '', 'b'] } }));
-        expect(cr.computeRowClass(makeRow('r', {}), 0)).toBe('a b');
-        const cr2 = createCellRender(makeCtx({ props: { rowClass: () => ({ on: true, off: false }) } }));
-        expect(cr2.computeRowClass(makeRow('r', {}), 0)).toBe('on');
-    });
-});
-describe('createCellRender / computeCellClass', () => {
-    it('returns empty string when cellClass is null/undefined', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computeCellClass(makeRow('r', {}), makeColumn('a'))).toBe('');
-    });
-    it('resolves a string cellClass', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computeCellClass(makeRow('r', {}), makeColumn('a', { cellClass: 'red' }))).toBe('red');
-    });
-    it('resolves an array cellClass', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computeCellClass(makeRow('r', {}), makeColumn('a', { cellClass: ['x', 'y'] }))).toBe('x y');
-    });
-    it('invokes a function cellClass with a minimal cell context', () => {
-        const cellClass = vi.fn((c) => (c.getValue() > 5 ? 'big' : 'small'));
-        const cr = createCellRender(makeCtx());
-        const row = makeRow('r', { score: 9 });
-        expect(cr.computeCellClass(row, makeColumn('score', { cellClass }))).toBe('big');
-        expect(cellClass).toHaveBeenCalledTimes(1);
-        const passed = cellClass.mock.calls[0][0];
-        expect(passed.row).toBe(row);
-        expect(passed.getValue()).toBe(9);
-    });
-    it('returns empty string for an unsupported cellClass type (number)', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computeCellClass(makeRow('r', {}), makeColumn('a', { cellClass: 123 }))).toBe('');
-    });
-});
-describe('createCellRender / computeCellTooltip', () => {
-    it('returns null when no tooltip configured', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computeCellTooltip(makeRow('r', {}), makeColumn('a'))).toBeNull();
-    });
-    it('returns a static string tooltip, but null for empty string', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computeCellTooltip(makeRow('r', {}), makeColumn('a', { tooltip: 'help' }))).toBe('help');
-        expect(cr.computeCellTooltip(makeRow('r', {}), makeColumn('a', { tooltip: '' }))).toBeNull();
-    });
-    it('invokes a function tooltip and stringifies the result', () => {
-        const tooltip = (c) => `val=${c.getValue()}`;
-        const cr = createCellRender(makeCtx());
-        const row = makeRow('r', { a: 42 });
-        expect(cr.computeCellTooltip(row, makeColumn('a', { tooltip }))).toBe('val=42');
-    });
-    it('returns null when the function tooltip returns a falsy value', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computeCellTooltip(makeRow('r', {}), makeColumn('a', { tooltip: () => '' }))).toBeNull();
-    });
-    it('returns null for an unsupported tooltip type', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computeCellTooltip(makeRow('r', {}), makeColumn('a', { tooltip: 5 }))).toBeNull();
-    });
-});
-describe('createCellRender / computeCellNote', () => {
-    it('returns null when neither overrides nor notes have an entry', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computeCellNote(makeRow('r', {}), makeColumn('a'))).toBeNull();
-    });
-    it('prefers the internal note override over props.notes', () => {
-        const cr = createCellRender(makeCtx({
-            noteOverrides: { r: { a: 'overlay' } },
-            props: { notes: { r: { a: 'stored' } } },
-        }));
-        expect(cr.computeCellNote(makeRow('r', {}), makeColumn('a'))).toBe('overlay');
-    });
-    it('treats a blank override as a removal (null)', () => {
-        const cr = createCellRender(makeCtx({
-            noteOverrides: { r: { a: '   ' } },
-            props: { notes: { r: { a: 'stored' } } },
-        }));
-        expect(cr.computeCellNote(makeRow('r', {}), makeColumn('a'))).toBeNull();
-    });
-    it('falls back to props.notes when no override exists', () => {
-        const cr = createCellRender(makeCtx({ props: { notes: { r: { a: 'stored note' } } } }));
-        expect(cr.computeCellNote(makeRow('r', {}), makeColumn('a'))).toBe('stored note');
-    });
-    it('returns null for a whitespace-only stored note', () => {
-        const cr = createCellRender(makeCtx({ props: { notes: { r: { a: '  ' } } } }));
-        expect(cr.computeCellNote(makeRow('r', {}), makeColumn('a'))).toBeNull();
-    });
-    it('returns null when the row or column is absent in the notes map', () => {
-        const cr = createCellRender(makeCtx({ props: { notes: { other: { a: 'x' } } } }));
-        expect(cr.computeCellNote(makeRow('r', {}), makeColumn('a'))).toBeNull();
-        const cr2 = createCellRender(makeCtx({ props: { notes: { r: { b: 'x' } } } }));
-        expect(cr2.computeCellNote(makeRow('r', {}), makeColumn('a'))).toBeNull();
-    });
-});
-describe('createCellRender / getColumnEditorOptions', () => {
-    it('returns [] for a function editorOptions when row has no original', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', { editorOptions: () => [{ value: 1, label: 'one' }] });
-        expect(cr.getColumnEditorOptions(col, null)).toEqual([]);
-    });
-    it('evaluates a function editorOptions per row', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', {
-            editorOptions: (data) => [{ value: data.code, label: data.name }],
-        });
-        const row = makeRow('r', { code: 'x', name: 'X' });
-        const opts = cr.getColumnEditorOptions(col, row);
-        expect(opts).toEqual([{ value: 'x', label: 'X' }]);
-    });
-    it('caches normalized static editorOptions and reuses them', () => {
-        const ctx = makeCtx();
-        const cr = createCellRender(ctx);
-        const src = ['a', 'b'];
-        const col = makeColumn('a', { editorOptions: src });
-        const first = cr.getColumnEditorOptions(col);
-        const second = cr.getColumnEditorOptions(col);
-        expect(first).toBe(second); // same cached array reference
-        expect(ctx.editorOptionsCache['a']).toBe(first);
-    });
-    it('re-normalizes when the editorOptions source changes', () => {
-        const ctx = makeCtx();
-        const cr = createCellRender(ctx);
-        const first = cr.getColumnEditorOptions(makeColumn('a', { editorOptions: ['a'] }));
-        const second = cr.getColumnEditorOptions(makeColumn('a', { editorOptions: ['b'] }));
-        expect(first).not.toBe(second);
-    });
-});
-describe('createCellRender / formatListCellValue', () => {
-    it('joins an array of values using the default separator', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', {
-            editorOptions: [
-                { value: 1, label: 'One' },
-                { value: 2, label: 'Two' },
-            ],
-        });
-        expect(cr.formatListCellValue(col, [1, 2])).toBe('One, Two');
-    });
-    it('honors a custom editorSeparator', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', {
-            editorSeparator: ' | ',
-            editorOptions: [
-                { value: 1, label: 'One' },
-                { value: 2, label: 'Two' },
-            ],
-        });
-        expect(cr.formatListCellValue(col, [1, 2])).toBe('One | Two');
-    });
-    it('returns empty string for null / empty scalar values', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', { editorOptions: [] });
-        expect(cr.formatListCellValue(col, null)).toBe('');
-        expect(cr.formatListCellValue(col, '')).toBe('');
-    });
-    it('maps a single scalar value to its label', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', {
-            editorOptions: [{ value: 'k', label: 'Known' }],
-        });
-        expect(cr.formatListCellValue(col, 'k')).toBe('Known');
-        // unknown value falls back to its string form
-        expect(cr.formatListCellValue(col, 'z')).toBe('z');
-    });
-});
-describe('createCellRender / formatCellValue', () => {
-    const row = makeRow('r', {});
-    it('uses a custom formatter callback when present', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', {
-            formatter: ({ value }) => `<<${value}>>`,
-        });
-        expect(cr.formatCellValue(col, 7, row)).toBe('<<7>>');
-    });
-    it('coerces a nullish formatter result to empty string', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', { formatter: () => null });
-        expect(cr.formatCellValue(col, 1, row)).toBe('');
-    });
-    it('masks password columns with bullets, capped at 12', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', { editorType: 'password' });
-        expect(cr.formatCellValue(col, 'abc', row)).toBe('•••');
-        expect(cr.formatCellValue(col, '', row)).toBe('');
-        expect(cr.formatCellValue(col, 'x'.repeat(50), row)).toBe('•'.repeat(12));
-    });
-    it('stringifies plain values when there is no format config', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a');
-        expect(cr.formatCellValue(col, 'hello', row)).toBe('hello');
-        expect(cr.formatCellValue(col, null, row)).toBe('');
-    });
-    it('applies numeric / currency / percent format configs', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.formatCellValue(makeColumn('a', { format: { type: 'number' } }), 1234.5, row)).toContain('1,234');
-        const cur = cr.formatCellValue(makeColumn('a', { format: { type: 'currency', currency: 'USD' } }), 1000, row);
-        expect(cur).toContain('$');
-        const pct = cr.formatCellValue(makeColumn('a', { format: { type: 'percent' } }), 0.25, row);
-        expect(pct).toContain('%');
-    });
-    it('formats date configs and falls back when the value is not a date', () => {
-        const cr = createCellRender(makeCtx());
-        const dateCol = makeColumn('a', { format: { type: 'date' } });
-        const out = cr.formatCellValue(dateCol, '2024-01-15T00:00:00Z', row);
-        expect(out).toMatch(/2024/);
-        // Unparseable -> returns String(value)
-        expect(cr.formatCellValue(dateCol, 'not-a-date', row)).toBe('not-a-date');
-    });
-    it('formats datetime configs with merged default options', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', { format: { type: 'datetime' } });
-        const out = cr.formatCellValue(col, '2024-03-10T13:45:00Z', row);
-        expect(out).toMatch(/2024/);
-    });
-});
-describe('createCellRender / formatPinnedValue', () => {
-    it('invokes a formatter with a null row', () => {
-        const cr = createCellRender(makeCtx());
-        const formatter = vi.fn(({ value, row }) => `${value}:${row}`);
-        const col = makeColumn('a', { formatter });
-        expect(cr.formatPinnedValue(col, 5)).toBe('5:null');
-        expect(formatter.mock.calls[0][0].row).toBeNull();
-    });
-    it('masks password pinned values', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.formatPinnedValue(makeColumn('a', { editorType: 'password' }), 'pw')).toBe('••');
-        expect(cr.formatPinnedValue(makeColumn('a', { editorType: 'password' }), '')).toBe('');
-    });
-    it('stringifies when no format config', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.formatPinnedValue(makeColumn('a'), 'total')).toBe('total');
-        expect(cr.formatPinnedValue(makeColumn('a'), null)).toBe('');
-    });
-    it('applies numeric and date format configs', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.formatPinnedValue(makeColumn('a', { format: { type: 'number' } }), 9999)).toContain('9,999');
-        const d = cr.formatPinnedValue(makeColumn('a', { format: { type: 'date' } }), '2022-06-01T00:00:00Z');
-        expect(d).toMatch(/2022/);
-        // unparseable date falls through to String()
-        expect(cr.formatPinnedValue(makeColumn('a', { format: { type: 'date' } }), 'xyz')).toBe('xyz');
-    });
-    it('formats datetime pinned configs', () => {
-        const cr = createCellRender(makeCtx());
-        const out = cr.formatPinnedValue(makeColumn('a', { format: { type: 'datetime' } }), '2021-12-31T08:00:00Z');
-        expect(out).toMatch(/2021/);
-    });
-});
-describe('createCellRender / computePinnedCellClass', () => {
-    it('returns empty string when cellClass is not a function', () => {
-        const cr = createCellRender(makeCtx());
-        expect(cr.computePinnedCellClass({ a: 1 }, makeColumn('a', { cellClass: 'x' }))).toBe('');
-    });
-    it('invokes a function cellClass with a null row and the pinned value', () => {
-        const cr = createCellRender(makeCtx());
-        const cellClass = vi.fn((c) => (c.value > 0 ? 'pos' : 'neg'));
-        const col = makeColumn('a', {
-            cellClass,
-            field: 'a',
-        });
-        expect(cr.computePinnedCellClass({ a: 3 }, col)).toBe('pos');
-        expect(cellClass.mock.calls[0][0].row).toBeNull();
-    });
-    it('coerces a falsy cellClass result to empty string', () => {
-        const cr = createCellRender(makeCtx());
-        const col = makeColumn('a', { cellClass: () => undefined, field: 'a' });
-        expect(cr.computePinnedCellClass({ a: 1 }, col)).toBe('');
-    });
-});

package/dist/chart-export.test.d.ts

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