@jmruthers/pace-core 0.5.189 → 0.5.190

package/src/components/DataTable/components/__tests__/DataTableToolbar.test.tsx

@@ -0,0 +1,157 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DataTableToolbar } from '../DataTableToolbar';
+import type { DataTableFeatureConfig } from '../../types';
+
+vi.mock('../GroupingDropdown', () => ({
+  GroupingDropdown: ({ onGroupByChange }: any) => (
+    <button onClick={() => onGroupByChange('grouped')} data-testid="grouping-dropdown">
+      Grouping Dropdown
+    </button>
+  ),
+}));
+
+vi.mock('../ColumnVisibilityDropdown', () => ({
+  ColumnVisibilityDropdown: ({ onColumnVisibilityChange }: any) => (
+    <button
+      onClick={() => onColumnVisibilityChange('column-id', true)}
+      data-testid="column-visibility-dropdown"
+    >
+      Column Visibility Dropdown
+    </button>
+  ),
+}));
+
+vi.mock('../../Button/Button', () => ({
+  Button: ({ children, onClick, variant, ...rest }: any) => (
+    <button onClick={onClick} data-variant={variant} {...rest}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('../../Input/Input', () => ({
+  Input: ({ value, onChange, placeholder, ...rest }: any) => (
+    <input value={value} onChange={onChange} placeholder={placeholder} {...rest} />
+  ),
+}));
+
+describe('[component] DataTableToolbar', () => {
+  const baseFeatures: DataTableFeatureConfig = {
+    search: true,
+    grouping: true,
+    columnVisibility: true,
+    filtering: true,
+    creation: true,
+    import: true,
+    export: true,
+    selection: true,
+    deletion: true,
+    deleteSelected: true,
+  };
+
+  const permissions = {
+    canCreate: { can: true, isLoading: false },
+    canImport: { can: true, isLoading: false },
+    canExport: { can: true, isLoading: false },
+    canDelete: { can: true, isLoading: false },
+  };
+
+  const commonProps = {
+    features: baseFeatures,
+    rbac: { pageId: 'test-page' },
+    permissions,
+    globalFilter: '',
+    onGlobalFilterChange: vi.fn(),
+    columns: [
+      { id: 'name', header: 'Name' },
+      { id: 'role', header: 'Role' },
+    ],
+    grouping: [],
+    onGroupByChange: vi.fn(),
+    tableColumns: [
+      {
+        id: 'name',
+        columnDef: { header: 'Name' },
+        getCanHide: () => true,
+        getIsVisible: () => true,
+      },
+    ] as any,
+    onColumnVisibilityChange: vi.fn(),
+    rowSelection: {},
+    onCreateRow: vi.fn(),
+    onImportClick: vi.fn(),
+    onExport: vi.fn(),
+    onDeleteSelected: vi.fn(),
+    onToggleFilterRow: vi.fn(),
+    showFilterRow: false,
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders search input and passes global filter changes', async () => {
+    const onGlobalFilterChange = vi.fn();
+
+    render(<DataTableToolbar {...commonProps} onGlobalFilterChange={onGlobalFilterChange} />);
+
+    const searchInput = screen.getByPlaceholderText('Search...');
+    await userEvent.type(searchInput, 'alpha');
+
+    const calls = onGlobalFilterChange.mock.calls.map((call) => call[0]);
+    expect(calls).toEqual(['a', 'l', 'p', 'h', 'a']);
+  });
+
+  it('shows feature controls and triggers handlers with permissions', async () => {
+    const onDeleteSelected = vi.fn();
+    const props = {
+      ...commonProps,
+      rowSelection: { row1: true },
+      onDeleteSelected,
+      showFilterRow: true,
+    };
+
+    render(<DataTableToolbar {...props} />);
+
+    await userEvent.click(screen.getByText('Grouping Dropdown'));
+    expect(props.onGroupByChange).toHaveBeenCalledWith('grouped');
+
+    await userEvent.click(screen.getByText('Column Visibility Dropdown'));
+    expect(props.onColumnVisibilityChange).toHaveBeenCalledWith('column-id', true);
+
+    await userEvent.click(screen.getByText('Hide Filters'));
+    expect(props.onToggleFilterRow).toHaveBeenCalled();
+
+    await userEvent.click(screen.getByText('Add Row'));
+    expect(props.onCreateRow).toHaveBeenCalled();
+
+    await userEvent.click(screen.getByText('Import'));
+    expect(props.onImportClick).toHaveBeenCalled();
+
+    await userEvent.click(screen.getByText('Export'));
+    expect(props.onExport).toHaveBeenCalled();
+
+    await userEvent.click(screen.getByText('Delete'));
+    expect(onDeleteSelected).toHaveBeenCalledWith({ row1: true });
+  });
+
+  it('respects permission gates for creation and deletion', () => {
+    const props = {
+      ...commonProps,
+      permissions: {
+        ...permissions,
+        canCreate: { can: false, isLoading: false },
+        canDelete: { can: false, isLoading: false },
+      },
+      rowSelection: { row1: true },
+    };
+
+    render(<DataTableToolbar {...props} />);
+
+    expect(screen.queryByText('Add Row')).not.toBeInTheDocument();
+    expect(screen.queryByText('Delete')).not.toBeInTheDocument();
+  });
+});

package/src/components/DataTable/components/__tests__/LoadingState.test.tsx

@@ -114,7 +114,8 @@ describe('[component] LoadingState', () => {
       render(<LoadingState />);
 
       const spinner = screen.getByText('Loading...').previousElementSibling;
-      expect(spinner).toHaveClass('h-6', 'w-6');
+      // LoadingState spinner uses Tailwind v4 size-* utility instead of h-* w-*
+      expect(spinner).toHaveClass('size-6');
     });
   });
 });

