@svgrid/grid 1.1.1 → 1.2.1

package/dist/server-data-source.coverage.test.js

@@ -1,154 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createServerDataSource } from './server-data-source';
-const flush = () => new Promise((r) => setTimeout(r, 0));
-describe('createServerDataSource - request params', () => {
-    it('passes startRow/endRow/page/sort/filter through to getRows', async () => {
-        const getRows = vi.fn(async (_req) => ({ rows: [], rowCount: 0 }));
-        const ctl = createServerDataSource({ getRows }, { pageSize: 20, onChange: () => { } });
-        ctl.setFilter({ global: 'abc', columns: { name: { operator: 'eq', value: 'x' } } });
-        await flush();
-        const req = getRows.mock.calls.at(-1)[0];
-        expect(req).toMatchObject({
-            startRow: 0,
-            endRow: 20,
-            pageIndex: 0,
-            pageSize: 20,
-            filterModel: { global: 'abc', columns: { name: { operator: 'eq', value: 'x' } } },
-        });
-    });
-    it('setFilter resets to page 0', async () => {
-        const getRows = vi.fn(async () => ({ rows: [], rowCount: 100 }));
-        const ctl = createServerDataSource({ getRows }, { pageSize: 10, onChange: () => { } });
-        ctl.setPage(3);
-        await flush();
-        ctl.setFilter({ global: 'q' });
-        await flush();
-        expect(ctl.getState().pageIndex).toBe(0);
-        const req = getRows.mock.calls.at(-1)[0];
-        expect(req.startRow).toBe(0);
-    });
-    it('uses the default page size of 50 when unspecified', () => {
-        const ctl = createServerDataSource({ getRows: async () => ({ rows: [], rowCount: 0 }) }, { onChange: () => { } });
-        expect(ctl.getState().pageSize).toBe(50);
-    });
-});
-describe('createServerDataSource - setPage edge cases', () => {
-    it('clamps a negative page index to 0', async () => {
-        const getRows = vi.fn(async () => ({ rows: [], rowCount: 0 }));
-        const ctl = createServerDataSource({ getRows }, { pageSize: 10, onChange: () => { } });
-        ctl.setPage(5);
-        await flush();
-        getRows.mockClear();
-        ctl.setPage(-3);
-        await flush();
-        expect(ctl.getState().pageIndex).toBe(0);
-        expect(getRows).toHaveBeenCalledTimes(1);
-    });
-    it('does nothing when the page index is unchanged', async () => {
-        const getRows = vi.fn(async () => ({ rows: [], rowCount: 0 }));
-        const ctl = createServerDataSource({ getRows }, { pageSize: 10, onChange: () => { } });
-        await flush();
-        getRows.mockClear();
-        ctl.setPage(0); // already on page 0
-        await flush();
-        expect(getRows).not.toHaveBeenCalled();
-    });
-});
-describe('createServerDataSource - setPageSize', () => {
-    it('clamps page size to a minimum of 1, resets page, and re-fetches', async () => {
-        const getRows = vi.fn(async () => ({ rows: [], rowCount: 0 }));
-        const ctl = createServerDataSource({ getRows }, { pageSize: 10, onChange: () => { } });
-        ctl.setPage(2);
-        await flush();
-        getRows.mockClear();
-        ctl.setPageSize(0);
-        await flush();
-        expect(ctl.getState().pageSize).toBe(1);
-        expect(ctl.getState().pageIndex).toBe(0);
-        expect(getRows).toHaveBeenCalledTimes(1);
-    });
-    it('recomputes pageCount from total and page size', async () => {
-        const getRows = vi.fn(async () => ({ rows: [], rowCount: 95 }));
-        const ctl = createServerDataSource({ getRows }, { pageSize: 10, onChange: () => { } });
-        ctl.refresh();
-        await flush();
-        expect(ctl.getState().pageCount).toBe(10); // ceil(95/10)
-        ctl.setPageSize(20);
-        await flush();
-        expect(ctl.getState().pageCount).toBe(5); // ceil(95/20)
-    });
-});
-describe('createServerDataSource - error handling', () => {
-    it('captures a rejection into state.error and clears rows', async () => {
-        const boom = new Error('network down');
-        const ctl = createServerDataSource({ getRows: async () => { throw boom; } }, { pageSize: 10, onChange: () => { } });
-        ctl.refresh();
-        await flush();
-        const s = ctl.getState();
-        expect(s.error).toBe(boom);
-        expect(s.rows).toEqual([]);
-        expect(s.loading).toBe(false);
-    });
-    it('clears a prior error on the next successful fetch', async () => {
-        let fail = true;
-        const ctl = createServerDataSource({
-            getRows: async () => {
-                if (fail)
-                    throw new Error('x');
-                return { rows: [{ id: 1 }], rowCount: 1 };
-            },
-        }, { pageSize: 10, onChange: () => { } });
-        ctl.refresh();
-        await flush();
-        expect(ctl.getState().error).toBeInstanceOf(Error);
-        fail = false;
-        ctl.refresh();
-        await flush();
-        expect(ctl.getState().error).toBe(null);
-        expect(ctl.getState().rows).toEqual([{ id: 1 }]);
-    });
-    it('ignores a stale REJECTION when a newer request superseded it', async () => {
-        let call = 0;
-        const src = {
-            getRows: vi.fn(async (req) => {
-                call += 1;
-                if (call === 1) {
-                    await new Promise((r) => setTimeout(r, 40));
-                    throw new Error('stale failure');
-                }
-                await new Promise((r) => setTimeout(r, 5));
-                return { rows: [{ id: req.startRow }], rowCount: 100 };
-            }),
-        };
-        const ctl = createServerDataSource(src, { pageSize: 10, onChange: () => { } });
-        ctl.refresh(); // slow + throws
-        ctl.setPage(2); // fast + wins
-        await new Promise((r) => setTimeout(r, 80));
-        const s = ctl.getState();
-        expect(s.error).toBe(null); // stale rejection did not land
-        expect(s.rows).toEqual([{ id: 20 }]);
-    });
-});
-describe('createServerDataSource - dispose', () => {
-    it('refresh after dispose does not call getRows', async () => {
-        const getRows = vi.fn(async () => ({ rows: [], rowCount: 0 }));
-        const ctl = createServerDataSource({ getRows }, { pageSize: 10, onChange: () => { } });
-        ctl.dispose();
-        ctl.refresh();
-        await flush();
-        expect(getRows).not.toHaveBeenCalled();
-    });
-    it('a response resolving after dispose is ignored', async () => {
-        const onChange = vi.fn();
-        const ctl = createServerDataSource({
-            getRows: async () => {
-                await new Promise((r) => setTimeout(r, 30));
-                return { rows: [{ id: 1 }], rowCount: 1 };
-            },
-        }, { pageSize: 10, onChange });
-        ctl.refresh();
-        ctl.dispose();
-        await new Promise((r) => setTimeout(r, 60));
-        expect(ctl.getState().rows).toEqual([]);
-    });
-});

