@svgrid/grid 1.1.1 → 1.2.1

package/dist/filter-operators.test.js

@@ -1,135 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { filterOperatorOptions, fallbackOperatorOption, TEXT_OPERATORS, NUMBER_OPERATORS, DATE_OPERATORS, CHECKBOX_OPERATORS, operatorOption, operatorsForColumn, defaultOperatorFor, operatorLabelFor, } from "./filter-operators";
-// `operatorsForColumn` / `defaultOperatorFor` / `operatorLabelFor` only ever
-// read `column?.columnDef.editorType`, so a minimal duck-typed stub is enough
-// to exercise every branch without standing up a real grid/column instance.
-function col(editorType) {
-    return editorType === undefined
-        ? { columnDef: {} }
-        : { columnDef: { editorType } };
-}
-describe("filter-operators: catalogue integrity", () => {
-    it("every option exposes value/label/iconName and a unique value", () => {
-        const values = filterOperatorOptions.map((o) => o.value);
-        expect(new Set(values).size).toBe(values.length);
-        for (const o of filterOperatorOptions) {
-            expect(typeof o.value).toBe("string");
-            expect(typeof o.label).toBe("string");
-            expect(o.iconName).toMatch(/^op-/);
-        }
-    });
-    it("fallback option is the 'contains' operator", () => {
-        expect(fallbackOperatorOption.value).toBe("contains");
-        expect(fallbackOperatorOption.label).toBe("Contains");
-    });
-    it("each type's operator list only references catalogued operators", () => {
-        const known = new Set(filterOperatorOptions.map((o) => o.value));
-        for (const list of [
-            TEXT_OPERATORS,
-            NUMBER_OPERATORS,
-            DATE_OPERATORS,
-            CHECKBOX_OPERATORS,
-        ]) {
-            for (const id of list)
-                expect(known.has(id)).toBe(true);
-        }
-    });
-    it("the catalogue includes between / isBlank for numeric + date filtering", () => {
-        const values = filterOperatorOptions.map((o) => o.value);
-        expect(values).toContain("between");
-        expect(values).toContain("isBlank");
-    });
-});
-describe("operatorOption", () => {
-    it("returns the matching option for every catalogued operator", () => {
-        for (const o of filterOperatorOptions) {
-            expect(operatorOption(o.value)).toBe(o);
-        }
-    });
-    it("looks up a specific operator by value", () => {
-        expect(operatorOption("between")).toMatchObject({
-            value: "between",
-            label: "Between",
-        });
-        expect(operatorOption("greaterThan").label).toBe("Greater than");
-        expect(operatorOption("lessThan").label).toBe("Less than");
-        expect(operatorOption("startsWith").label).toBe("Starts with");
-    });
-    it("falls back to 'contains' for an unknown operator value", () => {
-        const result = operatorOption("nope");
-        expect(result).toBe(fallbackOperatorOption);
-        expect(result.value).toBe("contains");
-    });
-});
-describe("operatorsForColumn", () => {
-    const labels = (opts) => opts.map((o) => o.value);
-    it("number columns get equals/greaterThan/lessThan/between/isBlank", () => {
-        expect(labels(operatorsForColumn(col("number")))).toEqual(NUMBER_OPERATORS);
-    });
-    it("date columns get the date operator set", () => {
-        expect(labels(operatorsForColumn(col("date")))).toEqual(DATE_OPERATORS);
-    });
-    it("datetime columns share the date operator set", () => {
-        expect(labels(operatorsForColumn(col("datetime")))).toEqual(DATE_OPERATORS);
-    });
-    it("checkbox columns get only equals + isBlank", () => {
-        expect(labels(operatorsForColumn(col("checkbox")))).toEqual(CHECKBOX_OPERATORS);
-    });
-    it("text columns get the text operator set", () => {
-        expect(labels(operatorsForColumn(col("text")))).toEqual(TEXT_OPERATORS);
-    });
-    it("an unknown editor type defaults to the text operator set", () => {
-        expect(labels(operatorsForColumn(col("currency")))).toEqual(TEXT_OPERATORS);
-    });
-    it("a column with no editorType defaults to text", () => {
-        expect(labels(operatorsForColumn(col()))).toEqual(TEXT_OPERATORS);
-    });
-    it("an undefined column defaults to the text operator set", () => {
-        expect(labels(operatorsForColumn(undefined))).toEqual(TEXT_OPERATORS);
-    });
-    it("returns full FilterOption objects (value+label+iconName), in order", () => {
-        const opts = operatorsForColumn(col("number"));
-        expect(opts[0]).toMatchObject({ value: "equals", iconName: "op-equals" });
-        for (const o of opts) {
-            expect(o).toHaveProperty("label");
-            expect(o).toHaveProperty("iconName");
-        }
-    });
-});
-describe("defaultOperatorFor", () => {
-    it("picks the first operator valid for the column type", () => {
-        expect(defaultOperatorFor(col("number"))).toBe("equals");
-        expect(defaultOperatorFor(col("date"))).toBe("equals");
-        expect(defaultOperatorFor(col("checkbox"))).toBe("equals");
-        expect(defaultOperatorFor(col("text"))).toBe("contains");
-    });
-    it("defaults to 'contains' for text / unknown / undefined columns", () => {
-        expect(defaultOperatorFor(col())).toBe("contains");
-        expect(defaultOperatorFor(undefined)).toBe("contains");
-        expect(defaultOperatorFor(col("mystery"))).toBe("contains");
-    });
-});
-describe("operatorLabelFor", () => {
-    const less = operatorOption("lessThan");
-    const greater = operatorOption("greaterThan");
-    const equals = operatorOption("equals");
-    it("renames lessThan/greaterThan to Before/After for date columns", () => {
-        expect(operatorLabelFor(less, col("date"))).toBe("Before");
-        expect(operatorLabelFor(greater, col("date"))).toBe("After");
-    });
-    it("applies the date relabelling for datetime columns too", () => {
-        expect(operatorLabelFor(less, col("datetime"))).toBe("Before");
-        expect(operatorLabelFor(greater, col("datetime"))).toBe("After");
-    });
-    it("leaves non-relabelled operators untouched on date columns", () => {
-        expect(operatorLabelFor(equals, col("date"))).toBe(equals.label);
-    });
-    it("keeps the catalogue label for non-date columns", () => {
-        expect(operatorLabelFor(less, col("number"))).toBe("Less than");
-        expect(operatorLabelFor(greater, col("number"))).toBe("Greater than");
-        expect(operatorLabelFor(less, col("text"))).toBe("Less than");
-    });
-    it("keeps the catalogue label when the column is undefined", () => {
-        expect(operatorLabelFor(greater, undefined)).toBe("Greater than");
-    });
-});