package/src/components/DataTable/components/__tests__/VirtualizedDataTable.test.tsx

@@ -0,0 +1,128 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { useReactTable, getCoreRowModel, type ColumnDef } from '@tanstack/react-table';
+import { VirtualizedDataTable, EnhancedVirtualizedDataTable } from '../VirtualizedDataTable';
+import type { DataRecord } from '../../types';
+
+const virtualItems = [{ index: 0, key: '0', start: 0, size: 40 }];
+
+vi.mock('@tanstack/react-virtual', () => ({
+  useVirtualizer: vi.fn(() => ({
+    getVirtualItems: () => virtualItems,
+    getTotalSize: () => 40,
+  })),
+}));
+
+describe('[component] VirtualizedDataTable', () => {
+  type Row = DataRecord & { id: string; name: string };
+
+  const columns: ColumnDef<Row>[] = [
+    {
+      accessorKey: 'name',
+      header: 'Name',
+      cell: (info) => <span>{info.getValue() as string}</span>,
+    },
+  ];
+
+  const createTable = (data: Row[]) =>
+    renderHook(() =>
+      useReactTable({
+        data,
+        columns,
+        getCoreRowModel: getCoreRowModel(),
+      })
+    ).result.current;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders headers and cells when data is available', () => {
+    const table = createTable([{ id: '1', name: 'Alice' }]);
+
+    render(<VirtualizedDataTable table={table} height={200} />);
+
+    expect(screen.getByText('Name')).toBeInTheDocument();
+    expect(screen.getByText('Alice')).toBeInTheDocument();
+    expect(screen.getByText(/Showing 1 to 1 of 1 rows/)).toBeInTheDocument();
+  });
+
+  it('renders an empty state when no rows are present', () => {
+    const table = createTable([]);
+
+    render(<VirtualizedDataTable table={table} />);
+
+    expect(screen.getByText('No data available')).toBeInTheDocument();
+    expect(screen.getByText('Name')).toBeInTheDocument();
+  });
+
+  it('reports visible range changes', async () => {
+    const table = createTable([{ id: '1', name: 'Alice' }, { id: '2', name: 'Bob' }]);
+    const onVisibilityChange = vi.fn();
+
+    render(
+      <VirtualizedDataTable
+        table={table}
+        onVisibilityChange={onVisibilityChange}
+      />
+    );
+
+    await waitFor(() => {
+      expect(onVisibilityChange).toHaveBeenCalledWith({ start: 0, end: 0 });
+    });
+  });
+});
+
+describe('[component] EnhancedVirtualizedDataTable', () => {
+  type Row = DataRecord & { id: string; name: string };
+
+  const columns: ColumnDef<Row>[] = [
+    {
+      accessorKey: 'name',
+      header: 'Name',
+      cell: (info) => <span>{info.getValue() as string}</span>,
+    },
+  ];
+
+  const createTable = (data: Row[]) =>
+    renderHook(() =>
+      useReactTable({
+        data,
+        columns,
+        getCoreRowModel: getCoreRowModel(),
+      })
+    ).result.current;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('shows loading placeholder rows when loading', () => {
+    const table = createTable([{ id: '1', name: 'Alice' }]);
+
+    render(
+      <EnhancedVirtualizedDataTable
+        table={table}
+        isLoading
+        loadingRows={2}
+      />
+    );
+
+    expect(screen.getByText('Loading...')).toBeInTheDocument();
+  });
+
+  it('renders custom empty message when no data is available and not loading', () => {
+    const table = createTable([]);
+
+    render(
+      <EnhancedVirtualizedDataTable
+        table={table}
+        emptyMessage="Nothing here"
+      />
+    );
+
+    expect(screen.getByText('Nothing here')).toBeInTheDocument();
+  });
+});

