@happyvertical/smrt-ui 0.42.3 → 0.42.4

package/dist/components/data/DataTableIdentity.js

@@ -0,0 +1,28 @@
+import { assertDataTableRowId, dataTableRowIdKey, } from './DataTableController.js';
+function readRowKey(row, rowKey) {
+    return typeof rowKey === 'function'
+        ? rowKey(row)
+        : row[rowKey];
+}
+/**
+ * Resolve the renderer's source rows once and fail closed for missing or
+ * duplicate durable identities. The index fallback only exists for
+ * presentational local tables that have no durable row state.
+ */
+export function resolveDataTableRows(rows, rowKey, options = {}) {
+    if (options.requireStableIdentity && !rowKey) {
+        throw new TypeError('DataTable rowKey is required for selectable, expandable, manual, or agent-addressable tables');
+    }
+    const seen = new Set();
+    return rows.map((row, sourceIndex) => {
+        const rowId = rowKey
+            ? assertDataTableRowId(readRowKey(row, rowKey))
+            : sourceIndex;
+        const key = dataTableRowIdKey(rowId);
+        if (seen.has(key)) {
+            throw new TypeError(`DataTable rowKey must resolve to unique row ids; duplicate ${key}`);
+        }
+        seen.add(key);
+        return { row, sourceIndex, rowId };
+    });
+}

package/dist/components/data/__tests__/DataTable.test.js

@@ -5,19 +5,20 @@
  * headers, cells, row count), the empty state, sortable-header interaction
  * (aria-sort transition), and axe-cleanliness.
  */
-import { render, screen } from '@testing-library/svelte';
+import { render, screen, within } from '@testing-library/svelte';
 import userEvent from '@testing-library/user-event';
 import { createRawSnippet } from 'svelte';
 import { describe, expect, it, vi } from 'vitest';
 import { expectNoA11yViolations } from '../../../test-support/a11y';
 import DataTable from '../DataTable.svelte';