package/dist/server-data-source.test.d.ts

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

package/dist/server-data-source.test.js

@@ -1,81 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createServerDataSource } from './server-data-source';
-function makeSource(total = 250, delay = 0) {
-    const all = Array.from({ length: total }, (_, i) => ({ id: i }));
-    return {
-        calls: 0,
-        async getRows(req) {
-            this.calls += 1;
-            if (delay)
-                await new Promise((r) => setTimeout(r, delay));
-            // server applies sort: reverse when desc on 'id'
-            let rows = all;
-            if (req.sortModel[0]?.id === 'id' && req.sortModel[0]?.desc)
-                rows = [...all].reverse();
-            return { rows: rows.slice(req.startRow, req.endRow), rowCount: total };
-        },
-    };
-}
-const flush = () => new Promise((r) => setTimeout(r, 0));
-describe('createServerDataSource', () => {
-    it('fetches a page and reports total + pageCount', async () => {
-        const src = makeSource(250);
-        const states = [];
-        const ctl = createServerDataSource(src, { pageSize: 50, onChange: (s) => states.push(s) });
-        ctl.refresh();
-        await flush();
-        const last = ctl.getState();
-        expect(last.rows).toHaveLength(50);
-        expect(last.total).toBe(250);
-        expect(last.pageCount).toBe(5);
-        expect(last.loading).toBe(false);
-        // emitted a loading=true then loading=false
-        expect(states.some((s) => s.loading)).toBe(true);
-    });
-    it('setPage fetches the right slice', async () => {
-        const src = makeSource(250);
-        const ctl = createServerDataSource(src, { pageSize: 50, onChange: () => { } });
-        ctl.setPage(2);
-        await flush();
-        expect(ctl.getState().rows[0]).toEqual({ id: 100 });
-    });
-    it('setSort resets to page 0 and re-fetches', async () => {
-        const src = makeSource(250);
-        const ctl = createServerDataSource(src, { pageSize: 50, onChange: () => { } });
-        ctl.setPage(2);
-        await flush();
-        ctl.setSort([{ id: 'id', desc: true }]);
-        await flush();
-        const s = ctl.getState();
-        expect(s.pageIndex).toBe(0);
-        expect(s.rows[0]).toEqual({ id: 249 }); // reversed
-    });
-    it('ignores a stale response when a newer request supersedes it', async () => {
-        // slow source: first call (page 0) resolves AFTER the second (page 1)
-        const all = Array.from({ length: 100 }, (_, i) => ({ id: i }));
-        let call = 0;
-        const src = {
-            getRows: vi.fn(async (req) => {
-                call += 1;
-                const delay = call === 1 ? 40 : 5; // first call is slow
-                await new Promise((r) => setTimeout(r, delay));
-                return { rows: all.slice(req.startRow, req.endRow), rowCount: 100 };
-            }),
-        };
-        const ctl = createServerDataSource(src, { pageSize: 10, onChange: () => { } });
-        ctl.refresh(); // page 0 (slow)
-        ctl.setPage(3); // page 30 (fast) - should win
-        await new Promise((r) => setTimeout(r, 80));
-        expect(ctl.getState().rows[0]).toEqual({ id: 30 });
-    });
-    it('dispose stops further updates', async () => {
-        const src = makeSource(50, 20);
-        const onChange = vi.fn();
-        const ctl = createServerDataSource(src, { pageSize: 10, onChange });
-        ctl.refresh();
-        ctl.dispose();
-        await new Promise((r) => setTimeout(r, 40));
-        // only the synchronous loading=true emit happened before dispose
-        expect(ctl.getState().rows).toHaveLength(0);
-    });
-});