package/src/components/DataTable/core/__tests__/ActionManager.test.ts

@@ -101,4 +101,23 @@ describe('ActionManagerImpl', () => {
     expect(manager.isActionDisabled('disabled', { id: '1', status: 'draft' })).toBe(true);
     expect(manager.isActionDisabled('unknown', { id: '1', status: 'draft' })).toBe(true);
   });
+
+  it('filters actions by variant and resets state through setter helpers', () => {
+    const actions = [
+      buildAction({ testId: 'primary', variant: 'default', label: 'Primary' }),
+      buildAction({ testId: 'secondary', variant: 'secondary', label: 'Secondary' }),
+      buildAction({ testId: 'danger', variant: 'destructive', label: 'Danger' }),
+    ];
+
+    const manager = new ActionManagerImpl<TestRecord>(actions);
+    expect(manager.getPrimaryActions().map(action => action.testId)).toEqual(['primary']);
+    expect(manager.getSecondaryActions().map(action => action.testId)).toEqual(['secondary']);
+    expect(manager.getDestructiveActions().map(action => action.testId)).toEqual(['danger']);
+
+    manager.clearActions();
+    expect(manager.getActionCount()).toBe(0);
+
+    manager.setActions(actions.slice(0, 2));
+    expect(manager.getActionIds()).toEqual(['primary', 'secondary']);
+  });
 });

package/src/components/DataTable/core/__tests__/ColumnFactory.test.ts

@@ -115,6 +115,21 @@ describe('ColumnFactory', () => {
       expect(column.meta?.align).toBe('right');
       expect(column.meta?.type).toBe('number');
     });
+
+    it('formats numeric values and falls back to locale strings', () => {
+      const formatted = ColumnFactory.createNumberColumn<TestDataRecord>('age', {
+        format: value => `#${value}`,
+      });
+      const formattedResult = formatted.cell?.({ getValue: () => 42 } as any);
+      expect(formattedResult).toBe('#42');
+
+      const defaultFormatted = ColumnFactory.createNumberColumn<TestDataRecord>('age');
+      const defaultResult = defaultFormatted.cell?.({ getValue: () => 1000 } as any);
+      expect(defaultResult).toBe('1,000');
+
+      const passthroughResult = defaultFormatted.cell?.({ getValue: () => 'n/a' } as any);
+      expect(passthroughResult).toBe('n/a');
+    });
   });
 
   describe('createDateColumn', () => {
@@ -154,6 +169,18 @@ describe('ColumnFactory', () => {
       expect(column.cell).toBeDefined();
       // The cell renderer handles invalid dates by returning empty string
     });
+
+    it('returns localized dates and preserves non-date values', () => {
+      const column = ColumnFactory.createDateColumn<TestDataRecord>('createdAt', {
+        locale: 'en-GB',
+      });
+
+      const displayValue = column.cell?.({ getValue: () => '2020-01-02T00:00:00Z' } as any) as string;
+      expect(displayValue).toContain('2020');
+
+      const invalidValue = column.cell?.({ getValue: () => 'not-a-date' } as any);
+      expect(invalidValue).toBe('not-a-date');
+    });
   });
 
   describe('createBooleanColumn', () => {
@@ -186,6 +213,17 @@ describe('ColumnFactory', () => {
       expect(column.enableGrouping).toBe(false);
       expect(column.enableHiding).toBe(false);
     });
+
+    it('renders boolean values and delegates to custom renderers', () => {
+      const defaultColumn = ColumnFactory.createBooleanColumn<TestDataRecord>('active');
+      expect(defaultColumn.cell?.({ getValue: () => true } as any)).toBe('Yes');
+      expect(defaultColumn.cell?.({ getValue: () => false } as any)).toBe('No');
+
+      const renderColumn = ColumnFactory.createBooleanColumn<TestDataRecord>('active', {
+        render: value => (value ? 'Active' : 'Inactive'),
+      });
+      expect(renderColumn.cell?.({ getValue: () => true } as any)).toBe('Active');
+    });
   });
 
   describe('createActionColumn', () => {
@@ -249,6 +287,19 @@ describe('ColumnFactory', () => {
       expect(column.id).toBe(longKey);
       expect(column.accessorKey).toBe(longKey);
     });
+
+    it('creates columns from config and falls back to text for unknown types', () => {
+      const columns = ColumnFactory.createColumnsFromConfig<TestDataRecord>([
+        { key: 'name', type: 'text' },
+        { key: 'active', type: 'boolean' },
+        { key: 'custom', type: 'unknown' as any },
+      ]);
+
+      expect(columns).toHaveLength(3);
+      expect(columns[1].id).toBe('active');
+      expect(columns[2].id).toBe('custom');
+      expect(columns[2].enableColumnFilter).toBe(true);
+    });
   });
 });
 