package/dist/filtering/excel-filters.test.d.ts

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

package/dist/filtering/excel-filters.test.js

@@ -1,116 +0,0 @@
-/**
- * Unit tests for applyExcelFilter. Every operator + edge case.
- */
-import { describe, expect, it } from 'vitest';
-import { applyExcelFilter } from './excel-filters';
-const make = (operator, value, valueTo) => ({
-    id: 'col',
-    operator,
-    value,
-    valueTo,
-});
-describe('applyExcelFilter - basic operators (smoke regression)', () => {
-    it('supports text operators (contains, startsWith, equals)', () => {
-        expect(applyExcelFilter('alphabet', make('contains', 'pha'))).toBe(true);
-        expect(applyExcelFilter('alphabet', make('startsWith', 'alp'))).toBe(true);
-        expect(applyExcelFilter('alphabet', make('equals', 'alphabet'))).toBe(true);
-    });
-    it('supports numeric operators (greaterThan, between)', () => {
-        expect(applyExcelFilter(15, make('greaterThan', 10))).toBe(true);
-        expect(applyExcelFilter(15, make('between', 10, 20))).toBe(true);
-    });
-    it('supports blank checks', () => {
-        expect(applyExcelFilter('', make('isBlank'))).toBe(true);
-        expect(applyExcelFilter('x', make('isBlank'))).toBe(false);
-    });
-});
-describe('applyExcelFilter - contains', () => {
-    it('matches case-insensitive substrings', () => {
-        expect(applyExcelFilter('Hello World', make('contains', 'world'))).toBe(true);
-        expect(applyExcelFilter('Hello World', make('contains', 'World'))).toBe(true);
-    });
-    it('returns false when substring absent', () => {
-        expect(applyExcelFilter('Hello', make('contains', 'xyz'))).toBe(false);
-    });
-    it('treats empty filter value as universal match', () => {
-        expect(applyExcelFilter('anything', make('contains', ''))).toBe(true);
-    });
-    it('coerces null cell to empty string', () => {
-        expect(applyExcelFilter(null, make('contains', 'x'))).toBe(false);
-        expect(applyExcelFilter(null, make('contains', ''))).toBe(true);
-    });
-});
-describe('applyExcelFilter - equals', () => {
-    it('matches case-insensitively', () => {
-        expect(applyExcelFilter('Boston', make('equals', 'boston'))).toBe(true);
-    });
-    it('rejects partial matches', () => {
-        expect(applyExcelFilter('Boston', make('equals', 'bost'))).toBe(false);
-    });
-    it('treats null as empty', () => {
-        expect(applyExcelFilter(null, make('equals', ''))).toBe(true);
-    });
-});
-describe('applyExcelFilter - startsWith', () => {
-    it('matches a prefix case-insensitively', () => {
-        expect(applyExcelFilter('Brooklyn', make('startsWith', 'brook'))).toBe(true);
-        expect(applyExcelFilter('Brooklyn', make('startsWith', 'lyn'))).toBe(false);
-    });
-});
-describe('applyExcelFilter - greaterThan', () => {
-    it('compares numerically when both sides parse as numbers', () => {
-        expect(applyExcelFilter(100, make('greaterThan', 99))).toBe(true);
-        expect(applyExcelFilter('100', make('greaterThan', 50))).toBe(true);
-        expect(applyExcelFilter(50, make('greaterThan', 50))).toBe(false);
-    });
-    it('falls back to string comparison when either side is non-numeric', () => {
-        expect(applyExcelFilter('banana', make('greaterThan', 'apple'))).toBe(true);
-        expect(applyExcelFilter('apple', make('greaterThan', 'banana'))).toBe(false);
-    });
-    it('treats null on either side as empty string in the fallback', () => {
-        expect(applyExcelFilter(null, make('greaterThan', 'a'))).toBe(false);
-        expect(applyExcelFilter('a', make('greaterThan', null))).toBe(true);
-    });
-});
-describe('applyExcelFilter - lessThan', () => {
-    it('compares numerically when both sides parse', () => {
-        expect(applyExcelFilter(10, make('lessThan', 20))).toBe(true);
-        expect(applyExcelFilter(20, make('lessThan', 10))).toBe(false);
-    });
-    it('falls back to string comparison', () => {
-        expect(applyExcelFilter('apple', make('lessThan', 'banana'))).toBe(true);
-    });
-    it('treats nulls as empty strings in fallback', () => {
-        expect(applyExcelFilter(null, make('lessThan', 'a'))).toBe(true);
-    });
-});
-describe('applyExcelFilter - between', () => {
-    it('includes both endpoints', () => {
-        expect(applyExcelFilter(5, make('between', 1, 10))).toBe(true);
-        expect(applyExcelFilter(1, make('between', 1, 10))).toBe(true);
-        expect(applyExcelFilter(10, make('between', 1, 10))).toBe(true);
-    });
-    it('excludes values outside the range', () => {
-        expect(applyExcelFilter(0, make('between', 1, 10))).toBe(false);
-        expect(applyExcelFilter(11, make('between', 1, 10))).toBe(false);
-    });
-    it('treats undefined endpoints as 0', () => {
-        expect(applyExcelFilter(0, make('between'))).toBe(true);
-        expect(applyExcelFilter(1, make('between'))).toBe(false);
-    });
-    it('treats null cell as 0', () => {
-        expect(applyExcelFilter(null, make('between', -1, 1))).toBe(true);
-    });
-});
-describe('applyExcelFilter - isBlank', () => {
-    it('matches null, undefined, and whitespace-only strings', () => {
-        expect(applyExcelFilter(null, make('isBlank'))).toBe(true);
-        expect(applyExcelFilter(undefined, make('isBlank'))).toBe(true);
-        expect(applyExcelFilter('', make('isBlank'))).toBe(true);
-        expect(applyExcelFilter('   ', make('isBlank'))).toBe(true);
-    });
-    it('rejects non-blank content', () => {
-        expect(applyExcelFilter('x', make('isBlank'))).toBe(false);
-        expect(applyExcelFilter(0, make('isBlank'))).toBe(false);
-    });
-});