package/dist/sparkline.test.d.ts

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

package/dist/sparkline.test.js

@@ -1,52 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildSparkline, toSparklineValues } from './sparkline';
-describe('toSparklineValues', () => {
-    it('passes through number arrays and drops non-finite', () => {
-        expect(toSparklineValues([1, 2, NaN, 3])).toEqual([1, 2, 3]);
-    });
-    it('parses comma / space separated strings', () => {
-        expect(toSparklineValues('1, 2 3,4')).toEqual([1, 2, 3, 4]);
-    });
-    it('returns [] for empty / unusable input', () => {
-        expect(toSparklineValues(null)).toEqual([]);
-        expect(toSparklineValues('')).toEqual([]);
-        expect(toSparklineValues({})).toEqual([]);
-    });
-});
-describe('buildSparkline', () => {
-    it('returns null for empty data', () => {
-        expect(buildSparkline([])).toBeNull();
-    });
-    it('builds a line path through every point', () => {
-        const g = buildSparkline([0, 5, 10], { type: 'line', width: 100, height: 20 });
-        expect(g.type).toBe('line');
-        expect(g.linePath.startsWith('M')).toBe(true);
-        // three points => one M + two L commands
-        expect((g.linePath.match(/[ML]/g) ?? []).length).toBe(3);
-        expect(g.lastPoint).not.toBeNull();
-    });
-    it('closes the area path back to the baseline', () => {
-        const g = buildSparkline([1, 2, 3], { type: 'area' });
-        expect(g.areaPath.endsWith('Z')).toBe(true);
-    });
-    it('emits one bar per value and flags negatives', () => {
-        const g = buildSparkline([-2, 4, -1], { type: 'bar' });
-        expect(g.bars).toHaveLength(3);
-        expect(g.bars[0].negative).toBe(true);
-        expect(g.bars[1].negative).toBe(false);
-    });
-    it('winloss uses sign only, equal-height up/down bars', () => {
-        const g = buildSparkline([1, -1, 1], { type: 'winloss', height: 20 });
-        expect(g.bars).toHaveLength(3);
-        expect(g.bars[0].negative).toBe(false);
-        expect(g.bars[1].negative).toBe(true);
-        // up and down bars are the same height (sign-only chart)
-        expect(g.bars[0].h).toBeCloseTo(g.bars[1].h);
-    });
-    it('honors a fixed min/max scale', () => {
-        const a = buildSparkline([5, 5, 5], { type: 'line', min: 0, max: 10 });
-        // flat series on a 0..10 scale sits at the vertical middle, not the top
-        const ys = a.linePath.match(/,(-?\d+(\.\d+)?)/g).map((s) => Number(s.slice(1)));
-        expect(new Set(ys).size).toBe(1);
-    });
-});

package/dist/spreadsheet.test.d.ts

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