@svgrid/grid 1.1.1 → 1.2.1

package/dist/named-views.coverage.test.js

@@ -1,180 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { attachAutoSavedView, createNamedViews, localStorageViews, memoryViews, } from './named-views';
-function fakeHost(initial = {}) {
-    let state = { sorting: [], columnFilters: [], ...initial };
-    return {
-        getState: () => state,
-        setState: vi.fn((s) => {
-            state = { ...state, ...s };
-        }),
-        set: (s) => {
-            state = s;
-        },
-    };
-}
-describe('createNamedViews - list ordering and edge cases', () => {
-    it('lists views sorted by createdAt ascending', () => {
-        const store = memoryViews([
-            { name: 'late', state: {}, createdAt: 200 },
-            { name: 'early', state: {}, createdAt: 100 },
-        ]);
-        const views = createNamedViews(fakeHost(), { storage: store });
-        expect(views.list().map((v) => v.name)).toEqual(['early', 'late']);
-    });
-    it('defaults to memory storage when none is passed', () => {
-        const views = createNamedViews(fakeHost({ sorting: [{ id: 'a', desc: true }] }));
-        views.save('only');
-        expect(views.has('only')).toBe(true);
-        expect(views.list()).toHaveLength(1);
-    });
-    it('rename returns false when the source name is unknown', () => {
-        const views = createNamedViews(fakeHost(), { storage: memoryViews() });
-        views.save('a');
-        expect(views.rename('missing', 'b')).toBe(false);
-        expect(views.list().map((v) => v.name)).toEqual(['a']);
-    });
-    it('load returns false and does not call setState for unknown name', () => {
-        const host = fakeHost();
-        const views = createNamedViews(host, { storage: memoryViews() });
-        host.setState.mockClear();
-        expect(views.load('nope')).toBe(false);
-        expect(host.setState).not.toHaveBeenCalled();
-    });
-    it('save captures the current host state snapshot', () => {
-        const host = fakeHost({ sorting: [{ id: 'z', desc: false }] });
-        const views = createNamedViews(host, { storage: memoryViews() });
-        const v = views.save('snap');
-        expect(v.state).toMatchObject({ sorting: [{ id: 'z', desc: false }] });
-        expect(typeof v.createdAt).toBe('number');
-    });
-});
-describe('localStorageViews', () => {
-    beforeEach(() => localStorage.clear());
-    afterEach(() => localStorage.clear());
-    it('reads [] when the key is absent', () => {
-        const store = localStorageViews('svgrid:absent');
-        expect(store.read()).toEqual([]);
-    });
-    it('round-trips views through localStorage', () => {
-        const store = localStorageViews('svgrid:rt');
-        const views = [{ name: 'x', state: {}, createdAt: 1 }];
-        store.write(views);
-        expect(store.read()).toEqual(views);
-        // raw JSON is actually present
-        expect(JSON.parse(localStorage.getItem('svgrid:rt'))).toEqual(views);
-    });
-    it('returns [] for corrupt JSON', () => {
-        localStorage.setItem('svgrid:bad', '{not valid json');
-        expect(localStorageViews('svgrid:bad').read()).toEqual([]);
-    });
-    it('returns [] when the stored value is not an array', () => {
-        localStorage.setItem('svgrid:obj', JSON.stringify({ foo: 'bar' }));
-        expect(localStorageViews('svgrid:obj').read()).toEqual([]);
-    });
-    it('swallows write errors (quota / private mode)', () => {
-        const store = localStorageViews('svgrid:quota');
-        const spy = vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
-            throw new DOMException('quota', 'QuotaExceededError');
-        });
-        expect(() => store.write([{ name: 'a', state: {}, createdAt: 1 }])).not.toThrow();
-        spy.mockRestore();
-    });
-    it('works end-to-end as a NamedViews adapter', () => {
-        const views = createNamedViews(fakeHost({ sorting: [{ id: 'p', desc: true }] }), {
-            storage: localStorageViews('svgrid:adapter'),
-        });
-        views.save('persisted');
-        const reopened = createNamedViews(fakeHost(), {
-            storage: localStorageViews('svgrid:adapter'),
-        });
-        expect(reopened.has('persisted')).toBe(true);
-        expect(reopened.load('persisted')).toBe(true);
-    });
-});
-describe('attachAutoSavedView', () => {
-    beforeEach(() => vi.useFakeTimers());
-    afterEach(() => vi.useRealTimers());
-    it('restores an existing autosave slot on attach', () => {
-        const host = fakeHost();
-        const store = memoryViews([
-            { name: '__autosave', state: { sorting: [{ id: 'restored', desc: true }] }, createdAt: 1 },
-        ]);
-        const views = createNamedViews(host, { storage: store });
-        const off = attachAutoSavedView(host, views);
-        expect(host.setState).toHaveBeenCalledWith(expect.objectContaining({ sorting: [{ id: 'restored', desc: true }] }));
-        off();
-    });
-    it('skips restore when skipRestore is set', () => {
-        const host = fakeHost();
-        const store = memoryViews([{ name: '__autosave', state: { sorting: [] }, createdAt: 1 }]);
-        const views = createNamedViews(host, { storage: store });
-        const off = attachAutoSavedView(host, views, { skipRestore: true });
-        expect(host.setState).not.toHaveBeenCalled();
-        off();
-    });
-    it('saves when the state snapshot changes after an interval', () => {
-        const host = fakeHost({ sorting: [] });
-        const views = createNamedViews(host, { storage: memoryViews() });
-        const off = attachAutoSavedView(host, views, { intervalMs: 500 });
-        expect(views.has('__autosave')).toBe(false);
-        // mutate the host state, then let the poller tick
-        host.set({ sorting: [{ id: 'new', desc: false }], columnFilters: [] });
-        vi.advanceTimersByTime(500);
-        expect(views.has('__autosave')).toBe(true);
-        off();
-    });
-    it('does not save when the snapshot is unchanged', () => {
-        const host = fakeHost({ sorting: [] });
-        const views = createNamedViews(host, { storage: memoryViews() });
-        const saveSpy = vi.spyOn(views, 'save');
-        const off = attachAutoSavedView(host, views, { intervalMs: 300 });
-        vi.advanceTimersByTime(900); // several ticks, no state change
-        expect(saveSpy).not.toHaveBeenCalled();
-        off();
-    });
-    it('uses a custom slot name', () => {
-        const host = fakeHost({ sorting: [] });
-        const views = createNamedViews(host, { storage: memoryViews() });
-        const off = attachAutoSavedView(host, views, { name: 'mySlot', intervalMs: 200 });
-        host.set({ sorting: [{ id: 'q', desc: true }], columnFilters: [] });
-        vi.advanceTimersByTime(200);
-        expect(views.has('mySlot')).toBe(true);
-        off();
-    });
-    it('clamps the interval to a minimum of 100ms', () => {
-        const host = fakeHost({ sorting: [] });
-        const views = createNamedViews(host, { storage: memoryViews() });
-        const setIntervalSpy = vi.spyOn(globalThis, 'setInterval');
-        const off = attachAutoSavedView(host, views, { intervalMs: 5 });
-        expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 100);
-        off();
-        setIntervalSpy.mockRestore();
-    });
-    it('recovers when getState throws inside the poll loop', () => {
-        let throwing = false;
-        const host = {
-            getState: () => {
-                if (throwing)
-                    throw new Error('boom');
-                return { sorting: [], columnFilters: [] };
-            },
-            setState: vi.fn(),
-        };
-        const views = createNamedViews(host, { storage: memoryViews() });
-        const saveSpy = vi.spyOn(views, 'save');
-        const off = attachAutoSavedView(host, views, { intervalMs: 200 });
-        throwing = true;
-        expect(() => vi.advanceTimersByTime(400)).not.toThrow();
-        expect(saveSpy).not.toHaveBeenCalled();
-        off();
-    });
-    it('detach stops the polling interval', () => {
-        const host = fakeHost({ sorting: [] });
-        const views = createNamedViews(host, { storage: memoryViews() });
-        const clearSpy = vi.spyOn(globalThis, 'clearInterval');
-        const off = attachAutoSavedView(host, views, { intervalMs: 200 });
-        off();
-        expect(clearSpy).toHaveBeenCalled();
-        clearSpy.mockRestore();
-    });
-});