package/dist/filtering/locale-filter.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Pure unit tests for the locale-aware text normalization + Excel
- * filter pipeline. No DOM, no mounted grid - just the two exported
- * helpers `normalizeForFilter` and `applyExcelFilter`.
- *
- * Covers:
- *   - Diacritic stripping (Café → cafe)
- *   - Composed / decomposed Unicode round-trip
- *   - Locale-specific lowercasing (Turkish dotted-I)
- *   - All Excel operators × locale option × accented inputs
- *   - Edge cases: empty strings, null/undefined, numeric mixed with text
- */
-export {};

package/dist/filtering/locale-filter.test.js

@@ -1,189 +0,0 @@
-/**
- * Pure unit tests for the locale-aware text normalization + Excel
- * filter pipeline. No DOM, no mounted grid - just the two exported
- * helpers `normalizeForFilter` and `applyExcelFilter`.
- *
- * Covers:
- *   - Diacritic stripping (Café → cafe)
- *   - Composed / decomposed Unicode round-trip
- *   - Locale-specific lowercasing (Turkish dotted-I)
- *   - All Excel operators × locale option × accented inputs
- *   - Edge cases: empty strings, null/undefined, numeric mixed with text
- */
-import { describe, expect, it } from 'vitest';
-import { applyExcelFilter, normalizeForFilter, } from './excel-filters';
-describe('normalizeForFilter - diacritic stripping', () => {
-    it('strips Latin accents (NFD path)', () => {
-        expect(normalizeForFilter('Café')).toBe('cafe');
-        expect(normalizeForFilter('CAFÉ')).toBe('cafe');
-        expect(normalizeForFilter('München')).toBe('munchen');
-        expect(normalizeForFilter('São Paulo')).toBe('sao paulo');
-        expect(normalizeForFilter('Tōkyō')).toBe('tokyo');
-        expect(normalizeForFilter('Genève')).toBe('geneve');
-        expect(normalizeForFilter('Québec')).toBe('quebec');
-        expect(normalizeForFilter('Málaga')).toBe('malaga');
-        expect(normalizeForFilter('Brasília')).toBe('brasilia');
-    });
-    it('handles already-decomposed input (NFD-stable)', () => {
-        // "Café" composed (4 code points) vs decomposed (5 code points).
-        const composed = 'Café'.normalize('NFC');
-        const decomposed = 'Café'.normalize('NFD');
-        expect(normalizeForFilter(composed)).toBe('cafe');
-        expect(normalizeForFilter(decomposed)).toBe('cafe');
-    });
-    it('preserves base ASCII unchanged', () => {
-        expect(normalizeForFilter('Hello World')).toBe('hello world');
-        expect(normalizeForFilter('ABC-123')).toBe('abc-123');
-        expect(normalizeForFilter('email@example.com')).toBe('email@example.com');
-    });
-    it('returns empty string for empty / falsy input', () => {
-        expect(normalizeForFilter('')).toBe('');
-    });
-    it('keeps non-Latin alphabets intact', () => {
-        // The diacritic strip only touches the Combining Diacritical Marks
-        // block (U+0300..U+036F). CJK / Cyrillic / Arabic stay as-is.
-        expect(normalizeForFilter('東京')).toBe('東京');
-        expect(normalizeForFilter('Москва')).toBe('москва');
-        expect(normalizeForFilter('القاهرة')).toBe('القاهرة');
-    });
-});
-describe('normalizeForFilter - locale-aware lowercase', () => {
-    it('default (no locale) makes English "istanbul" match dotted Turkish "İstanbul"', () => {
-        // No locale: NFD decomposes İ → I + combining dot above; the dot is
-        // stripped; remaining 'I' becomes 'i' under default lowercase.
-        expect(normalizeForFilter('İstanbul')).toBe('istanbul');
-        expect(normalizeForFilter('istanbul')).toBe('istanbul');
-    });
-    it('Turkish locale honors dotted-I / dotless-i asymmetry', () => {
-        // With "tr-TR" the bare 'I' (post-dot-strip) lowercases to dotless
-        // 'ı'. This is intentional Turkish behavior and is why we expose a
-        // locale prop: consumers who explicitly want Turkish casing get it.
-        // English-typed "istanbul" then no longer matches Turkish "İstanbul"
-        // - locale-pickers should make that trade-off knowingly.
-        expect(normalizeForFilter('İSTANBUL', 'tr-TR')).toBe('ıstanbul');
-        expect(normalizeForFilter('I', 'tr-TR')).toBe('ı');
-    });
-    it('default (no locale) behaves like toLowerCase()', () => {
-        expect(normalizeForFilter('HELLO')).toBe('hello');
-        expect(normalizeForFilter('CafÉ')).toBe('cafe'); // É
-    });
-    it('accepts an array of fallback locales', () => {
-        expect(normalizeForFilter('Café', ['fr-CA', 'en-US'])).toBe('cafe');
-    });
-    it('Greek / Cyrillic / German all fold cleanly', () => {
-        // Greek: stripped tones (oxia)
-        expect(normalizeForFilter('Αθήνα')).toBe('αθηνα');
-        // German: umlauts strip
-        expect(normalizeForFilter('Düsseldorf')).toBe('dusseldorf');
-        // Cyrillic: no diacritics, just locale-aware lowercase
-        expect(normalizeForFilter('Москва', 'ru-RU')).toBe('москва');
-    });
-});
-describe('applyExcelFilter - contains (locale-aware)', () => {
-    it('matches case + accent insensitively without a locale', () => {
-        const ok = applyExcelFilter('Café Genève', {
-            id: 'name', operator: 'contains', value: 'cafe geneve',
-        });
-        expect(ok).toBe(true);
-    });
-    it('matches with a German locale', () => {
-        const ok = applyExcelFilter('München', {
-            id: 'city', operator: 'contains', value: 'munch',
-        }, { locale: 'de-DE' });
-        expect(ok).toBe(true);
-    });
-    it('matches with a French locale', () => {
-        const ok = applyExcelFilter('Montréal', {
-            id: 'city', operator: 'contains', value: 'montreal',
-        }, { locale: 'fr-CA' });
-        expect(ok).toBe(true);
-    });
-    it('matches with a Portuguese locale', () => {
-        const ok = applyExcelFilter('São Paulo', {
-            id: 'city', operator: 'contains', value: 'sao paulo',
-        }, { locale: 'pt-BR' });
-        expect(ok).toBe(true);
-    });
-    it('rejects non-matching queries even with locale', () => {
-        const ok = applyExcelFilter('München', {
-            id: 'city', operator: 'contains', value: 'berlin',
-        }, { locale: 'de-DE' });
-        expect(ok).toBe(false);
-    });
-    it('empty needle matches every cell (includes "")', () => {
-        expect(applyExcelFilter('München', {
-            id: 'city', operator: 'contains', value: '',
-        })).toBe(true);
-    });
-});
-describe('applyExcelFilter - equals (locale-aware)', () => {
-    it('case + accent insensitive equals', () => {
-        expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'CAFE' })).toBe(true);
-        expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'cafe' })).toBe(true);
-        expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'Café' })).toBe(true);
-    });
-    it('rejects when normalized strings differ', () => {
-        expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'cafes' })).toBe(false);
-        expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'café!' })).toBe(false);
-    });
-});
-describe('applyExcelFilter - startsWith (locale-aware)', () => {
-    it('matches stripped prefix', () => {
-        expect(applyExcelFilter('München-Schwabing', {
-            id: 'x', operator: 'startsWith', value: 'munchen',
-        })).toBe(true);
-    });
-    it('rejects mid-string match', () => {
-        expect(applyExcelFilter('Großmünchen', {
-            id: 'x', operator: 'startsWith', value: 'munchen',
-        })).toBe(false);
-    });
-});
-describe('applyExcelFilter - numeric operators (locale-independent)', () => {
-    it('greaterThan / lessThan / between still work', () => {
-        expect(applyExcelFilter(150, { id: 'price', operator: 'greaterThan', value: 100 })).toBe(true);
-        expect(applyExcelFilter(150, { id: 'price', operator: 'lessThan', value: 200 })).toBe(true);
-        expect(applyExcelFilter(150, {
-            id: 'price', operator: 'between', value: 100, valueTo: 200,
-        })).toBe(true);
-    });
-    it('between rejects out-of-range', () => {
-        expect(applyExcelFilter(50, {
-            id: 'price', operator: 'between', value: 100, valueTo: 200,
-        })).toBe(false);
-    });
-});
-describe('applyExcelFilter - isBlank', () => {
-    it('treats empty / whitespace-only as blank', () => {
-        expect(applyExcelFilter('', { id: 'x', operator: 'isBlank' })).toBe(true);
-        expect(applyExcelFilter('   ', { id: 'x', operator: 'isBlank' })).toBe(true);
-        expect(applyExcelFilter(null, { id: 'x', operator: 'isBlank' })).toBe(true);
-        expect(applyExcelFilter(undefined, { id: 'x', operator: 'isBlank' })).toBe(true);
-    });
-    it('rejects non-blank cells', () => {
-        expect(applyExcelFilter('Café', { id: 'x', operator: 'isBlank' })).toBe(false);
-        expect(applyExcelFilter(' x ', { id: 'x', operator: 'isBlank' })).toBe(false);
-    });
-});
-describe('applyExcelFilter - regression: pre-locale behavior preserved', () => {
-    // Before locale support, ASCII case-insensitive matching was the rule.
-    // Verify nothing regressed for the common path.
-    it('plain ASCII contains', () => {
-        expect(applyExcelFilter('Ada Lovelace', {
-            id: 'name', operator: 'contains', value: 'lovelace',
-        })).toBe(true);
-        expect(applyExcelFilter('Ada Lovelace', {
-            id: 'name', operator: 'contains', value: 'LOVELACE',
-        })).toBe(true);
-    });
-    it('plain ASCII equals', () => {
-        expect(applyExcelFilter('active', {
-            id: 'status', operator: 'equals', value: 'ACTIVE',
-        })).toBe(true);
-    });
-    it('plain ASCII startsWith', () => {
-        expect(applyExcelFilter('Linus Torvalds', {
-            id: 'name', operator: 'startsWith', value: 'linus',
-        })).toBe(true);
-    });
-});

