@svgrid/grid 1.1.1 → 1.2.1

package/dist/collaboration.coverage.test.js

@@ -1,200 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { broadcastChannelTransport, createCollaboration, } from './collaboration';
-const userA = { id: 'a', name: 'Ada', color: '#f00' };
-const userB = { id: 'b', name: 'Bob', color: '#00f' };
-/** A controllable transport whose subscriber we can drive by hand. */
-function manualTransport() {
-    const handlers = new Set();
-    const posted = [];
-    const transport = {
-        post: (msg) => {
-            posted.push(msg);
-        },
-        subscribe: (h) => {
-            handlers.add(h);
-            return () => handlers.delete(h);
-        },
-    };
-    const deliver = (msg) => {
-        for (const h of [...handlers])
-            h(msg);
-    };
-    return { transport, posted, deliver, handlers };
-}
-describe('createCollaboration - presence / edit upserts', () => {
-    it('hello reply carries the responder own cell', () => {
-        const t = manualTransport();
-        const a = createCollaboration({ user: userA, transport: t.transport });
-        a.setCell({ rowId: 'r0', columnId: 'c0' });
-        t.posted.length = 0;
-        // a newcomer says hello -> A replies presence with its own cell.
-        t.deliver({ kind: 'hello', user: userB });
-        const reply = t.posted.find((m) => m.kind === 'presence');
-        expect(reply).toEqual({ kind: 'presence', user: userA, cell: { rowId: 'r0', columnId: 'c0' } });
-        expect(a.peers().map((p) => p.id)).toEqual(['b']);
-        a.dispose();
-    });
-    it('presence message records the peer cursor', () => {
-        const t = manualTransport();
-        const onPeersChange = vi.fn();
-        const a = createCollaboration({ user: userA, transport: t.transport, onPeersChange });
-        t.deliver({ kind: 'presence', user: userB, cell: { rowId: 'r9', columnId: 'name' } });
-        expect(a.peers()[0]?.cell).toEqual({ rowId: 'r9', columnId: 'name' });
-        expect(onPeersChange).toHaveBeenCalled();
-        a.dispose();
-    });
-    it('edit from another peer sets a cursor AND fires onRemoteEdit', () => {
-        const t = manualTransport();
-        const onRemoteEdit = vi.fn();
-        const a = createCollaboration({ user: userA, transport: t.transport, onRemoteEdit });
-        t.deliver({ kind: 'edit', user: userB, rowId: 'r1', columnId: 'age', value: 30 });
-        expect(a.peers()[0]?.cell).toEqual({ rowId: 'r1', columnId: 'age' });
-        expect(onRemoteEdit).toHaveBeenCalledWith({
-            rowId: 'r1',
-            columnId: 'age',
-            value: 30,
-            user: userB,
-        });
-        a.dispose();
-    });
-    it('ignores own id on upsert (presence/edit echoed back)', () => {
-        const t = manualTransport();
-        const onRemoteEdit = vi.fn();
-        const a = createCollaboration({ user: userA, transport: t.transport, onRemoteEdit });
-        // self-echo: should not appear as a peer and should not call onRemoteEdit
-        t.deliver({ kind: 'presence', user: userA, cell: { rowId: 'x', columnId: 'y' } });
-        t.deliver({ kind: 'edit', user: userA, rowId: 'x', columnId: 'y', value: 1 });
-        expect(a.peers()).toHaveLength(0);
-        expect(onRemoteEdit).not.toHaveBeenCalled();
-        a.dispose();
-    });
-    it('bye for an unknown peer does not notify', () => {
-        const t = manualTransport();
-        const onPeersChange = vi.fn();
-        const a = createCollaboration({ user: userA, transport: t.transport, onPeersChange });
-        onPeersChange.mockClear();
-        t.deliver({ kind: 'bye', userId: 'ghost' });
-        expect(onPeersChange).not.toHaveBeenCalled();
-        a.dispose();
-    });
-    it('setCell broadcasts a presence with the new cell', () => {
-        const t = manualTransport();
-        const a = createCollaboration({ user: userA, transport: t.transport });
-        t.posted.length = 0;
-        a.setCell(null);
-        expect(t.posted).toContainEqual({ kind: 'presence', user: userA, cell: null });
-        a.dispose();
-    });
-    it('sendEdit broadcasts an edit message', () => {
-        const t = manualTransport();
-        const a = createCollaboration({ user: userA, transport: t.transport });
-        t.posted.length = 0;
-        a.sendEdit('r5', 'col', 'v');
-        expect(t.posted).toContainEqual({
-            kind: 'edit',
-            user: userA,
-            rowId: 'r5',
-            columnId: 'col',
-            value: 'v',
-        });
-        a.dispose();
-    });
-    it('drops messages after dispose and unsubscribes', () => {
-        const t = manualTransport();
-        const onPeersChange = vi.fn();
-        const a = createCollaboration({ user: userA, transport: t.transport, onPeersChange });
-        a.dispose();
-        onPeersChange.mockClear();
-        // After dispose the handler is unsubscribed; even if delivered it no-ops.
-        t.deliver({ kind: 'hello', user: userB });
-        expect(onPeersChange).not.toHaveBeenCalled();
-        expect(a.peers()).toHaveLength(0);
-        // second dispose is a no-op
-        a.dispose();
-    });
-});
-describe('createCollaboration - prune timer', () => {
-    beforeEach(() => vi.useFakeTimers());
-    afterEach(() => vi.useRealTimers());
-    it('prunes peers gone silent past the timeout', () => {
-        const t = manualTransport();
-        const onPeersChange = vi.fn();
-        const a = createCollaboration({
-            user: userA,
-            transport: t.transport,
-            onPeersChange,
-            peerTimeoutMs: 3000,
-        });
-        t.deliver({ kind: 'presence', user: userB, cell: null });
-        expect(a.peers()).toHaveLength(1);
-        onPeersChange.mockClear();
-        // advance past the timeout; prune interval is max(1000, timeout/3) = 1000
-        vi.advanceTimersByTime(4000);
-        expect(a.peers()).toHaveLength(0);
-        expect(onPeersChange).toHaveBeenCalled();
-        a.dispose();
-    });
-    it('prune tick with no expired peers does not notify', () => {
-        const t = manualTransport();
-        const onPeersChange = vi.fn();
-        const a = createCollaboration({
-            user: userA,
-            transport: t.transport,
-            onPeersChange,
-            peerTimeoutMs: 9000,
-        });
-        t.deliver({ kind: 'presence', user: userB, cell: null });
-        onPeersChange.mockClear();
-        vi.advanceTimersByTime(3000); // one tick, peer still fresh
-        expect(onPeersChange).not.toHaveBeenCalled();
-        expect(a.peers()).toHaveLength(1);
-        a.dispose();
-    });
-    it('dispose clears the prune timer', () => {
-        const clearSpy = vi.spyOn(globalThis, 'clearInterval');
-        const t = manualTransport();
-        const a = createCollaboration({ user: userA, transport: t.transport });
-        a.dispose();
-        expect(clearSpy).toHaveBeenCalled();
-        clearSpy.mockRestore();
-    });
-});
-describe('broadcastChannelTransport', () => {
-    it('round-trips a message across two channels of the same name', async () => {
-        const tx = broadcastChannelTransport('svgrid-test-chan');
-        const rx = broadcastChannelTransport('svgrid-test-chan');
-        const received = [];
-        const off = rx.subscribe((m) => received.push(m));
-        tx.post({ kind: 'hello', user: userA });
-        // BroadcastChannel delivery is async (microtask/macrotask).
-        await new Promise((r) => setTimeout(r, 10));
-        expect(received).toContainEqual({ kind: 'hello', user: userA });
-        off();
-    });
-    it('subscribe returns a working unsubscribe', async () => {
-        const tx = broadcastChannelTransport('svgrid-unsub-chan');
-        const rx = broadcastChannelTransport('svgrid-unsub-chan');
-        const received = [];
-        const off = rx.subscribe((m) => received.push(m));
-        off();
-        tx.post({ kind: 'bye', userId: 'a' });
-        await new Promise((r) => setTimeout(r, 10));
-        expect(received).toHaveLength(0);
-    });
-    it('no-ops gracefully when BroadcastChannel is unavailable', () => {
-        const original = globalThis.BroadcastChannel;
-        // @ts-expect-error - simulate SSR / old environment
-        delete globalThis.BroadcastChannel;
-        try {
-            const tx = broadcastChannelTransport('nope');
-            const handler = vi.fn();
-            const off = tx.subscribe(handler);
-            expect(() => tx.post({ kind: 'bye', userId: 'x' })).not.toThrow();
-            expect(() => off()).not.toThrow();
-            expect(handler).not.toHaveBeenCalled();
-        }
-        finally {
-            globalThis.BroadcastChannel = original;
-        }
-    });
-});