package/src/components/DataTable/core/__tests__/ColumnManager.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ColumnManagerImpl } from '../ColumnManager';
+import type { DataRecord } from '../../types';
+import type { ColumnDef } from '@tanstack/react-table';
+
+interface TestRecord extends DataRecord {
+  id: string;
+  name: string;
+  status: string;
+}
+
+describe('ColumnManagerImpl', () => {
+  const buildColumn = (overrides: Partial<ColumnDef<TestRecord>> = {}): ColumnDef<TestRecord> => ({
+    id: 'name',
+    accessorKey: 'name',
+    header: 'Name',
+    ...overrides,
+  });
+
+  it('adds, replaces, and removes columns while keeping map state in sync', () => {
+    const manager = new ColumnManagerImpl<TestRecord>();
+    const first = buildColumn({ id: 'name', header: 'First' });
+    const replacement = buildColumn({ id: 'name', header: 'Replacement' });
+    const secondary = buildColumn({ id: 'status', header: 'Status' });
+
+    manager.addColumn(first);
+    manager.addColumn(replacement);
+    manager.addColumn(secondary);
+
+    expect(manager.getColumns()).toHaveLength(2);
+    expect(manager.getColumn('name')?.header).toBe('Replacement');
+    expect(manager.hasColumn('status')).toBe(true);
+
+    manager.removeColumn('status');
+    expect(manager.getColumn('status')).toBeUndefined();
+    expect(manager.getColumnCount()).toBe(1);
+  });
+
+  it('updates, moves, and indexes columns with validation', () => {
+    const alpha = buildColumn({ id: 'alpha', header: 'Alpha' });
+    const beta = buildColumn({ id: 'beta', header: 'Beta' });
+    const manager = new ColumnManagerImpl<TestRecord>([alpha, beta]);
+
+    manager.updateColumn('alpha', { header: 'Renamed' });
+    expect(manager.getColumn('alpha')?.header).toBe('Renamed');
+
+    manager.moveColumn('beta', 0);
+    expect(manager.getColumnByIndex(0)?.id).toBe('beta');
+    expect(manager.getColumnIndex('beta')).toBe(0);
+
+    expect(() => manager.updateColumn('missing', { header: 'x' })).toThrow('Column with ID "missing" not found');
+    expect(() => manager.moveColumn('missing', 0)).toThrow('Column with ID "missing" not found');
+    expect(() => manager.moveColumn('beta', 5)).toThrow('Invalid index: 5');
+  });
+
+  it('filters columns by capabilities', () => {
+    const sortable = buildColumn({ id: 'sortable', enableSorting: true });
+    const filterable = buildColumn({ id: 'filterable', enableColumnFilter: true });
+    const groupable = buildColumn({ id: 'groupable', enableGrouping: true });
+    const hidden = buildColumn({ id: 'hidden', enableHiding: false });
+
+    const manager = new ColumnManagerImpl<TestRecord>([sortable, filterable, groupable, hidden]);
+
+    expect(manager.getSortableColumns()).toEqual([sortable]);
+    expect(manager.getFilterableColumns()).toEqual([filterable]);
+    expect(manager.getGroupableColumns()).toEqual([groupable]);
+    expect(manager.getVisibleColumns().map(col => col.id)).not.toContain('hidden');
+  });
+
+  it('derives stable identifiers for accessor functions', () => {
+    const randomSpy = vi.spyOn(Math, 'random').mockReturnValue(0.123456789);
+    const manager = new ColumnManagerImpl<TestRecord>();
+
+    manager.addColumn({
+      header: 'AccessorFn',
+      accessorFn: row => row.name,
+    } as ColumnDef<TestRecord>);
+
+    const generatedId = manager.getColumnIds()[0];
+    expect(generatedId).toMatch(/^fn-/);
+
+    randomSpy.mockRestore();
+  });
+});

