@svgrid/grid 1.1.2 → 1.2.1

package/dist/svgrid.set-filter.test.js

@@ -1,268 +0,0 @@
-/**
- * Component tests for `api.setFacetFilter()` - the imperative entry
- * point that powers the three set-filter UX patterns (Excel-style
- * column-menu, async value loaders, and tree-list cascades). The grid
- * is filter-source-agnostic; this test exercises the API directly so
- * coverage is independent of any specific UI implementation.
- *
- * Covers:
- *   - Single column facet filter narrows the displayed rows
- *   - Multi-value filter (OR within column) accepts every listed value
- *   - Passing null / empty clears the filter
- *   - Two columns AND across (different columns)
- *   - Combines with operator filter from setFilter()
- *   - Survives unknown values (no crash, just no matches)
- *   - Unicode / non-ASCII values match exactly (no normalization)
- */
-import { describe, expect, it } from 'vitest';
-import { mount, unmount } from 'svelte';
-import SvGrid from './SvGrid.svelte';
-import { columnFilteringFeature, createCoreRowModel, createFilteredRowModel, createSortedRowModel, rowSortingFeature, sortFns, tableFeatures, } from './index';
-const features = tableFeatures({ columnFilteringFeature, rowSortingFeature });
-const rows = [
-    { id: 'O-1', region: 'Americas', country: 'United States', status: 'open', amount: 120 },
-    { id: 'O-2', region: 'Americas', country: 'United States', status: 'paid', amount: 240 },
-    { id: 'O-3', region: 'Americas', country: 'Canada', status: 'delivered', amount: 410 },
-    { id: 'O-4', region: 'Americas', country: 'Brazil', status: 'shipped', amount: 180 },
-    { id: 'O-5', region: 'EMEA', country: 'Germany', status: 'paid', amount: 330 },
-    { id: 'O-6', region: 'EMEA', country: 'Germany', status: 'returned', amount: 205 },
-    { id: 'O-7', region: 'EMEA', country: 'France', status: 'open', amount: 155 },
-    { id: 'O-8', region: 'EMEA', country: 'France', status: 'shipped', amount: 420 },
-    { id: 'O-9', region: 'APAC', country: 'Japan', status: 'paid', amount: 890 },
-    { id: 'O-10', region: 'APAC', country: 'Japan', status: 'returned', amount: 240 },
-    { id: 'O-11', region: 'APAC', country: 'Australia', status: 'open', amount: 175 },
-    { id: 'O-12', region: 'APAC', country: 'Singapore', status: 'delivered', amount: 1200 },
-];
-const cols = [
-    { field: 'id', header: 'ID', width: 90 },
-    { field: 'region', header: 'Region', width: 110 },
-    { field: 'country', header: 'Country', width: 160 },
-    { field: 'status', header: 'Status', width: 110 },
-    { field: 'amount', header: 'Amount', width: 100, align: 'right' },
-];
-function mountGrid() {
-    return new Promise((res, rej) => {
-        const target = document.createElement('div');
-        document.body.appendChild(target);
-        let api = null;
-        const app = mount(SvGrid, {
-            target,
-            props: {
-                data: rows,
-                columns: cols,
-                features,
-                _rowModels: {
-                    coreRowModel: createCoreRowModel(),
-                    filteredRowModel: createFilteredRowModel(),
-                    sortedRowModel: createSortedRowModel(sortFns),
-                },
-                containerHeight: 360,
-                virtualization: false,
-                columnVirtualization: false,
-                showPagination: false,
-                showColumnFilters: false,
-                showGlobalFilter: false,
-                showRowSelection: false,
-                onApiReady(received) {
-                    api = received;
-                    res({ api, destroy: () => { unmount(app); target.remove(); } });
-                },
-            },
-        });
-        queueMicrotask(() => { if (!api)
-            rej(new Error('onApiReady never fired')); });
-    });
-}
-const tick = () => new Promise((r) => queueMicrotask(r));
-describe('SvGridApi.setFacetFilter - single column', () => {
-    it('narrows to one allowed value', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('region', ['EMEA']);
-            await tick();
-            const ids = api.getDisplayedRows().map((r) => r.id);
-            expect(ids).toEqual(['O-5', 'O-6', 'O-7', 'O-8']);
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('accepts multiple values (OR within column)', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('region', ['EMEA', 'APAC']);
-            await tick();
-            const regions = new Set(api.getDisplayedRows().map((r) => r.region));
-            expect(regions).toEqual(new Set(['EMEA', 'APAC']));
-            expect(api.getDisplayedRows().length).toBe(8);
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('empty allowed array filters everything out', async () => {
-        // An empty SET is treated as a clear (matches the implementation -
-        // see `setFacetFilter`'s null branch). Verify the documented
-        // behavior: empty array clears.
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('region', []);
-            await tick();
-            expect(api.getDisplayedRows().length).toBe(rows.length);
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('null clears the filter', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('region', ['EMEA']);
-            await tick();
-            expect(api.getDisplayedRows().length).toBe(4);
-            api.setFacetFilter('region', null);
-            await tick();
-            expect(api.getDisplayedRows().length).toBe(rows.length);
-        }
-        finally {
-            destroy();
-        }
-    });
-});
-describe('SvGridApi.setFacetFilter - multi-column AND', () => {
-    it('region + status both narrow', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('region', ['EMEA']);
-            api.setFacetFilter('status', ['paid', 'returned']);
-            await tick();
-            const ids = api.getDisplayedRows().map((r) => r.id);
-            expect(ids).toEqual(['O-5', 'O-6']); // EMEA rows whose status is paid or returned
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('region + country + status all compose', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('region', ['APAC']);
-            api.setFacetFilter('country', ['Japan', 'Singapore']);
-            api.setFacetFilter('status', ['delivered']);
-            await tick();
-            const ids = api.getDisplayedRows().map((r) => r.id);
-            expect(ids).toEqual(['O-12']); // APAC + Singapore + delivered
-        }
-        finally {
-            destroy();
-        }
-    });
-});
-describe('SvGridApi.setFacetFilter - composition with operator filters', () => {
-    it('facet narrows; setFilter further narrows on the same column id', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('region', ['Americas', 'EMEA']);
-            api.setFilter('country', { operator: 'startsWith', value: 'g' }); // → Germany
-            await tick();
-            const ids = api.getDisplayedRows().map((r) => r.id);
-            expect(ids).toEqual(['O-5', 'O-6']);
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('clearing the facet but keeping setFilter only honors setFilter', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('region', ['EMEA']);
-            api.setFilter('country', { operator: 'contains', value: 'fran' });
-            await tick();
-            expect(api.getDisplayedRows().map((r) => r.id)).toEqual(['O-7', 'O-8']);
-            api.setFacetFilter('region', null);
-            await tick();
-            expect(api.getDisplayedRows().map((r) => r.id)).toEqual(['O-7', 'O-8']);
-        }
-        finally {
-            destroy();
-        }
-    });
-});
-describe('SvGridApi.setFacetFilter - edge cases', () => {
-    it('unknown allowed values silently match nothing', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('status', ['SHIPPED_IN_TRANSIT', 'PENDING_REVIEW']);
-            await tick();
-            expect(api.getDisplayedRows().length).toBe(0);
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('mixed known + unknown values: known values still match', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('status', ['shipped', 'UNKNOWN_VALUE']);
-            await tick();
-            const ids = api.getDisplayedRows().map((r) => r.id);
-            expect(ids).toEqual(['O-4', 'O-8']);
-        }
-        finally {
-            destroy();
-        }
-    });
-});
-describe('SvGridApi.setFacetFilter - simulates the tree-list pattern', () => {
-    // Demo 111's tree picker resolves a hierarchical selection to a flat
-    // list of leaf values, then calls setFacetFilter. These tests
-    // exercise that contract.
-    it('simulates a tree drop: select Americas → all American countries', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            // Leaf descendants of the "Americas" tree node:
-            const americansCountries = ['United States', 'Canada', 'Brazil'];
-            api.setFacetFilter('country', americansCountries);
-            await tick();
-            const regions = new Set(api.getDisplayedRows().map((r) => r.region));
-            expect(regions).toEqual(new Set(['Americas']));
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('simulates a partial-tree selection: only Japan + Singapore', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            api.setFacetFilter('country', ['Japan', 'Singapore']);
-            await tick();
-            const ids = api.getDisplayedRows().map((r) => r.id);
-            expect(ids).toEqual(['O-9', 'O-10', 'O-12']);
-        }
-        finally {
-            destroy();
-        }
-    });
-});
-describe('SvGridApi.setFacetFilter - simulates the async loader pattern', () => {
-    // Demo 111's async card emulates a server returning the distinct
-    // emails. The grid is told the final selection via setFacetFilter -
-    // there's no special "loading" code path inside the grid, the
-    // consumer's UI handles that. Verify the contract works regardless of
-    // whether the values were enumerated client-side or server-side.
-    it('async-loaded values: select user-resolved subset', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            // Pretend the user clicked these from a server-loaded value list.
-            const userSelected = ['Germany', 'France'];
-            api.setFacetFilter('country', userSelected);
-            await tick();
-            const regions = new Set(api.getDisplayedRows().map((r) => r.region));
-            expect(regions).toEqual(new Set(['EMEA']));
-            expect(api.getDisplayedRows().length).toBe(4);
-        }
-        finally {
-            destroy();
-        }
-    });
-});