package/dist/collaboration.test.d.ts

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

package/dist/collaboration.test.js

@@ -1,65 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createCollaboration, } from './collaboration';
-/** An in-memory bus so two controllers can talk in a test. */
-function makeBus() {
-    const handlers = new Set();
-    const transportFor = () => ({
-        post: (msg) => {
-            // deliver async-ish to every subscriber except none (real channels echo
-            // to other tabs, not self; our controllers ignore their own id anyway).
-            for (const h of [...handlers])
-                h(msg);
-        },
-        subscribe: (h) => {
-            handlers.add(h);
-            return () => handlers.delete(h);
-        },
-    });
-    return { transportFor };
-}
-const userA = { id: 'a', name: 'Ada', color: '#f00' };
-const userB = { id: 'b', name: 'Bob', color: '#00f' };
-describe('createCollaboration', () => {
-    it('peers see each other after hello', () => {
-        const bus = makeBus();
-        const a = createCollaboration({ user: userA, transport: bus.transportFor() });
-        const b = createCollaboration({ user: userB, transport: bus.transportFor() });
-        // A is announced; B's hello reaches A; A replies presence.
-        expect(a.peers().map((p) => p.id)).toEqual(['b']);
-        expect(b.peers().map((p) => p.id)).toEqual(['a']);
-        a.dispose();
-        b.dispose();
-    });
-    it('setCell propagates a remote cursor', () => {
-        const bus = makeBus();
-        const onPeers = vi.fn();
-        const a = createCollaboration({ user: userA, transport: bus.transportFor(), onPeersChange: onPeers });
-        const b = createCollaboration({ user: userB, transport: bus.transportFor() });
-        b.setCell({ rowId: 'r1', columnId: 'salary' });
-        const peerB = a.peers().find((p) => p.id === 'b');
-        expect(peerB?.cell).toEqual({ rowId: 'r1', columnId: 'salary' });
-        a.dispose();
-        b.dispose();
-    });
-    it('sendEdit fires onRemoteEdit on the other peer only', () => {
-        const bus = makeBus();
-        const aEdits = vi.fn();
-        const bEdits = vi.fn();
-        const a = createCollaboration({ user: userA, transport: bus.transportFor(), onRemoteEdit: aEdits });
-        const b = createCollaboration({ user: userB, transport: bus.transportFor(), onRemoteEdit: bEdits });
-        a.sendEdit('r2', 'name', 'Grace');
-        expect(bEdits).toHaveBeenCalledWith(expect.objectContaining({ rowId: 'r2', columnId: 'name', value: 'Grace' }));
-        expect(aEdits).not.toHaveBeenCalled(); // not echoed to self
-        a.dispose();
-        b.dispose();
-    });
-    it('bye removes a peer', () => {
-        const bus = makeBus();
-        const a = createCollaboration({ user: userA, transport: bus.transportFor() });
-        const b = createCollaboration({ user: userB, transport: bus.transportFor() });
-        expect(a.peers()).toHaveLength(1);
-        b.dispose();
-        expect(a.peers()).toHaveLength(0);
-        a.dispose();
-    });
-});