package/src/components/DataTable/core/__tests__/DataManager.test.ts

@@ -98,4 +98,18 @@ describe('DataManager', () => {
 
     await expect(manager.getCachedData('query')).resolves.toBeNull();
   });
+
+  it('returns cached data until expiry and clears when switching adapters', async () => {
+    const manager = new DataManager<TestRecord>(adapter, 10_000);
+    const cachedRows = [{ id: 'cached', name: 'Cached' }];
+    manager.setCachedData('list', cachedRows);
+
+    await expect(manager.getCachedData('list')).resolves.toEqual(cachedRows);
+
+    const newAdapter = createAdapter();
+    manager.setAdapter(newAdapter);
+
+    await expect(manager.getCachedData('list')).resolves.toBeNull();
+    expect(manager.getAdapter()).toBe(newAdapter);
+  });
 });

package/src/components/DataTable/core/__tests__/DataTableContext.test.tsx

@@ -0,0 +1,136 @@
+import React from 'react';
+import { render, renderHook, waitFor, act } from '@testing-library/react';
+import { describe, it, expect, vi } from 'vitest';
+import { DataTableProvider, useActionManager, useColumnManager, useDataManager, useDataTableContext, usePluginRegistry, useStateManager } from '../DataTableContext';
+import type { DataTableConfig, DataTableContext as IDataTableContext } from '../interfaces';
+import type { DataRecord, DataTableAction } from '../../types';
+import type { ColumnDef } from '@tanstack/react-table';
+
+interface TestRecord extends DataRecord {
+  id: string;
+  name: string;
+}
+
+const baseConfig: DataTableConfig<TestRecord> = {
+  features: {},
+  enableVirtualization: false,
+  enableCaching: false,
+  cacheTimeout: 0,
+  enableKeyboardNavigation: true,
+  enableScreenReaderSupport: true,
+};
+
+const columns: ColumnDef<TestRecord>[] = [
+  { id: 'name', header: 'Name', accessorKey: 'name' },
+];
+
+const actions: DataTableAction<TestRecord>[] = [
+  { label: 'View', testId: 'view', onClick: vi.fn() },
+];
+
+describe('DataTableContext', () => {
+  it('throws when hooks are used outside of the provider', () => {
+    expect(() => renderHook(() => useDataTableContext<TestRecord>())).toThrow(
+      'useDataTableContext must be used within a DataTableProvider'
+    );
+  });
+
+  it('exposes initialized managers populated from props', async () => {
+    const onContext = vi.fn();
+    const data: TestRecord[] = [{ id: '1', name: 'Alpha' }];
+
+    render(
+      <DataTableProvider config={baseConfig} data={data} columns={columns} actions={actions}>
+        <TestConsumer onContext={onContext} />
+      </DataTableProvider>
+    );
+
+    await waitFor(() => expect(onContext).toHaveBeenCalled());
+    const ctx = onContext.mock.calls.at(-1)?.[0];
+
+    expect(ctx.dataManager.getAdapter().name).toBe('local');
+    expect(ctx.stateManager.getState().data).toEqual(data);
+    expect(ctx.columnManager.getColumns()).toHaveLength(1);
+    expect(ctx.actionManager.getActions()).toHaveLength(1);
+  });
+
+  it('reacts to prop changes and updates managed state', async () => {
+    const onContext = vi.fn();
+    const initialData: TestRecord[] = [{ id: '1', name: 'Alpha' }];
+    const updatedData: TestRecord[] = [{ id: '2', name: 'Beta' }];
+    const updatedColumns: ColumnDef<TestRecord>[] = [
+      { id: 'name', header: 'Name', accessorKey: 'name' },
+      { id: 'id', header: 'Identifier', accessorKey: 'id' },
+    ];
+
+    const { rerender } = render(
+      <DataTableProvider config={baseConfig} data={initialData} columns={columns} actions={actions}>
+        <TestConsumer onContext={onContext} />
+      </DataTableProvider>
+    );
+
+    await waitFor(() => expect(onContext).toHaveBeenCalled());
+    onContext.mockClear();
+
+    rerender(
+      <DataTableProvider config={baseConfig} data={updatedData} columns={updatedColumns} actions={[...actions]}> 
+        <TestConsumer onContext={onContext} />
+      </DataTableProvider>
+    );
+
+    await waitFor(() => expect(onContext).toHaveBeenCalled());
+    const ctx = onContext.mock.calls.at(-1)?.[0];
+
+    expect(ctx.stateManager.getState().data).toEqual(updatedData);
+    expect(ctx.columnManager.getColumns()).toHaveLength(2);
+    expect(ctx.actionManager.getActions()).toHaveLength(actions.length);
+  });
+
+  it('exposes hook shorthands and utility helpers', async () => {
+    vi.useFakeTimers();
+    const wrapper = ({ children }: { children: React.ReactNode }) => (
+      <DataTableProvider config={baseConfig} data={[{ id: '1', name: 'Alpha' }]} columns={columns} actions={actions}>
+        {children}
+      </DataTableProvider>
+    );
+
+    const { result: managerResult } = renderHook(
+      () => ({
+        data: useDataManager<TestRecord>(),
+        columns: useColumnManager<TestRecord>(),
+        actions: useActionManager<TestRecord>(),
+        state: useStateManager<TestRecord>(),
+        plugins: usePluginRegistry<TestRecord>(),
+        context: useDataTableContext<TestRecord>(),
+      }),
+      { wrapper }
+    );
+
+    expect(managerResult.current.data.getAdapter().name).toBe('local');
+    expect(managerResult.current.columns.getColumns()).toHaveLength(1);
+    expect(managerResult.current.actions.getActionCount()).toBe(1);
+    expect(managerResult.current.state.getObserverCount()).toBe(0);
+    expect(managerResult.current.plugins.getPluginCount()).toBe(0);
+
+    const debounced = managerResult.current.context.utils.debounce(vi.fn(), 50);
+    debounced();
+    debounced();
+    expect(managerResult.current.context.utils.getRowId?.({} as any, 3)).toBe('3');
+
+    await act(async () => {
+      vi.advanceTimersByTime(60);
+    });
+
+    expect(managerResult.current.context.utils.debounce).toBeDefined();
+    expect((managerResult.current.context.utils.debounce as any).mock).toBeUndefined();
+    vi.useRealTimers();
+  });
+});
+
+function TestConsumer({ onContext }: { onContext: (ctx: IDataTableContext<TestRecord>) => void }) {
+  const ctx = useDataTableContext<TestRecord>();
+  React.useEffect(() => {
+    onContext(ctx);
+  }, [ctx, onContext]);
+  return null;
+}