package/dist/named-views.test.d.ts

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

package/dist/named-views.test.js

@@ -1,57 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createNamedViews, memoryViews } from './named-views';
-function fakeHost(initial = {}) {
-    let state = { sorting: [], columnFilters: [], ...initial };
-    return {
-        getState: () => state,
-        setState: vi.fn((s) => {
-            state = { ...state, ...s };
-        }),
-        _peek: () => state,
-    };
-}
-describe('createNamedViews', () => {
-    it('saves the current state and lists it', () => {
-        const host = fakeHost({ sorting: [{ id: 'name', desc: true }] });
-        const views = createNamedViews(host, { storage: memoryViews() });
-        views.save('By name');
-        expect(views.list().map((v) => v.name)).toEqual(['By name']);
-        expect(views.has('By name')).toBe(true);
-    });
-    it('load applies the saved state via setState', () => {
-        const host = fakeHost({ sorting: [{ id: 'age', desc: false }] });
-        const views = createNamedViews(host, { storage: memoryViews() });
-        views.save('snap');
-        host.setState({ sorting: [] }); // mutate away
-        host.setState.mockClear();
-        expect(views.load('snap')).toBe(true);
-        expect(host.setState).toHaveBeenCalledWith(expect.objectContaining({ sorting: [{ id: 'age', desc: false }] }));
-        expect(views.load('missing')).toBe(false);
-    });
-    it('save overwrites a duplicate name but keeps its createdAt', () => {
-        const host = fakeHost();
-        const views = createNamedViews(host, { storage: memoryViews() });
-        const a = views.save('v');
-        const b = views.save('v');
-        expect(views.list()).toHaveLength(1);
-        expect(b.createdAt).toBe(a.createdAt);
-    });
-    it('remove and rename', () => {
-        const host = fakeHost();
-        const views = createNamedViews(host, { storage: memoryViews() });
-        views.save('a');
-        views.save('b');
-        expect(views.rename('a', 'c')).toBe(true);
-        expect(views.rename('c', 'b')).toBe(false); // target exists
-        expect(views.remove('c')).toBe(true);
-        expect(views.remove('c')).toBe(false);
-        expect(views.list().map((v) => v.name)).toEqual(['b']);
-    });
-    it('persists through a storage adapter', () => {
-        const store = memoryViews();
-        createNamedViews(fakeHost({ sorting: [{ id: 'x', desc: true }] }), { storage: store }).save('keep');
-        // A fresh manager over the same storage sees it.
-        const reopened = createNamedViews(fakeHost(), { storage: store });
-        expect(reopened.has('keep')).toBe(true);
-    });
-});