package/dist/flex-render.test.d.ts

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

package/dist/flex-render.test.js

@@ -1,142 +0,0 @@
-/**
- * FlexRender tests. The component routes one of {content+context, cell,
- * header, footer} into the right render path: string, RenderComponentConfig,
- * RenderSnippetConfig, or raw value.
- */
-import { describe, expect, it } from 'vitest';
-import { mount, unmount } from 'svelte';
-import FlexRender from './FlexRender.svelte';
-import { RenderComponentConfig, RenderSnippetConfig } from './render-component';
-function mountFlex(props) {
-    const target = document.createElement('div');
-    document.body.appendChild(target);
-    const app = mount(FlexRender, { target, props });
-    return {
-        target,
-        destroy: () => {
-            unmount(app);
-            target.remove();
-        },
-    };
-}
-describe('FlexRender', () => {
-    it('renders a plain string content directly', () => {
-        const { target, destroy } = mountFlex({
-            content: 'Hello header',
-            context: { column: {}, table: {} },
-        });
-        try {
-            expect(target.textContent).toContain('Hello header');
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('calls a function content with the context and renders the result', () => {
-        const fn = (ctx) => `value=${ctx.value}`;
-        const { target, destroy } = mountFlex({
-            content: fn,
-            context: { value: 42 },
-        });
-        try {
-            expect(target.textContent).toContain('value=42');
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('renders nothing when content is undefined', () => {
-        const { target, destroy } = mountFlex({
-            content: undefined,
-            context: {},
-        });
-        try {
-            expect(target.textContent?.trim()).toBe('');
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('pulls content + context from `cell` when provided', () => {
-        const cell = {
-            column: { columnDef: { cell: (ctx) => `row=${ctx.row.id}` } },
-            getContext: () => ({ row: { id: 7 } }),
-        };
-        const { target, destroy } = mountFlex({ cell });
-        try {
-            expect(target.textContent).toContain('row=7');
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('pulls content + context from `header` when provided', () => {
-        const header = {
-            column: { columnDef: { header: 'Total' } },
-            getContext: () => ({}),
-        };
-        const { target, destroy } = mountFlex({ header });
-        try {
-            expect(target.textContent).toContain('Total');
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('pulls content + context from `footer` when provided', () => {
-        const footer = {
-            column: { columnDef: { footer: 'Sum' } },
-            getContext: () => ({}),
-        };
-        const { target, destroy } = mountFlex({ footer });
-        try {
-            expect(target.textContent).toContain('Sum');
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('renders a RenderComponentConfig result (smoke)', () => {
-        // Anonymous Svelte-like component would require compilation; we just
-        // exercise the constructor path so the discriminator branch executes.
-        const fn = () => new RenderComponentConfig(null, {});
-        const { destroy } = mountFlex({
-            content: fn,
-            context: {},
-        });
-        try {
-            // No throw means the discriminator was hit.
-            expect(true).toBe(true);
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('renders a RenderSnippetConfig result (smoke)', () => {
-        const fakeSnippet = (() => null);
-        const fn = () => new RenderSnippetConfig(fakeSnippet, undefined);
-        const { destroy } = mountFlex({
-            content: fn,
-            context: {},
-        });
-        try {
-            expect(true).toBe(true);
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('renders a raw scalar value when the function returns one', () => {
-        const fn = () => 99;
-        const { target, destroy } = mountFlex({
-            content: fn,
-            context: {},
-        });
-        try {
-            expect(target.textContent).toContain('99');
-        }
-        finally {
-            destroy();
-        }
-    });
-});

package/dist/group-aggregate.test.d.ts

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

package/dist/group-aggregate.test.js

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { applyGroupAggregate } from './core';
-// Minimal Row stubs - applyGroupAggregate only touches getCellValueByColumnId
-// and original.
-function rows(values) {
-    return values.map((v) => ({
-        original: { v, cat: 'x' },
-        getCellValueByColumnId: (id) => (id === 'v' ? v : 'x'),
-    }));
-}
-describe('applyGroupAggregate', () => {
-    const r = rows([10, 20, 30]);
-    it('sum / avg / min / max', () => {
-        expect(applyGroupAggregate('sum', 'v', r)).toBe(60);
-        expect(applyGroupAggregate('avg', 'v', r)).toBe(20);
-        expect(applyGroupAggregate('min', 'v', r)).toBe(10);
-        expect(applyGroupAggregate('max', 'v', r)).toBe(30);
-    });
-    it('count / countDistinct / first / extent', () => {
-        expect(applyGroupAggregate('count', 'v', r)).toBe(3);
-        expect(applyGroupAggregate('countDistinct', 'cat', r)).toBe(1);
-        expect(applyGroupAggregate('first', 'v', r)).toBe(10);
-        expect(applyGroupAggregate('extent', 'v', r)).toBe('10 – 30');
-    });
-    it('custom function receives numeric values + rows', () => {
-        const median = applyGroupAggregate((vals) => vals.sort((a, b) => a - b)[Math.floor(vals.length / 2)], 'v', r);
-        expect(median).toBe(20);
-    });
-    it('numeric reducers ignore non-numeric and empty groups', () => {
-        expect(applyGroupAggregate('sum', 'v', rows([]))).toBeUndefined();
-    });
-});

package/dist/hyperformula-adapter.test.d.ts

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