+import { createDataTableController, transitionDataTableState, } from '../DataTableController.js';
 const columns = [
     { id: 'name', label: 'Name', accessor: 'name', sortable: true },
     { id: 'age', label: 'Age', accessor: 'age' },
 ];
 const data = [
-    { name: 'Ada', age: 36 },
-    { name: 'Linus', age: 54 },
+    { id: 'ada', name: 'Ada', age: 36 },
+    { id: 'linus', name: 'Linus', age: 54 },
 ];
 describe('DataTable', () => {
     it('renders caption, headers, cells, and a row per datum', () => {
@@ -40,10 +41,40 @@ describe('DataTable', () => {
         await userEvent.click(screen.getByRole('button', { name: 'Name' }));
         expect(nameHeader).toHaveAttribute('aria-sort', 'ascending');
     });
+    it('routes a human sort click through the same controller transition as a command', async () => {
+        const controller = createDataTableController({
+            columnIds: columns.map((column) => column.id),
+        });
+        const before = controller.getState();
+        render(DataTable, { props: { data, columns, sortable: true, controller } });
+        await userEvent.click(screen.getByRole('button', { name: 'Name' }));
+        expect(controller.getState()).toEqual(transitionDataTableState(before, {
+            type: 'toggleSorting',
+            columnId: 'name',
+            multi: false,
+        }));
+    });
+    it('waits for a controlled controller host before rendering a proposed interaction', async () => {
+        const initialState = createDataTableController({
+            columnIds: columns.map((column) => column.id),
+        }).getState();
+        const onStateChange = vi.fn();
+        const controller = createDataTableController({
+            state: initialState,
+            columnIds: columns.map((column) => column.id),
+            onStateChange,
+        });
+        render(DataTable, { props: { data, columns, sortable: true, controller } });
+        const nameHeader = screen.getByRole('columnheader', { name: 'Name' });
+        await userEvent.click(screen.getByRole('button', { name: 'Name' }));
+        expect(nameHeader).not.toHaveAttribute('aria-sort');
+        controller.replaceState(onStateChange.mock.calls[0][0]);
+        await vi.waitFor(() => expect(nameHeader).toHaveAttribute('aria-sort', 'ascending'));
+    });
     it('filters and paginates client-side rows', async () => {
         render(DataTable, {
             props: {
-                data: [...data, { name: 'Grace', age: 85 }],
+                data: [...data, { id: 'grace', name: 'Grace', age: 85 }],
                 columns,
                 filterFn: (person) => person.age > 40,
                 pageSize: 1,
@@ -54,43 +85,216 @@ describe('DataTable', () => {
         await userEvent.click(screen.getByRole('button', { name: 'Next page' }));
         expect(screen.getByRole('cell', { name: 'Grace' })).toBeInTheDocument();
     });
-    it('keeps fallback selection keys unique across pages', async () => {
+    it('ignores local filters targeting a non-filterable column', () => {
+        const controller = createDataTableController({
+            columnIds: columns.map((column) => column.id),
+            initialState: {
+                filters: [{ columnId: 'age', operator: 'gte', value: 40 }],
+            },
+        });
+        render(DataTable, {
+            props: {
+                data,
+                columns: [columns[0], { ...columns[1], filterable: false }],
+                controller,
+            },
+        });
+        expect(screen.getByRole('cell', { name: 'Ada' })).toBeInTheDocument();
+        expect(screen.getByRole('cell', { name: 'Linus' })).toBeInTheDocument();
+    });
+    it('clamps a controller page changed after mount against the current total', async () => {
+        const controller = createDataTableController({
+            columnIds: columns.map((column) => column.id),
+            initialState: { page: 1, pageSize: 1 },
+        });
+        render(DataTable, { props: { data, columns, controller } });
+        controller.replaceState({ ...controller.getState(), page: 4 });
+        await vi.waitFor(() => expect(controller.getState().page).toBe(2));
+        expect(screen.getByRole('cell', { name: 'Linus' })).toBeInTheDocument();
+    });
+    it.each([
+        [
+            'local/local/local',
+            { filtering: 'local', sorting: 'local', pagination: 'local' },
+            ['Grace'],
+        ],
+        [
+            'local/local/manual',
+            { filtering: 'local', sorting: 'local', pagination: 'manual' },
+            ['Grace', 'Linus'],
+        ],
+        [
+            'local/manual/local',
+            { filtering: 'local', sorting: 'manual', pagination: 'local' },
+            ['Linus'],
+        ],
+        [
+            'local/manual/manual',
+            { filtering: 'local', sorting: 'manual', pagination: 'manual' },
+            ['Linus', 'Grace'],
+        ],
+        [
+            'manual/local/local',
+            { filtering: 'manual', sorting: 'local', pagination: 'local' },
+            ['Grace'],
+        ],
+        [
+            'manual/local/manual',
+            { filtering: 'manual', sorting: 'local', pagination: 'manual' },
+            ['Grace', 'Linus', 'Ada'],
+        ],
+        [
+            'manual/manual/local',
+            { filtering: 'manual', sorting: 'manual', pagination: 'local' },
+            ['Ada'],
+        ],
+        [
+            'manual/manual/manual',
+            { filtering: 'manual', sorting: 'manual', pagination: 'manual' },
+            ['Ada', 'Linus', 'Grace'],
+        ],
+    ])('applies each local/manual mode combination exactly once (%s)', (_name, modes, expected) => {
+        const controller = createDataTableController({
+            modes,
+            initialState: {
+                filters: [{ columnId: 'age', operator: 'gte', value: 40 }],
+                sorting: [{ columnId: 'age', direction: 'desc' }],
+                page: 1,
+                pageSize: 1,
+            },
+            columnIds: columns.map((column) => column.id),
+        });
+        render(DataTable, {
+            props: {
+                data: [...data, { id: 'grace', name: 'Grace', age: 85 }],
+                columns,
+                controller,
+                rowKey: 'id',
+            },
+        });
+        const names = screen
+            .getAllByRole('row')
+            .slice(1)
+            .map((row) => within(row).getAllByRole('cell')[0].textContent);
+        expect(names).toEqual(expected);
+    });
+    it('keeps stable selection IDs across pages and labels the page scope', async () => {
         const onSelectionChange = vi.fn();
         render(DataTable, {
             props: {
                 data,
                 columns,
                 pageSize: 1,
+                rowKey: 'id',
                 selectable: true,
                 onSelectionChange,
             },
         });
-        await userEvent.click(screen.getByRole('checkbox', { name: 'Select all rows' }));
+        await userEvent.click(screen.getByRole('checkbox', { name: 'Select all rows on this page' }));
         await userEvent.click(screen.getByRole('button', { name: 'Next page' }));
-        await userEvent.click(screen.getByRole('checkbox', { name: 'Select all rows' }));
-        expect(onSelectionChange).toHaveBeenLastCalledWith(new Set([0, 1]));
+        await userEvent.click(screen.getByRole('checkbox', { name: 'Select all rows on this page' }));
+        expect(onSelectionChange).toHaveBeenLastCalledWith(new Set(['ada', 'linus']));
     });
-    it('does not carry fallback expansion keys onto the next page', async () => {
-        render(DataTable, {
+    it('honors legacy selected bindings during controller reconciliation', async () => {
+        const props = {
+            data,
+            columns,
+            rowKey: 'id',
+            selectable: true,
+            selected: new Set(['ada']),
+        };
+        const { rerender } = render(DataTable, { props });
+        const expectSelected = (name) => {
+            expect(screen.getByRole('cell', { name }).closest('tr')).toHaveClass('data-table__row--selected');
+        };
+        await vi.waitFor(() => expectSelected('Ada'));
+        await rerender({ ...props, selected: new Set(['linus']) });
+        await vi.waitFor(() => {
+            expectSelected('Linus');
+            expect(screen.getByRole('cell', { name: 'Ada' }).closest('tr')).not.toHaveClass('data-table__row--selected');
+        });
+    });
+    it('keeps stable selection and expansion through sort, filter, and data refresh', async () => {
+        const controller = createDataTableController({
+            columnIds: columns.map((column) => column.id),
+        });
+        const expandedContent = createRawSnippet(() => ({
+            render: () => '<p>Row detail</p>',
+        }));
+        const props = {
+            data,
+            columns,
+            rowKey: 'id',
+            selectable: true,
+            expandedContent,
+            controller,
+        };
+        const { rerender } = render(DataTable, { props });
+        const expectAdaSelectionAndExpansion = () => {
+            const adaRow = screen.getByRole('cell', { name: 'Ada' }).closest('tr');
+            expect(adaRow).toHaveClass('data-table__row--selected');
+            expect(adaRow?.nextElementSibling).toHaveTextContent('Row detail');
+        };
+        const visibleNames = () => screen
+            .getAllByRole('row')
+            .slice(1)
+            .filter((row) => !row.classList.contains('data-table__row--expanded'))
+            .map((row) => within(row)
+            .getAllByRole('cell')
+            .find((cell) => ['Ada', 'Linus'].includes(cell.textContent ?? ''))
+            ?.textContent)
+            .filter((name) => name !== undefined);
+        await userEvent.click(screen.getAllByRole('checkbox', { name: 'Select row' })[0]);
+        await userEvent.click(screen.getAllByRole('button', { name: 'Expand row' })[0]);
+        expectAdaSelectionAndExpansion();
+        controller.dispatch({
+            type: 'setSorting',
+            sorting: [{ columnId: 'age', direction: 'desc' }],
+        });
+        await vi.waitFor(() => {
+            expect(visibleNames()).toEqual(['Linus', 'Ada']);
+            expectAdaSelectionAndExpansion();
+        });
+        controller.dispatch({ type: 'setSearch', search: 'Ada' });
+        await vi.waitFor(() => {
+            expect(screen.queryByRole('cell', { name: 'Linus' })).not.toBeInTheDocument();
+            expectAdaSelectionAndExpansion();
+        });
+        controller.dispatch({ type: 'setSearch', search: '' });
+        await rerender({
+            ...props,
+            data: [
+                { id: 'linus', name: 'Linus', age: 10 },
+                { id: 'ada', name: 'Ada', age: 90 },
+            ],
+        });
+        await vi.waitFor(() => {
+            expect(visibleNames()).toEqual(['Ada', 'Linus']);
+            expectAdaSelectionAndExpansion();
+        });
+    });
+    it('fails closed when durable selection, expansion, manual, or agent modes lack a rowKey', () => {
+        expect(() => render(DataTable, { props: { data, columns, selectable: true } })).toThrow(/rowKey is required/);
+        expect(() => render(DataTable, {
             props: {
                 data,
                 columns,
-                pageSize: 1,
-                expandedContent: createRawSnippet(() => ({
-                    render: () => '<p>Row detail</p>',
-                })),
+                expandedContent: createRawSnippet(() => ({ render: () => '' })),
             },
-        });
-        await userEvent.click(screen.getByRole('button', { name: 'Expand row' }));
-        await userEvent.click(screen.getByRole('button', { name: 'Next page' }));
-        expect(screen.queryByText('Row detail')).not.toBeInTheDocument();
-        expect(screen.getByRole('button', { name: 'Expand row' })).toBeInTheDocument();
+        })).toThrow(/rowKey is required/);
+        expect(() => render(DataTable, {
+            props: { data, columns, agentAddressable: true },
+        })).toThrow(/rowKey is required/);
+        expect(() => render(DataTable, {
+            props: { data, columns, modes: { pagination: 'manual' } },
+        })).toThrow(/rowKey is required/);
     });
     it('reveals expandable row content', async () => {
         render(DataTable, {
             props: {
                 data,
                 columns,
+                rowKey: 'id',
                 expandedContent: createRawSnippet(() => ({
                     render: () => '<p>Row detail</p>',
                 })),
@@ -99,6 +303,40 @@ describe('DataTable', () => {
         await userEvent.click(screen.getAllByRole('button', { name: 'Expand row' })[0]);
         expect(screen.getByText('Row detail')).toBeInTheDocument();
     });
+    it('rejects duplicate stable row keys and local totals that imply server paging', () => {
+        expect(() => render(DataTable, {
+            props: {
+                data: [data[0], { ...data[1], id: 'ada' }],
+                columns,
+                rowKey: 'id',
+            },
+        })).toThrow(/unique row ids/);
+        expect(() => render(DataTable, {
+            props: { data, columns, rowKey: 'id', totalRows: 10 },
+        })).toThrow(/only valid when pagination mode is manual/);
+    });
+    it('uses stable row IDs as the final local sort tie-breaker', () => {
+        const controller = createDataTableController({
+            columnIds: columns.map((column) => column.id),
+            initialState: { sorting: [{ columnId: 'age', direction: 'asc' }] },
+        });
+        render(DataTable, {
+            props: {
+                data: [
+                    { id: 'z', name: 'Zed', age: 36 },
+                    { id: 'a', name: 'Ada', age: 36 },
+                ],
+                columns,
+                rowKey: 'id',
+                controller,
+            },
+        });
+        const names = screen
+            .getAllByRole('row')
+            .slice(1)
+            .map((row) => within(row).getAllByRole('cell')[0].textContent);
+        expect(names).toEqual(['Ada', 'Zed']);
+    });
     it('is axe-clean', async () => {
         const { container } = render(DataTable, {
             props: { data, columns, caption: 'People' },

package/dist/components/data/__tests__/DataTableController.test.js

@@ -0,0 +1,214 @@
+import { describe, expect, it, vi } from 'vitest';
+import { assertDataTableSelectionCurrent, createDataTableController, hydrateDataTableSnapshot, transitionDataTableState, } from '../DataTableController.js';
+const state = {
+    search: '',
+    filters: [],
+    sorting: [],
+    page: 3,
+    pageSize: 10,
+    columnOrder: ['name', 'age'],
+    columnVisibility: [
+        { columnId: 'age', visible: true },
+        { columnId: 'name', visible: true },
+    ],
+    selection: { scope: 'explicit', rowIds: [] },
+    selectedRowIds: [],
+    expandedRowIds: [],
+};
+describe('DataTableController', () => {
+    it('uses canonical JSON-safe snapshots regardless of insertion order', () => {
+        const first = createDataTableController({
+            initialState: {
+                ...state,
+                filters: [
+                    {
+                        columnId: 'age',
+                        operator: 'gte',
+                        value: { minimum: 18, maximum: 65 },
+                    },
+                    { columnId: 'name', operator: 'contains', value: 'a' },
+                ],
+                selectedRowIds: ['2', 1, '1', 2],
+                expandedRowIds: [3, '3', 1],
+            },
+        });
+        const second = createDataTableController({
+            initialState: {
+                ...state,
+                filters: [
+                    { columnId: 'name', operator: 'contains', value: 'a' },
+                    {
+                        columnId: 'age',
+                        operator: 'gte',
+                        value: { maximum: 65, minimum: 18 },
+                    },
+                ],
+                selectedRowIds: [2, '1', 1, '2'],
+                expandedRowIds: [1, '3', 3],
+            },
+        });
+        expect(JSON.stringify(first.snapshot())).toBe(JSON.stringify(second.snapshot()));
+        expect(JSON.parse(JSON.stringify(first.snapshot()))).toEqual(first.snapshot());
+    });
+    it('omits ignored null-check filter values from canonical snapshots', () => {
+        const withoutValue = createDataTableController({
+            initialState: {
+                ...state,
+                filters: [{ columnId: 'name', operator: 'isNull' }],
+            },
+        });
+        const withIgnoredValue = createDataTableController({
+            initialState: {
+                ...state,
+                filters: [
+                    {
+                        columnId: 'name',
+                        operator: 'isNull',
+                        value: undefined,
+                    },
+                ],
+            },
+        });
+        expect(withIgnoredValue.snapshot()).toEqual(withoutValue.snapshot());
+    });
+    it('resets page only when a query-shape value changes and clamps reliable totals', () => {
+        const controller = createDataTableController({ initialState: state });
+        expect(controller.dispatch({ type: 'setSearch', search: '' }).changed).toBe(false);
+        expect(controller.snapshot().state.page).toBe(3);
+        controller.dispatch({ type: 'setSearch', search: 'ada' });
+        expect(controller.snapshot().state.page).toBe(1);
+        controller.replaceState({ ...controller.getState(), page: 4 });
+        controller.dispatch({ type: 'setColumnOrder', columnIds: ['age', 'name'] });
+        expect(controller.snapshot().state.page).toBe(4);
+        controller.clampPage(11);
+        expect(controller.snapshot().state.page).toBe(2);
+        controller.clampPage(0);
+        expect(controller.snapshot().state.page).toBe(1);
+        expect(() => controller.clampPage(1.5)).toThrow(/totalRows/);
+    });
+    it('keeps multi-sort priority while cycling a column through asc, desc, and clear', () => {
+        const controller = createDataTableController({ initialState: state });
+        controller.dispatch({ type: 'toggleSorting', columnId: 'name' });
+        controller.dispatch({
+            type: 'toggleSorting',
+            columnId: 'age',
+            multi: true,
+        });
+        expect(controller.snapshot().state.sorting).toEqual([
+            { columnId: 'name', direction: 'asc' },
+            { columnId: 'age', direction: 'asc' },
+        ]);
+        controller.dispatch({
+            type: 'toggleSorting',
+            columnId: 'name',
+            multi: true,
+        });
+        expect(controller.snapshot().state.sorting).toEqual([
+            { columnId: 'name', direction: 'desc' },
+            { columnId: 'age', direction: 'asc' },
+        ]);
+        controller.dispatch({
+            type: 'toggleSorting',
+            columnId: 'name',
+            multi: true,
+        });
+        expect(controller.snapshot().state.sorting).toEqual([
+            { columnId: 'age', direction: 'asc' },
+        ]);
+    });
+    it('proposes controlled transitions without mutating until the host reconciles state', () => {
+        const onStateChange = vi.fn();
+        const controller = createDataTableController({ state, onStateChange });
+        const transition = controller.dispatch({ type: 'setPage', page: 2 });
+        expect(transition.next.state.page).toBe(2);
+        expect(controller.snapshot().state.page).toBe(3);
+        expect(onStateChange).toHaveBeenCalledWith(expect.objectContaining({ page: 2 }), { type: 'setPage', page: 2 });
+        controller.replaceState(transition.next.state);
+        expect(controller.snapshot().state.page).toBe(2);
+    });
+    it('notifies subscribers with defensive selection and expansion snapshots', () => {
+        const controller = createDataTableController({ initialState: state });
+        const listener = vi.fn();
+        const unsubscribe = controller.subscribe(listener);
+        controller.dispatch({ type: 'toggleRowSelection', rowId: 'row-1' });
+        controller.dispatch({ type: 'toggleRowExpansion', rowId: 2 });
+        expect(listener).toHaveBeenCalledTimes(2);
+        expect(listener.mock.calls[1][0].next.state).toMatchObject({
+            selectedRowIds: ['row-1'],
+            expandedRowIds: [2],
+        });
+        listener.mock.calls[1][0].next.state.selectedRowIds.push('mutated');
+        expect(controller.snapshot().state.selectedRowIds).toEqual(['row-1']);
+        unsubscribe();
+        controller.dispatch({ type: 'setSearch', search: 'Ada' });
+        expect(listener).toHaveBeenCalledTimes(2);
+    });
+    it('defensively copies state and validates persisted snapshots', () => {
+        const controller = createDataTableController({ initialState: state });
+        const snapshot = controller.snapshot();
+        snapshot.state.selectedRowIds.push('unexpected');
+        expect(controller.snapshot().state.selectedRowIds).toEqual([]);
+        expect(hydrateDataTableSnapshot(JSON.parse(JSON.stringify(controller.snapshot())))).toEqual(controller.snapshot());
+        const { selection: _selection, ...legacyState } = state;
+        expect(hydrateDataTableSnapshot({
+            version: 1,
+            modes: controller.getModes(),
+            state: legacyState,
+        })).toMatchObject({
+            version: 2,
+            state: { selection: { scope: 'explicit', rowIds: [] } },
+        });
+        expect(() => hydrateDataTableSnapshot({ version: 3 })).toThrow(/version/);
+        expect(() => transitionDataTableState(state, { type: 'setPageSize', pageSize: 0 })).toThrow(/pageSize/);
+        for (const page of [0, -1, 1.5]) {
+            expect(() => transitionDataTableState(state, { type: 'setPage', page })).toThrow(/page/);
+        }
+    });
+    it('models current-page and explicit row selections separately', () => {
+        const controller = createDataTableController({ initialState: state });
+        controller.dispatch({
+            type: 'setPageSelection',
+            rowIds: ['row-2', 'row-1'],
+        });
+        expect(controller.getState().selection).toEqual({
+            scope: 'page',
+            rowIds: ['row-1', 'row-2'],
+        });
+        controller.dispatch({ type: 'setPage', page: 4 });
+        expect(controller.getState().selection).toEqual({
+            scope: 'page',
+            rowIds: [],
+        });
+        controller.dispatch({ type: 'setSelectedRows', rowIds: ['row-2'] });
+        controller.dispatch({ type: 'setPage', page: 5 });
+        expect(controller.getState().selection).toEqual({
+            scope: 'explicit',
+            rowIds: ['row-2'],
+        });
+    });
+    it('binds all-matching selection to an exact query revision and invalidates it on query changes', () => {
+        const controller = createDataTableController({ initialState: state });
+        controller.dispatch({
+            type: 'selectAllMatching',
+            queryFingerprint: 'dq1_example',
+            queryRevision: 'revision-7',
+            expectedCount: 42,
+        });
+        expect(controller.getState().selection).toEqual({
+            scope: 'allMatching',
+            queryFingerprint: 'dq1_example',
+            queryRevision: 'revision-7',
+            expectedCount: 42,
+        });
+        expect(controller.getState().selectedRowIds).toEqual([]);
+        expect(() => assertDataTableSelectionCurrent(controller.getState().selection, {
+            queryFingerprint: 'dq1_example',
+            queryRevision: 'revision-8',
+        })).toThrow(/stale/);
+        controller.dispatch({ type: 'setSearch', search: 'Ada' });
+        expect(controller.getState().selection).toEqual({
+            scope: 'explicit',
+            rowIds: [],
+        });
+    });
+});

package/dist/components/data/__tests__/DataTableIdentity.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { resolveDataTableRows } from '../DataTableIdentity.js';
+const rows = [
+    { id: 'ada', name: 'Ada' },
+    { id: 'linus', name: 'Linus' },
+];
+describe('resolveDataTableRows', () => {
+    it('uses stable canonical IDs and preserves source indexes', () => {
+        expect(resolveDataTableRows(rows, 'id', { requireStableIdentity: true })).toEqual([
+            { row: rows[0], sourceIndex: 0, rowId: 'ada' },
+            { row: rows[1], sourceIndex: 1, rowId: 'linus' },
+        ]);
+    });
+    it('keeps the index fallback only for presentational local tables', () => {
+        expect(resolveDataTableRows(rows, undefined)).toEqual([
+            { row: rows[0], sourceIndex: 0, rowId: 0 },
+            { row: rows[1], sourceIndex: 1, rowId: 1 },
+        ]);
+        expect(() => resolveDataTableRows(rows, undefined, { requireStableIdentity: true })).toThrow(/rowKey is required/);
+    });
+    it('rejects duplicate, empty, and non-finite stable row IDs', () => {
+        expect(() => resolveDataTableRows([
+            { id: 'same', name: 'Ada' },
+            { id: 'same', name: 'Linus' },
+        ], 'id')).toThrow(/unique/);
+        expect(() => resolveDataTableRows([{ id: '', name: 'Ada' }], 'id')).toThrow(/non-empty/);
+        expect(() => resolveDataTableRows([{ id: Number.NaN, name: 'Ada' }], (row) => row.id)).toThrow(/finite/);
+    });
+});

package/dist/components/data/index.d.ts

@@ -4,5 +4,7 @@
 export { default as CollectionList, default as ContentList, } from './CollectionList.svelte';
 export { default as CollectionToolbar } from './CollectionToolbar.svelte';
 export { default as DataTable } from './DataTable.svelte';
+export * from './DataTableController.js';
+export * from './DataTableIdentity.js';
 export * from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/data/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/data/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,OAAO,IAAI,cAAc,EACzB,OAAO,IAAI,WAAW,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC1D,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/data/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,OAAO,IAAI,cAAc,EACzB,OAAO,IAAI,WAAW,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC1D,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,YAAY,CAAC"}

package/dist/components/data/index.js

@@ -4,4 +4,6 @@
 export { default as CollectionList, default as ContentList, } from './CollectionList.svelte';
 export { default as CollectionToolbar } from './CollectionToolbar.svelte';
 export { default as DataTable } from './DataTable.svelte';
+export * from './DataTableController.js';
+export * from './DataTableIdentity.js';
 export * from './types.js';