package/dist/new-features.test.d.ts

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

package/dist/new-features.test.js

@@ -1,183 +0,0 @@
-/**
- * Tests for the headless-engine features shipped alongside the wrapper
- * additions (`getRowId`, the `between` filter operator). Wrapper-level
- * additions are covered by the source-level smoke tests in
- * `svgrid.new-features.wrapper.test.ts` - jsdom + Svelte 5 mount is
- * brittle for tests that only need to confirm props are read.
- */
-import { describe, expect, it } from 'vitest';
-import { columnFilteringFeature, createCoreRowModel, createSvGrid, rowSortingFeature, tableFeatures, } from './index';
-import { applyExcelFilter } from './filtering/excel-filters';
-const data = [
-    { id: 'ada', name: 'Ada Lovelace', age: 36 },
-    { id: 'linus', name: 'Linus Torvalds', age: 54 },
-    { id: 'grace', name: 'Grace Hopper', age: 85 },
-];
-const columns = [
-    { field: 'id', header: 'ID' },
-    { field: 'name', header: 'Name' },
-    { field: 'age', header: 'Age' },
-];
-const features = tableFeatures({ rowSortingFeature });
-describe('createSvGrid - getRowId', () => {
-    it('falls back to the array index as id when no getRowId is provided', () => {
-        const grid = createSvGrid({
-            _features: features,
-            _rowModels: { coreRowModel: createCoreRowModel() },
-            columns,
-            data,
-        });
-        const rows = grid.getRowModel().rows;
-        expect(rows.map((r) => r.id)).toEqual(['0', '1', '2']);
-    });
-    it('uses the result of getRowId(row, index) as the row id', () => {
-        const grid = createSvGrid({
-            _features: features,
-            _rowModels: { coreRowModel: createCoreRowModel() },
-            columns,
-            data,
-            getRowId: (row) => row.id,
-        });
-        const rows = grid.getRowModel().rows;
-        expect(rows.map((r) => r.id)).toEqual(['ada', 'linus', 'grace']);
-    });
-    it('passes the row index to getRowId', () => {
-        const seen = [];
-        createSvGrid({
-            _features: features,
-            _rowModels: { coreRowModel: createCoreRowModel() },
-            columns,
-            data,
-            getRowId: (row, index) => {
-                seen.push({ id: row.id, index });
-                return row.id;
-            },
-        }).getRowModel().rows;
-        expect(seen).toEqual([
-            { id: 'ada', index: 0 },
-            { id: 'linus', index: 1 },
-            { id: 'grace', index: 2 },
-        ]);
-    });
-    it('preserves the same id across `getRowModel()` invocations (stable identity)', () => {
-        const grid = createSvGrid({
-            _features: features,
-            _rowModels: { coreRowModel: createCoreRowModel() },
-            columns,
-            data,
-            getRowId: (row) => `r:${row.id}`,
-        });
-        const first = grid.getRowModel().rows.map((r) => r.id);
-        const second = grid.getRowModel().rows.map((r) => r.id);
-        expect(first).toEqual(second);
-        expect(first).toEqual(['r:ada', 'r:linus', 'r:grace']);
-    });
-});
-describe('applyExcelFilter - between operator', () => {
-    it('returns true when the value is inside the inclusive range', () => {
-        expect(applyExcelFilter(50, { id: 'age', operator: 'between', value: 18, valueTo: 65 })).toBe(true);
-    });
-    it('is inclusive at the lower bound', () => {
-        expect(applyExcelFilter(18, { id: 'age', operator: 'between', value: 18, valueTo: 65 })).toBe(true);
-    });
-    it('is inclusive at the upper bound', () => {
-        expect(applyExcelFilter(65, { id: 'age', operator: 'between', value: 18, valueTo: 65 })).toBe(true);
-    });
-    it('returns false when the value is below the range', () => {
-        expect(applyExcelFilter(17, { id: 'age', operator: 'between', value: 18, valueTo: 65 })).toBe(false);
-    });
-    it('returns false when the value is above the range', () => {
-        expect(applyExcelFilter(66, { id: 'age', operator: 'between', value: 18, valueTo: 65 })).toBe(false);
-    });
-    it('parses string endpoints as numbers (the wrapper hands strings through)', () => {
-        expect(applyExcelFilter('30', { id: 'age', operator: 'between', value: '18', valueTo: '65' })).toBe(true);
-    });
-    it('works with ISO date strings via lexicographic compare', () => {
-        expect(applyExcelFilter('2026-06-15', {
-            id: 'd', operator: 'between', value: '2026-01-01', valueTo: '2026-12-31',
-        })).toBe(true);
-        expect(applyExcelFilter('2025-12-31', {
-            id: 'd', operator: 'between', value: '2026-01-01', valueTo: '2026-12-31',
-        })).toBe(false);
-        expect(applyExcelFilter('2027-01-01', {
-            id: 'd', operator: 'between', value: '2026-01-01', valueTo: '2026-12-31',
-        })).toBe(false);
-    });
-});
-describe('ColumnDef.sortable + ColumnDef.filterable', () => {
-    const features = tableFeatures({
-        rowSortingFeature,
-        columnFilteringFeature,
-    });
-    function columnsWith(opts) {
-        return [
-            { field: 'id', header: 'ID' },
-            { field: 'name', header: 'Name', sortable: opts.nameSortable, filterable: opts.nameFilterable },
-            { field: 'age', header: 'Age', sortable: opts.ageSortable },
-        ];
-    }
-    it('getCanSort() returns true by default when rowSortingFeature is on', () => {
-        const grid = createSvGrid({
-            _features: features,
-            _rowModels: { coreRowModel: createCoreRowModel() },
-            data,
-            columns: columnsWith({}),
-        });
-        const name = grid.getAllColumns().find((c) => c.id === 'name');
-        expect(name?.getCanSort()).toBe(true);
-    });
-    it('getCanSort() returns false when columnDef.sortable === false', () => {
-        const grid = createSvGrid({
-            _features: features,
-            _rowModels: { coreRowModel: createCoreRowModel() },
-            data,
-            columns: columnsWith({ nameSortable: false }),
-        });
-        const name = grid.getAllColumns().find((c) => c.id === 'name');
-        const age = grid.getAllColumns().find((c) => c.id === 'age');
-        expect(name?.getCanSort()).toBe(false);
-        expect(age?.getCanSort()).toBe(true);
-    });
-    it('getCanSort() still returns false even with sortable: true if the feature is OFF', () => {
-        const noSortFeatures = tableFeatures({ columnFilteringFeature });
-        const grid = createSvGrid({
-            _features: noSortFeatures,
-            _rowModels: { coreRowModel: createCoreRowModel() },
-            data,
-            columns: [
-                { field: 'name', header: 'Name', sortable: true },
-            ],
-        });
-        const name = grid.getAllColumns().find((c) => c.id === 'name');
-        expect(name?.getCanSort()).toBe(false);
-    });
-    it('getCanFilter() returns false when columnDef.filterable === false', () => {
-        const grid = createSvGrid({
-            _features: features,
-            _rowModels: { coreRowModel: createCoreRowModel() },
-            data,
-            columns: columnsWith({ nameFilterable: false }),
-        });
-        const name = grid.getAllColumns().find((c) => c.id === 'name');
-        const age = grid.getAllColumns().find((c) => c.id === 'age');
-        expect(name?.getCanFilter()).toBe(false);
-        expect(age?.getCanFilter()).toBe(true);
-    });
-    it('sortable + filterable are independent', () => {
-        const grid = createSvGrid({
-            _features: features,
-            _rowModels: { coreRowModel: createCoreRowModel() },
-            data,
-            columns: [
-                { field: 'name', header: 'Name', sortable: false, filterable: true },
-                { field: 'age', header: 'Age', sortable: true, filterable: false },
-            ],
-        });
-        const name = grid.getAllColumns().find((c) => c.id === 'name');
-        const age = grid.getAllColumns().find((c) => c.id === 'age');
-        expect(name?.getCanSort()).toBe(false);
-        expect(name?.getCanFilter()).toBe(true);
-        expect(age?.getCanSort()).toBe(true);
-        expect(age?.getCanFilter()).toBe(false);
-    });
-});

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

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