package/dist/column-groups.test.d.ts

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

package/dist/column-groups.test.js

@@ -1,56 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { computeColumnGroupMeta, hiddenLeavesForCollapse } from './column-groups';
-// A group "Q1" with an always-on Total plus Jan/Feb that only show when open.
-const columns = [
-    { field: 'name' },
-    {
-        id: 'q1',
-        header: 'Q1',
-        columns: [
-            { field: 'q1Total' },
-            { field: 'jan', columnGroupShow: 'open' },
-            { field: 'feb', columnGroupShow: 'open' },
-        ],
-    },
-    {
-        id: 'q2',
-        header: 'Q2',
-        openByDefault: true,
-        columns: [
-            { field: 'q2Total', columnGroupShow: 'closed' },
-            { field: 'apr', columnGroupShow: 'open' },
-        ],
-    },
-];
-describe('computeColumnGroupMeta', () => {
-    it('marks groups with columnGroupShow children as collapsible', () => {
-        const meta = computeColumnGroupMeta(columns);
-        expect([...meta.collapsibleGroupIds].sort()).toEqual(['q1', 'q2']);
-        expect(meta.defaultOpen.get('q1')).toBe(false);
-        expect(meta.defaultOpen.get('q2')).toBe(true);
-    });
-    it('maps controlled leaves to their group + show mode', () => {
-        const meta = computeColumnGroupMeta(columns);
-        expect(meta.leafControl.get('jan')).toEqual({ groupId: 'q1', show: 'open' });
-        expect(meta.leafControl.get('q2Total')).toEqual({ groupId: 'q2', show: 'closed' });
-        // untagged always-on column is not controlled
-        expect(meta.leafControl.has('q1Total')).toBe(false);
-        expect(meta.leafControl.has('name')).toBe(false);
-    });
-});
-describe('hiddenLeavesForCollapse', () => {
-    const meta = computeColumnGroupMeta(columns);
-    it('hides open-columns while collapsed, shows them while expanded', () => {
-        const collapsed = new Set(['q1']);
-        const hidden = hiddenLeavesForCollapse(meta, collapsed);
-        expect(hidden.jan).toBe(true);
-        expect(hidden.feb).toBe(true);
-        expect(hidden.q1Total).toBeUndefined(); // always on
-    });
-    it('hides closed-columns while expanded', () => {
-        const collapsed = new Set(); // q2 expanded
-        const hidden = hiddenLeavesForCollapse(meta, collapsed);
-        expect(hidden.q2Total).toBe(true); // 'closed' hides when expanded
-        expect(hidden.apr).toBeUndefined(); // 'open' shows when expanded
-    });
-});