package/dist/svgrid.wrapper.test.d.ts

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

package/dist/svgrid.wrapper.test.js

@@ -1,59 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import SvGrid from './SvGrid.svelte';
-describe('SvGrid wrapper', () => {
-    it('exports a production wrapper component', () => {
-        expect(SvGrid).toBeDefined();
-    });
-    it('contains full-wrapper controls and aria-activedescendant wiring', () => {
-        // The wrapper spans SvGrid.svelte plus its extracted sibling modules
-        // (types + pure helpers); read them together so these "contains X"
-        // assertions hold wherever the code physically lives.
-        const source = [
-            './SvGrid.svelte',
-            './SvGrid.controller.svelte.ts',
-            './GridMenus.svelte',
-            './GridFooter.svelte',
-            './SvGrid.types.ts',
-            './SvGrid.helpers.ts',
-            './filter-operators.ts',
-            './facet-buckets.ts',
-            './cell-values.ts',
-            './clipboard.ts',
-            './build-api.ts',
-            './columns.ts',
-            './selection.ts',
-            './editing.ts',
-            './cell-render.ts',
-            './menus.ts',
-            './summaries.ts',
-            './keyboard-handlers.ts',
-            './scroll-sync.ts',
-            './features.ts',
-        ]
-            .map((p) => readFileSync(resolve(__dirname, p), 'utf-8'))
-            .join('\n');
-        expect(source).toContain('Filter all rows');
-        expect(source).toContain('Previous');
-        expect(source).toContain('role="status"');
-        expect(source).toContain('role="alert"');
-        expect(source).toContain('activeDescendantId');
-        expect(source).toContain('getGridRootA11yProps');
-        expect(source).toContain('data-svgrid-header-col');
-        expect(source).toContain('data-svgrid-row');
-        expect(source).toContain('createSvelteVirtualizer');
-        expect(source).toContain('props.virtualization ?? true');
-        expect(source).toContain('virtualizer.getVirtualItems()');
-        expect(source).toContain('createColumnVirtualizer');
-        expect(source).toContain('data-selected-range');
-        expect(source).toContain('enableInlineEditing');
-        expect(source).toContain('showFilterMenu');
-        expect(source).toContain('<tfoot');
-        expect(source).toContain('editorType === "number"');
-        expect(source).toContain('editorType === "date"');
-        expect(source).toContain('editorType === "checkbox"');
-        expect(source).toContain('applyExcelFilter');
-        expect(source).toContain('showFilterRow');
-    });
-});