package/dist/render-component.test.js

@@ -1,41 +0,0 @@
-/**
- * Unit tests for the renderComponent / renderSnippet factories.
- */
-import { describe, expect, it } from 'vitest';
-import { RenderComponentConfig, RenderSnippetConfig, renderComponent, renderSnippet, } from './render-component';
-describe('renderComponent', () => {
-    it('returns a RenderComponentConfig instance', () => {
-        const FakeComponent = (() => null);
-        const config = renderComponent(FakeComponent);
-        expect(config).toBeInstanceOf(RenderComponentConfig);
-        expect(config.component).toBe(FakeComponent);
-        expect(config.props).toBeUndefined();
-    });
-    it('captures the props payload as-is', () => {
-        const FakeComponent = (() => null);
-        const config = renderComponent(FakeComponent, { id: 1, label: 'Hello' });
-        expect(config.props).toEqual({ id: 1, label: 'Hello' });
-    });
-    it('reuses the constructor instance fields', () => {
-        const FakeComponent = (() => null);
-        const a = renderComponent(FakeComponent, { x: 1 });
-        const b = renderComponent(FakeComponent, { x: 1 });
-        // Different instances - the factory does not memoize.
-        expect(a).not.toBe(b);
-        expect(a.component).toBe(b.component);
-    });
-});
-describe('renderSnippet', () => {
-    it('returns a RenderSnippetConfig instance with the captured snippet + params', () => {
-        const fakeSnippet = (() => null);
-        const config = renderSnippet(fakeSnippet, { value: 42 });
-        expect(config).toBeInstanceOf(RenderSnippetConfig);
-        expect(config.snippet).toBe(fakeSnippet);
-        expect(config.params).toEqual({ value: 42 });
-    });
-    it('allows an undefined params payload', () => {
-        const fakeSnippet = (() => null);
-        const config = renderSnippet(fakeSnippet);
-        expect(config.params).toBeUndefined();
-    });
-});