package/src/components/DataTable/core/__tests__/LocalDataAdapter.test.ts

@@ -81,4 +81,20 @@ describe('LocalDataAdapter', () => {
     await expect(adapter.exportData('xlsx')).resolves.toContain('Alice');
     await expect(adapter.exportData('unsupported' as any)).rejects.toThrow('Unsupported export format: unsupported');
   });
+
+  it('imports replacements, clears data, and reports connection/error state', async () => {
+    await adapter.importData([{ id: '9', name: 'Imported', role: 'viewer', active: false }]);
+    expect(adapter.getDataCount()).toBe(1);
+    expect(adapter.getAllData()[0].id).toBe('9');
+
+    adapter.clearData();
+    expect(adapter.getDataCount()).toBe(0);
+    expect(adapter.isConnected()).toBe(true);
+
+    await expect(adapter.updateData('missing', { name: 'Nope' })).rejects.toThrow();
+    expect(adapter.getError()).toBeInstanceOf(Error);
+
+    const emptyExport = await adapter.exportData('csv');
+    expect(emptyExport).toBe('');
+  });
 });

package/src/components/DataTable/core/__tests__/PluginRegistry.test.ts

@@ -99,4 +99,22 @@ describe('PluginRegistryImpl', () => {
     expect(plugin.cleanup).toHaveBeenCalled();
     expect(registry.getPlugin('alpha')).toBeUndefined();
   });
+
+  it('validates dependencies, dependents, and unregistration edge cases', async () => {
+    const orphan = createPlugin('orphan', ['missing']);
+    const parent = createPlugin('parent');
+    const child = createPlugin('child', ['parent']);
+
+    registry.register(parent);
+    registry.register(child);
+    expect(registry.areDependenciesSatisfied('child')).toBe(true);
+    expect(registry.getDependents('parent').map(plugin => plugin.name)).toEqual(['child']);
+
+    registry.register(orphan);
+    const validation = registry.validateDependencies();
+    expect(validation.valid).toBe(false);
+    expect(validation.errors[0]).toContain('depends on "missing"');
+
+    expect(() => registry.unregister('unknown')).toThrow('Plugin "unknown" is not registered');
+  });
 });