package/dist/column-types.test.d.ts

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

package/dist/column-types.test.js

@@ -1,62 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { inferCellDataType, resolveColumnTypes } from './column-types';
-describe('inferCellDataType', () => {
-    it('classifies primitives', () => {
-        expect(inferCellDataType(42)).toBe('number');
-        expect(inferCellDataType(true)).toBe('boolean');
-        expect(inferCellDataType(new Date())).toBe('date');
-        expect(inferCellDataType('2026-06-27')).toBe('dateString');
-        expect(inferCellDataType('2026-06-27T10:00:00Z')).toBe('dateString');
-        expect(inferCellDataType('hello')).toBe('text');
-    });
-    it('returns undefined for null/undefined so nothing is forced', () => {
-        expect(inferCellDataType(null)).toBeUndefined();
-        expect(inferCellDataType(undefined)).toBeUndefined();
-    });
-});
-describe('resolveColumnTypes', () => {
-    it('maps explicit cellDataType to editorType + format', () => {
-        const cols = [
-            { field: 'name', cellDataType: 'text' },
-            { field: 'age', cellDataType: 'number' },
-            { field: 'active', cellDataType: 'boolean' },
-            { field: 'joined', cellDataType: 'date' },
-            { field: 'iso', cellDataType: 'dateString' },
-        ];
-        const out = resolveColumnTypes(cols, undefined, false);
-        expect(out[0].editorType).toBe('text');
-        expect(out[1].editorType).toBe('number');
-        expect(out[2].editorType).toBe('checkbox');
-        expect(out[3].editorType).toBe('date');
-        expect(out[3].format).toEqual({ type: 'date' });
-        expect(out[4].editorType).toBe('date');
-        expect(out[4].format).toBeUndefined();
-    });
-    it('never overrides an explicit editorType or format', () => {
-        const cols = [{ field: 'age', cellDataType: 'number', editorType: 'text', format: { type: 'currency' } }];
-        const out = resolveColumnTypes(cols, undefined, false);
-        expect(out[0].editorType).toBe('text');
-        expect(out[0].format).toEqual({ type: 'currency' });
-    });
-    it('infers from a sample row only when infer=true and nothing is declared', () => {
-        const cols = [
-            { field: 'age' },
-            { field: 'name' },
-            { field: 'when' },
-            { field: 'flag' },
-        ];
-        const sample = { age: 30, name: 'Ada', when: '2026-01-02', flag: false };
-        const off = resolveColumnTypes(cols, sample, false);
-        expect(off[0].editorType).toBeUndefined(); // inference off
-        const on = resolveColumnTypes(cols, sample, true);
-        expect(on[0].editorType).toBe('number');
-        expect(on[1].editorType).toBe('text');
-        expect(on[2].editorType).toBe('date');
-        expect(on[3].editorType).toBe('checkbox');
-    });
-    it('recurses into header groups', () => {
-        const cols = [{ header: 'Group', columns: [{ field: 'age', cellDataType: 'number' }] }];
-        const out = resolveColumnTypes(cols, undefined, false);
-        expect(out[0].columns[0].editorType).toBe('number');
-    });
-});

package/dist/columns.test.d.ts

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