package/dist/row-drag.test.d.ts

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

package/dist/row-drag.test.js

@@ -1,142 +0,0 @@
-/**
- * Unit tests for the managed row-drag handlers produced by createRowDrag(ctx).
- *
- * createRowDrag is a factory closing over a mutable `ctx` handle and a
- * module-level singleton "bus" that carries the dragged row between grids.
- * Because the bus is shared, we can create TWO fake ctxs (two grids) and drive
- * a genuine grid-to-grid move without mounting anything.
- */
-import { describe, expect, it, vi } from 'vitest';
-import { createRowDrag, rowDropZone } from './row-drag';
-function makeCtx(rows, props = {}) {
-    return {
-        props,
-        internalData: rows,
-        get allRows() {
-            // allRows tracks internalData order; each Row wraps `.original`.
-            return this.internalData.map((r) => ({ original: r }));
-        },
-        rowDragActive: false,
-        rowDropIndex: null,
-        rowDropSide: null,
-    };
-}
-function fakeEvent(clientY = 0, rectTop = 0, rectHeight = 40) {
-    return {
-        clientY,
-        preventDefault: vi.fn(),
-        stopPropagation: vi.fn(),
-        dataTransfer: { setData: vi.fn(), effectAllowed: '', dropEffect: '' },
-        currentTarget: {
-            getBoundingClientRect: () => ({ top: rectTop, height: rectHeight, bottom: rectTop + rectHeight, left: 0 }),
-        },
-    };
-}
-const P = { rowDragManaged: true };
-describe('createRowDrag - same-grid reorder', () => {
-    it('moves a dragged row after the drop target', () => {
-        const rows = [
-            { id: 1, title: 'a' },
-            { id: 2, title: 'b' },
-            { id: 3, title: 'c' },
-            { id: 4, title: 'd' },
-        ];
-        const ctx = makeCtx(rows, { ...P });
-        const h = createRowDrag(ctx);
-        h.onRowDragStart(fakeEvent(), 0); // drag "a"
-        ctx.rowDropSide = 'after';
-        h.onRowDrop(fakeEvent(), 2); // drop after "c"
-        expect(ctx.internalData.map((r) => r.title)).toEqual(['b', 'c', 'a', 'd']);
-    });
-    it('drops before the target when the side is "before"', () => {
-        const rows = [
-            { id: 1, title: 'a' },
-            { id: 2, title: 'b' },
-            { id: 3, title: 'c' },
-        ];
-        const ctx = makeCtx(rows, { ...P });
-        const h = createRowDrag(ctx);
-        h.onRowDragStart(fakeEvent(), 2); // drag "c"
-        ctx.rowDropSide = 'before';
-        h.onRowDrop(fakeEvent(), 0); // before "a"
-        expect(ctx.internalData.map((r) => r.title)).toEqual(['c', 'a', 'b']);
-    });
-});
-describe('createRowDrag - grid-to-grid', () => {
-    it('moves a row from source into target when groups match', () => {
-        const a = makeCtx([{ id: 1, title: 'a1' }, { id: 2, title: 'a2' }], { ...P, rowDragGroup: 'g' });
-        const b = makeCtx([{ id: 9, title: 'b1' }], { ...P, rowDragGroup: 'g', onRowDragEnd: vi.fn() });
-        const ha = createRowDrag(a);
-        const hb = createRowDrag(b);
-        ha.onRowDragStart(fakeEvent(), 1); // drag "a2" out of grid A
-        b.rowDropSide = 'before';
-        hb.onRowDrop(fakeEvent(), 0); // drop onto grid B before "b1"
-        expect(a.internalData.map((r) => r.title)).toEqual(['a1']);
-        expect(b.internalData.map((r) => r.title)).toEqual(['a2', 'b1']);
-        expect(b.props.onRowDragEnd).toHaveBeenCalledWith(expect.objectContaining({ sameGrid: false, toIndex: 0, row: expect.objectContaining({ title: 'a2' }) }));
-    });
-    it('does NOT accept a drop when groups differ', () => {
-        const a = makeCtx([{ id: 1, title: 'a1' }, { id: 2, title: 'a2' }], { ...P, rowDragGroup: 'g' });
-        const b = makeCtx([{ id: 9, title: 'b1' }], { ...P, rowDragGroup: 'other' });
-        const ha = createRowDrag(a);
-        const hb = createRowDrag(b);
-        ha.onRowDragStart(fakeEvent(), 0);
-        const ev = fakeEvent();
-        hb.onRowDragOver(ev, 0);
-        expect(ev.preventDefault).not.toHaveBeenCalled(); // over rejected
-        hb.onRowDrop(fakeEvent(), 0);
-        expect(b.internalData.map((r) => r.title)).toEqual(['b1']); // unchanged
-        expect(a.internalData.length).toBe(2); // source untouched
-    });
-    it('appends to the target on an empty-space (container) drop', () => {
-        const a = makeCtx([{ id: 1, title: 'a1' }, { id: 2, title: 'a2' }], { ...P, rowDragGroup: 'g' });
-        const b = makeCtx([{ id: 9, title: 'b1' }], { ...P, rowDragGroup: 'g' });
-        const ha = createRowDrag(a);
-        const hb = createRowDrag(b);
-        ha.onRowDragStart(fakeEvent(), 0); // drag "a1"
-        hb.onRowsContainerDrop(fakeEvent());
-        expect(b.internalData.map((r) => r.title)).toEqual(['b1', 'a1']);
-        expect(a.internalData.map((r) => r.title)).toEqual(['a2']);
-    });
-});
-describe('createRowDrag - disabled', () => {
-    it('is inert when rowDragManaged is off', () => {
-        const ctx = makeCtx([{ id: 1, title: 'a' }, { id: 2, title: 'b' }], {});
-        const h = createRowDrag(ctx);
-        h.onRowDragStart(fakeEvent(), 0);
-        ctx.rowDropSide = 'after';
-        h.onRowDrop(fakeEvent(), 1);
-        expect(ctx.internalData.map((r) => r.title)).toEqual(['a', 'b']);
-    });
-});
-describe('rowDropZone (external drop target)', () => {
-    function dropOn(el) {
-        const ev = new Event('drop', { bubbles: true, cancelable: true });
-        el.dispatchEvent(ev);
-    }
-    it('removes the dragged row from its source grid and calls onDrop', () => {
-        const a = makeCtx([{ id: 1, title: 'a1' }, { id: 2, title: 'a2' }], { ...P, rowDragGroup: 'g' });
-        const ha = createRowDrag(a);
-        ha.onRowDragStart(fakeEvent(), 0); // start dragging "a1"
-        const el = document.createElement('div');
-        const dropped = [];
-        const action = rowDropZone(el, { group: 'g', onDrop: (e) => dropped.push(e) });
-        dropOn(el);
-        expect(dropped.length).toBe(1);
-        expect(dropped[0].row.title).toBe('a1');
-        expect(a.internalData.map((r) => r.title)).toEqual(['a2']); // removed from source
-        action.destroy();
-    });
-    it('ignores drops when the group does not match', () => {
-        const a = makeCtx([{ id: 1, title: 'a1' }], { ...P, rowDragGroup: 'g' });
-        const ha = createRowDrag(a);
-        ha.onRowDragStart(fakeEvent(), 0);
-        const el = document.createElement('div');
-        const dropped = [];
-        const action = rowDropZone(el, { group: 'other', onDrop: (e) => dropped.push(e) });
-        dropOn(el);
-        expect(dropped.length).toBe(0);
-        expect(a.internalData.length).toBe(1); // untouched
-        action.destroy();
-    });
-});

package/dist/row-resize.test.d.ts

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