package/dist/test-setup.d.ts

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

package/dist/test-setup.js

@@ -1,35 +0,0 @@
-// Vitest setup. jsdom doesn't ship ResizeObserver, IntersectionObserver,
-// or the layout APIs SvGrid touches inside its mount effects. Provide
-// minimal no-op stubs so component mounting completes without crashing.
-//
-// These assign to globals/prototypes the jsdom env doesn't fully type, so
-// the targets are cast to `any`. We deliberately avoid expect-error
-// suppression directives: when a stub happens to line up with the lib types,
-// such a directive becomes "unused" and svelte-check fails the build (an
-// unused expect-error directive is itself an error).
-if (typeof globalThis.ResizeObserver === 'undefined') {
-    ;
-    globalThis.ResizeObserver = class {
-        observe() { }
-        unobserve() { }
-        disconnect() { }
-    };
-}
-if (typeof globalThis.IntersectionObserver === 'undefined') {
-    ;
-    globalThis.IntersectionObserver = class {
-        observe() { }
-        unobserve() { }
-        disconnect() { }
-        takeRecords() {
-            return [];
-        }
-    };
-}
-// jsdom's HTMLElement.scrollIntoView is a no-op; some grid code calls it
-// during the first effect. Make sure the method exists on every element.
-if (typeof Element !== 'undefined' && !Element.prototype.scrollIntoView) {
-    ;
-    Element.prototype.scrollIntoView = function () { };
-}
-export {};

