@svgrid/grid 1.1.0 → 1.1.2

package/dist/SvGrid.helpers.test.js

@@ -0,0 +1,298 @@
+import { describe, expect, it } from 'vitest';
+import { cfTextStyle, fmtStat, getCellKey, resolveClassList, toDateInputValue, toDateTimeLocalInputValue, getEditableInputValue, getEditorInputType, toValueArray, getOptionLabel, getOptionColor, colorfulChipStyle, getEditorClass, asDate, clampMenuX, cssEscape, rawToNumber, formatFacetNumber, formatFacetDate, } from './SvGrid.helpers';
+describe('cfTextStyle', () => {
+    it('returns empty string when no color or fontWeight', () => {
+        expect(cfTextStyle({})).toBe('');
+    });
+    it('emits a color declaration', () => {
+        expect(cfTextStyle({ color: 'red' })).toBe('color:red;');
+    });
+    it('emits a font-weight declaration including 0 (not null)', () => {
+        expect(cfTextStyle({ fontWeight: 700 })).toBe('font-weight:700;');
+    });
+    it('combines color and fontWeight', () => {
+        expect(cfTextStyle({ color: '#fff', fontWeight: 'bold' })).toBe('color:#fff;font-weight:bold;');
+    });
+    it('omits font-weight when it is null', () => {
+        expect(cfTextStyle({ color: 'blue', fontWeight: null })).toBe('color:blue;');
+    });
+});
+describe('fmtStat', () => {
+    it('formats integers with locale grouping', () => {
+        expect(fmtStat(1000)).toBe((1000).toLocaleString());
+    });
+    it('rounds floats to at most 2 fraction digits', () => {
+        expect(fmtStat(1.23456)).toBe((1.23456).toLocaleString(undefined, { maximumFractionDigits: 2 }));
+    });
+    it('treats whole-number floats as integers', () => {
+        expect(fmtStat(5.0)).toBe((5).toLocaleString());
+    });
+});
+describe('getCellKey', () => {
+    it('joins rowId and columnId with a colon', () => {
+        expect(getCellKey('r1', 'colA')).toBe('r1:colA');
+    });
+});
+describe('resolveClassList', () => {
+    it('returns empty for null/undefined/empty', () => {
+        expect(resolveClassList(null)).toBe('');
+        expect(resolveClassList(undefined)).toBe('');
+        expect(resolveClassList('')).toBe('');
+    });
+    it('passes a plain string through unchanged', () => {
+        expect(resolveClassList('a b')).toBe('a b');
+    });
+    it('joins arrays and drops falsy entries', () => {
+        expect(resolveClassList(['a', '', 'b'])).toBe('a b');
+    });
+    it('emits only truthy keys of a record', () => {
+        expect(resolveClassList({ a: true, b: false, c: true })).toBe('a c');
+    });
+    it('returns empty string for an all-false record', () => {
+        expect(resolveClassList({ a: false })).toBe('');
+    });
+});
+describe('toDateInputValue', () => {
+    it('returns empty for null/undefined/empty', () => {
+        expect(toDateInputValue(null)).toBe('');
+        expect(toDateInputValue(undefined)).toBe('');
+        expect(toDateInputValue('')).toBe('');
+    });
+    it('passes an already-ISO date string through', () => {
+        expect(toDateInputValue('2024-01-15')).toBe('2024-01-15');
+    });
+    it('formats a Date instance to yyyy-mm-dd', () => {
+        expect(toDateInputValue(new Date(Date.UTC(2024, 0, 15)))).toBe('2024-01-15');
+    });
+    it('parses a numeric timestamp', () => {
+        const ts = Date.UTC(2020, 5, 1);
+        expect(toDateInputValue(ts)).toBe('2020-06-01');
+    });
+    it('returns empty for an unparseable value', () => {
+        expect(toDateInputValue('not-a-date')).toBe('');
+    });
+});
+describe('toDateTimeLocalInputValue', () => {
+    it('returns empty for null/empty', () => {
+        expect(toDateTimeLocalInputValue(null)).toBe('');
+        expect(toDateTimeLocalInputValue('')).toBe('');
+    });
+    it('passes a matching datetime-local string through', () => {
+        expect(toDateTimeLocalInputValue('2024-01-15T13:45')).toBe('2024-01-15T13:45');
+    });
+    it('formats a Date instance to yyyy-mm-ddThh:mm', () => {
+        expect(toDateTimeLocalInputValue(new Date(Date.UTC(2024, 0, 15, 8, 30)))).toBe('2024-01-15T08:30');
+    });
+    it('returns empty for an invalid value', () => {
+        expect(toDateTimeLocalInputValue('garbage')).toBe('');
+    });
+});
+describe('getEditableInputValue', () => {
+    it('delegates to the date formatter for date editors', () => {
+        expect(getEditableInputValue('date', '2024-01-15')).toBe('2024-01-15');
+    });
+    it('delegates to the datetime formatter for datetime editors', () => {
+        expect(getEditableInputValue('datetime', '2024-01-15T10:00')).toBe('2024-01-15T10:00');
+    });
+    it('stringifies other editor types', () => {
+        expect(getEditableInputValue('text', 42)).toBe('42');
+    });
+    it('returns empty string for nullish values', () => {
+        expect(getEditableInputValue('text', null)).toBe('');
+    });
+});
+describe('getEditorInputType', () => {
+    it('maps each known editor type to its input type', () => {
+        expect(getEditorInputType('number')).toBe('number');
+        expect(getEditorInputType('date')).toBe('date');
+        expect(getEditorInputType('datetime')).toBe('datetime-local');
+        expect(getEditorInputType('time')).toBe('time');
+        expect(getEditorInputType('password')).toBe('password');
+        expect(getEditorInputType('color')).toBe('color');
+    });
+    it('falls back to text for unknown editor types', () => {
+        expect(getEditorInputType('select')).toBe('text');
+    });
+});
+describe('toValueArray', () => {
+    it('returns empty for null/empty', () => {
+        expect(toValueArray(null)).toEqual([]);
+        expect(toValueArray('')).toEqual([]);
+    });
+    it('filters nullish/empty entries from an array', () => {
+        expect(toValueArray([1, null, '', 2, undefined])).toEqual([1, 2]);
+    });
+    it('wraps a scalar in an array', () => {
+        expect(toValueArray('x')).toEqual(['x']);
+        expect(toValueArray(7)).toEqual([7]);
+    });
+});
+describe('getOptionLabel', () => {
+    const options = [
+        { value: 1, label: 'One' },
+        { value: 'two', label: 'Two' },
+    ];
+    it('finds the label by strict value match', () => {
+        expect(getOptionLabel(options, 1)).toBe('One');
+    });
+    it('finds the label by stringified value match', () => {
+        expect(getOptionLabel(options, '1')).toBe('One');
+    });
+    it('falls back to the stringified value when no option matches', () => {
+        expect(getOptionLabel(options, 99)).toBe('99');
+    });
+    it('returns empty string for a nullish unmatched value', () => {
+        expect(getOptionLabel(options, null)).toBe('');
+    });
+});
+describe('getOptionColor', () => {
+    const options = [
+        { value: 'a', label: 'A', color: '#f00' },
+        { value: 'b', label: 'B' },
+    ];
+    it('returns the configured color', () => {
+        expect(getOptionColor(options, 'a')).toBe('#f00');
+    });
+    it('returns undefined when matched option has no color', () => {
+        expect(getOptionColor(options, 'b')).toBeUndefined();
+    });
+    it('returns undefined when no option matches', () => {
+        expect(getOptionColor(options, 'z')).toBeUndefined();
+    });
+    it('matches by stringified value', () => {
+        const opts = [{ value: 5, label: 'Five', color: 'green' }];
+        expect(getOptionColor(opts, '5')).toBe('green');
+    });
+});
+describe('colorfulChipStyle', () => {
+    it('returns empty for no color', () => {
+        expect(colorfulChipStyle(undefined)).toBe('');
+    });
+    it('builds a color-mix based style with the given color', () => {
+        const style = colorfulChipStyle('#abc');
+        expect(style).toContain('background: color-mix(in srgb, #abc 22%, transparent);');
+        expect(style).toContain('border-color: color-mix(in srgb, #abc 45%, transparent);');
+        expect(style).toContain('color: color-mix(in srgb, #abc 80%, var(--sg-fg, #0f172a));');
+    });
+});
+describe('getEditorClass', () => {
+    it('returns the modifier class for each editor type', () => {
+        expect(getEditorClass('number')).toBe('sv-grid-cell-editor sv-grid-cell-editor-number');
+        expect(getEditorClass('date')).toBe('sv-grid-cell-editor sv-grid-cell-editor-date');
+        expect(getEditorClass('datetime')).toBe('sv-grid-cell-editor sv-grid-cell-editor-datetime');
+        expect(getEditorClass('color')).toBe('sv-grid-cell-editor sv-grid-cell-editor-color');
+    });
+    it('returns the base class for other editor types', () => {
+        expect(getEditorClass('text')).toBe('sv-grid-cell-editor');
+    });
+});
+describe('asDate', () => {
+    it('returns null for null/empty', () => {
+        expect(asDate(null)).toBeNull();
+        expect(asDate('')).toBeNull();
+    });
+    it('returns the same Date instance for a Date', () => {
+        const d = new Date(2024, 0, 1);
+        expect(asDate(d)).toBe(d);
+    });
+    it('parses a date string', () => {
+        const result = asDate('2024-01-15');
+        expect(result).toBeInstanceOf(Date);
+        expect(result?.getUTCFullYear()).toBe(2024);
+    });
+    it('returns null for an invalid date', () => {
+        expect(asDate('nope')).toBeNull();
+    });
+});
+describe('clampMenuX', () => {
+    it('clamps to the left minimum of 8', () => {
+        expect(clampMenuX(-50, 100)).toBe(8);
+    });
+    it('clamps against the right edge', () => {
+        const max = window.innerWidth - 100 - 8;
+        expect(clampMenuX(window.innerWidth, 100)).toBe(max);
+    });
+    it('returns the value unchanged when it fits', () => {
+        expect(clampMenuX(20, 50)).toBe(20);
+    });
+});
+describe('cssEscape', () => {
+    const hasCssEscape = typeof CSS !== 'undefined' && typeof CSS.escape === 'function';
+    it('delegates to CSS.escape when available, otherwise escapes quotes', () => {
+        if (hasCssEscape) {
+            expect(cssEscape('1abc')).toBe(CSS.escape('1abc'));
+        }
+        else {
+            // Fallback only escapes double quotes.
+            expect(cssEscape('a"b')).toBe('a\\"b');
+        }
+    });
+    it('uses the quote-escaping fallback path when CSS is unavailable', () => {
+        const original = globalThis.CSS;
+        globalThis.CSS = undefined;
+        try {
+            expect(cssEscape('say "hi"')).toBe('say \\"hi\\"');
+            expect(cssEscape('plain')).toBe('plain');
+        }
+        finally {
+            ;
+            globalThis.CSS = original;
+        }
+    });
+    it('leaves a plain identifier intact', () => {
+        expect(cssEscape('abc')).toBe('abc');
+    });
+});
+describe('rawToNumber', () => {
+    it('returns NaN for null/empty', () => {
+        expect(rawToNumber(null, false)).toBeNaN();
+        expect(rawToNumber('', false)).toBeNaN();
+    });
+    it('returns a numeric value as-is', () => {
+        expect(rawToNumber(42, false)).toBe(42);
+    });
+    it('coerces a numeric string', () => {
+        expect(rawToNumber('3.5', false)).toBe(3.5);
+    });
+    it('returns NaN for a non-numeric string', () => {
+        expect(rawToNumber('abc', false)).toBeNaN();
+    });
+    it('returns the timestamp for a Date when isDate is true', () => {
+        const d = new Date(Date.UTC(2024, 0, 1));
+        expect(rawToNumber(d, true)).toBe(d.getTime());
+    });
+    it('parses a date string to a timestamp when isDate is true', () => {
+        expect(rawToNumber('2024-01-01', true)).toBe(new Date('2024-01-01').getTime());
+    });
+    it('returns NaN for an invalid date when isDate is true', () => {
+        expect(rawToNumber('not-a-date', true)).toBeNaN();
+    });
+});
+describe('formatFacetNumber', () => {
+    it('uses 0 fraction digits for magnitudes >= 1000', () => {
+        expect(formatFacetNumber(1234.56)).toBe((1234.56).toLocaleString(undefined, { maximumFractionDigits: 0 }));
+    });
+    it('uses 1 fraction digit for magnitudes >= 100', () => {
+        expect(formatFacetNumber(123.456)).toBe((123.456).toLocaleString(undefined, { maximumFractionDigits: 1 }));
+    });
+    it('uses 2 fraction digits for magnitudes >= 1', () => {
+        expect(formatFacetNumber(1.2345)).toBe((1.2345).toLocaleString(undefined, { maximumFractionDigits: 2 }));
+    });
+    it('uses 4 fraction digits for small magnitudes', () => {
+        expect(formatFacetNumber(0.123456)).toBe((0.123456).toLocaleString(undefined, { maximumFractionDigits: 4 }));
+    });
+    it('handles negative numbers via absolute magnitude', () => {
+        expect(formatFacetNumber(-2000)).toBe((-2000).toLocaleString(undefined, { maximumFractionDigits: 0 }));
+    });
+});
+describe('formatFacetDate', () => {
+    it('formats a timestamp into a short localized date', () => {
+        const ts = Date.UTC(2024, 0, 15);
+        const expected = new Date(ts).toLocaleDateString(undefined, {
+            year: 'numeric',
+            month: 'short',
+            day: 'numeric',
+        });
+        expect(formatFacetDate(ts)).toBe(expected);
+    });
+});