package/dist/transaction.test.d.ts

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

package/dist/transaction.test.js

@@ -1,89 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { mount, unmount } from 'svelte';
-import SvGrid from './SvGrid.svelte';
-import { createCoreRowModel, createFilteredRowModel, createSortedRowModel, sortFns, tableFeatures, } from './index';
-const features = tableFeatures({});
-const seed = [
-    { id: 'a', symbol: 'AAPL', price: 100 },
-    { id: 'b', symbol: 'MSFT', price: 200 },
-    { id: 'c', symbol: 'NVDA', price: 300 },
-];
-const columns = [
-    { field: 'symbol', header: 'Symbol' },
-    { field: 'price', header: 'Price' },
-];
-function mountGrid() {
-    return new Promise((resolve, reject) => {
-        const target = document.createElement('div');
-        document.body.appendChild(target);
-        let captured = null;
-        const app = mount(SvGrid, {
-            target,
-            props: {
-                data: seed,
-                columns,
-                features,
-                getRowId: (o) => o.id,
-                _rowModels: {
-                    coreRowModel: createCoreRowModel(),
-                    filteredRowModel: createFilteredRowModel(),
-                    sortedRowModel: createSortedRowModel(sortFns),
-                },
-                containerHeight: 400,
-                virtualization: false,
-                onApiReady(api) {
-                    captured = api;
-                    resolve({ api, destroy: () => { unmount(app); target.remove(); } });
-                },
-            },
-        });
-        queueMicrotask(() => { if (!captured)
-            reject(new Error('onApiReady never fired')); });
-    });
-}
-const tick = () => Promise.resolve();
-describe('api.applyTransaction', () => {
-    it('adds, updates (by id), and removes (by id) in one batch', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            const result = api.applyTransaction({
-                add: [{ id: 'd', symbol: 'AMZN', price: 400 }],
-                update: [{ id: 'b', symbol: 'MSFT', price: 222 }],
-                remove: ['a'],
-            });
-            await tick();
-            expect(result).toEqual({ added: 1, updated: 1, removed: 1 });
-            const data = api.getData();
-            expect(data.map((o) => o.id)).toEqual(['b', 'c', 'd']);
-            expect(data.find((o) => o.id === 'b')?.price).toBe(222);
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('removes by row reference too', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            const ref = api.getData()[2]; // 'c'
-            const result = api.applyTransaction({ remove: [ref] });
-            await tick();
-            expect(result.removed).toBe(1);
-            expect(api.getData().map((o) => o.id)).toEqual(['a', 'b']);
-        }
-        finally {
-            destroy();
-        }
-    });
-    it('ignores unknown ids without throwing', async () => {
-        const { api, destroy } = await mountGrid();
-        try {
-            const result = api.applyTransaction({ update: [{ id: 'zzz', symbol: 'X', price: 1 }], remove: ['nope'] });
-            await tick();
-            expect(result).toEqual({ added: 0, updated: 0, removed: 0 });
-            expect(api.getData()).toHaveLength(3);
-        }
-        finally {
-            destroy();
-        }
-    });
-});

package/dist/virtualization/column-virtualizer.test.d.ts

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

package/dist/virtualization/column-virtualizer.test.js

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createColumnVirtualizer } from './column-virtualizer';
-describe('column virtualizer', () => {
-    it('computes horizontal window', () => {
-        const v = createColumnVirtualizer({
-            count: 1000,
-            viewportWidth: 700,
-            overscan: 3,
-            estimateSize: () => 140,
-        });
-        const items = v.getVirtualItems();
-        expect(items[0]?.index).toBe(0);
-        expect(items.length).toBeGreaterThan(0);
-    });
-    it('updates indices on horizontal scroll', () => {
-        const v = createColumnVirtualizer({
-            count: 1000,
-            viewportWidth: 700,
-            estimateSize: () => 140,
-        });
-        v.setHorizontalOffset(2800);
-        const state = v.getState();
-        expect(state.startIndex).toBeGreaterThan(0);
-    });
-});

package/dist/virtualization/scroll-scaling.test.d.ts

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

package/dist/virtualization/scroll-scaling.test.js

@@ -1,127 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createRowScrollScaling, resolveMaxDomHeight } from './scroll-scaling';
-const VIEWPORT = 600;
-const FALLBACK = 8000000;
-describe('createRowScrollScaling - inert (content fits under the cap)', () => {
-    // 1M rows * 18px = 18M, under a 33.5M (Chrome) cap -> no scaling.
-    const s = createRowScrollScaling(18000000, 33554400, VIEWPORT);
-    it('is inactive and exposes the true height as the DOM height', () => {
-        expect(s.active).toBe(false);
-        expect(s.domTotal).toBe(18000000);
-    });
-    it('both maps are the identity', () => {
-        for (const v of [0, 1, 1234, 9000000, 17999400]) {
-            expect(s.domToLogical(v)).toBe(v);
-            expect(s.logicalToDom(v)).toBe(v);
-        }
-    });
-});
-describe('createRowScrollScaling - active (content exceeds the cap)', () => {
-    // 1M rows * 32px = 32M, over Firefox's ~17.9M cap -> scaling engages.
-    const trueTotal = 32000000;
-    const maxDom = 17895697;
-    const s = createRowScrollScaling(trueTotal, maxDom, VIEWPORT);
-    const domMax = s.domTotal - VIEWPORT;
-    const logicalMax = trueTotal - VIEWPORT;
-    it('caps the DOM height at the browser limit', () => {
-        expect(s.active).toBe(true);
-        expect(s.domTotal).toBe(maxDom);
-        expect(s.domTotal).toBeLessThanOrEqual(maxDom);
-    });
-    it('maps the endpoints exactly so the first and last rows are reachable', () => {
-        expect(s.domToLogical(0)).toBe(0);
-        // The bottom of the DOM scroll range reaches the bottom of the logical range.
-        expect(s.domToLogical(domMax)).toBeCloseTo(logicalMax, 3);
-        expect(s.logicalToDom(0)).toBe(0);
-        expect(s.logicalToDom(logicalMax)).toBeCloseTo(domMax, 3);
-    });
-    it('clamps out-of-range inputs instead of overshooting', () => {
-        expect(s.domToLogical(-100)).toBe(0);
-        expect(s.domToLogical(domMax + 10000)).toBeCloseTo(logicalMax, 3);
-        expect(s.logicalToDom(-100)).toBe(0);
-        expect(s.logicalToDom(logicalMax + 10000)).toBeCloseTo(domMax, 3);
-    });
-    it('logicalToDom is the inverse of domToLogical across the range', () => {
-        for (let i = 0; i <= 10; i += 1) {
-            const domTop = (domMax * i) / 10;
-            const roundTrip = s.logicalToDom(s.domToLogical(domTop));
-            expect(roundTrip).toBeCloseTo(domTop, 2);
-        }
-    });
-    it('both maps are monotonic non-decreasing', () => {
-        let prevL = -1;
-        let prevD = -1;
-        for (let i = 0; i <= 20; i += 1) {
-            const domTop = (domMax * i) / 20;
-            const logical = s.domToLogical(domTop);
-            expect(logical).toBeGreaterThanOrEqual(prevL);
-            prevL = logical;
-            const logIn = (logicalMax * i) / 20;
-            const dom = s.logicalToDom(logIn);
-            expect(dom).toBeGreaterThanOrEqual(prevD);
-            prevD = dom;
-        }
-    });
-});
-describe('resolveMaxDomHeight - picks the smaller, real scrollable cap', () => {
-    it('keeps the desktop cap when both signals agree', () => {
-        // Chrome ~33.5M; offsetHeight and scrollHeight match. 0.5% safety shave.
-        const cap = resolveMaxDomHeight(33554400, 33554400, FALLBACK);
-        expect(cap).toBeLessThan(33554400);
-        expect(cap).toBeGreaterThan(33000000);
-    });
-    it('uses the SCROLL cap when a phone over-reports offsetHeight', () => {
-        // High-DPR mobile: layout says 24M, but the container only scrolls ~6M.
-        // Trusting offsetHeight is exactly what stranded the last rows.
-        const cap = resolveMaxDomHeight(24000000, 6000000, FALLBACK);
-        expect(cap).toBeLessThanOrEqual(6000000);
-        expect(cap).toBeGreaterThan(5900000);
-    });
-    it('shaves a safety margin so the spacer never sits at the exact edge', () => {
-        const cap = resolveMaxDomHeight(10000000, 10000000, FALLBACK);
-        expect(cap).toBeLessThan(10000000);
-    });
-    it('falls back when both readings are junk (jsdom returns 0)', () => {
-        expect(resolveMaxDomHeight(0, 0, FALLBACK)).toBe(FALLBACK);
-    });
-    it('falls back when the browser did not clamp (returned ~1e9)', () => {
-        expect(resolveMaxDomHeight(1000000000, 1000000000, FALLBACK)).toBe(FALLBACK);
-    });
-    it('ignores a junk signal but trusts the valid one', () => {
-        // offsetHeight unclamped/garbage, scrollHeight is the real cap.
-        const cap = resolveMaxDomHeight(1000000000, 5000000, FALLBACK);
-        expect(cap).toBeLessThanOrEqual(5000000);
-        expect(cap).toBeGreaterThan(4900000);
-    });
-    it('feeds straight into the scaler so the last row stays reachable', () => {
-        const maxDom = resolveMaxDomHeight(24000000, 6000000, FALLBACK);
-        const trueTotal = 500000 * 32; // 16M px of rows, over the phone cap
-        const s = createRowScrollScaling(trueTotal, maxDom, VIEWPORT);
-        expect(s.active).toBe(true);
-        expect(s.domTotal).toBeLessThanOrEqual(maxDom);
-        const domMax = s.domTotal - VIEWPORT;
-        expect(s.domToLogical(domMax)).toBeCloseTo(trueTotal - VIEWPORT, 0);
-    });
-});
-describe('createRowScrollScaling - edge cases', () => {
-    it('handles an empty grid without dividing by zero', () => {
-        const s = createRowScrollScaling(0, 17895697, VIEWPORT);
-        expect(s.active).toBe(false);
-        expect(s.domTotal).toBe(0);
-        expect(s.domToLogical(0)).toBe(0);
-        expect(s.logicalToDom(0)).toBe(0);
-    });
-    it('handles content shorter than the viewport', () => {
-        const s = createRowScrollScaling(200, 17895697, VIEWPORT);
-        expect(s.active).toBe(false);
-        expect(s.domToLogical(0)).toBe(0);
-    });
-    it('extreme scale (100M rows) keeps the last row reachable', () => {
-        const trueTotal = 100000000 * 32; // 3.2 billion px
-        const s = createRowScrollScaling(trueTotal, 33554400, VIEWPORT);
-        expect(s.active).toBe(true);
-        expect(s.domTotal).toBe(33554400);
-        const domMax = s.domTotal - VIEWPORT;
-        expect(s.domToLogical(domMax)).toBeCloseTo(trueTotal - VIEWPORT, 0);
-    });
-});

package/dist/virtualization/virtualizer.test.d.ts

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

package/dist/virtualization/virtualizer.test.js

@@ -1,41 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createVirtualizer } from './virtualizer';
-describe('virtualizer', () => {
-    it('computes bounded virtual range with overscan', () => {
-        const v = createVirtualizer({
-            count: 100000,
-            estimateSize: 36,
-            overscan: 8,
-            viewportHeight: 360,
-            scrollOffset: 0,
-        });
-        const items = v.getVirtualItems();
-        expect(items.length).toBeGreaterThan(0);
-        expect(items[0]?.index).toBe(0);
-        expect(items[items.length - 1]?.index).toBe(18);
-    });
-    it('updates range when scroll offset changes', () => {
-        const v = createVirtualizer({
-            count: 100000,
-            estimateSize: 40,
-            overscan: 5,
-            viewportHeight: 400,
-            scrollOffset: 0,
-        });
-        v.setScrollOffset(4000);
-        const state = v.getState();
-        expect(state.startIndex).toBeLessThanOrEqual(100);
-        expect(state.endIndex).toBeGreaterThanOrEqual(110);
-    });
-    it('scrollToIndex clamps target offset', () => {
-        const v = createVirtualizer({
-            count: 100,
-            estimateSize: 30,
-            overscan: 2,
-            viewportHeight: 300,
-            scrollOffset: 0,
-        });
-        v.scrollToIndex(9999);
-        expect(v.getState().scrollOffset).toBe(2700);
-    });
-});