@jmruthers/pace-core 0.6.10 → 0.6.11

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

@@ -1,178 +0,0 @@
-/**
- * @file DataManager Unit Tests
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Core/__tests__
- *
- * Validates data lifecycle operations, caching, and adapter error handling.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { DataManager } from '../DataManager';
-import type { DataAdapter } from '../interfaces';
-import type { DataRecord } from '../../types';
-
-interface TestRecord extends DataRecord {
-  id: string;
-  name: string;
-}
-
-type AdapterMock = DataAdapter<TestRecord> & {
-  updateData: ReturnType<typeof vi.fn>;
-  deleteData: ReturnType<typeof vi.fn>;
-  createData: ReturnType<typeof vi.fn>;
-};
-
-const createAdapter = (): AdapterMock => ({
-  name: 'mock',
-  fetchData: vi.fn(),
-  updateData: vi.fn().mockResolvedValue(undefined),
-  deleteData: vi.fn().mockResolvedValue(undefined),
-  createData: vi.fn().mockResolvedValue({ id: 'created', name: 'Created' }),
-  exportData: vi.fn(),
-  importData: vi.fn(),
-  isConnected: vi.fn().mockReturnValue(true),
-  getError: vi.fn().mockReturnValue(null),
-});
-
-describe('DataManager', () => {
-  let adapter: AdapterMock;
-
-  beforeEach(() => {
-    adapter = createAdapter();
-  });
-
-  it('updates rows through the adapter, mutates local state, and clears cache', async () => {
-    const manager = new DataManager<TestRecord>(adapter);
-    (manager as any).data = [{ id: '1', name: 'Alpha' }];
-    manager.setCachedData('list', [{ id: 'cached', name: 'Cache' }]);
-
-    await manager.updateData('1', { name: 'Beta' });
-
-    expect(adapter.updateData).toHaveBeenCalledWith('1', { name: 'Beta' });
-    expect(manager.getData()[0]).toEqual({ id: '1', name: 'Beta' });
-    await expect(manager.getCachedData('list')).resolves.toBeNull();
-    expect(manager.isLoading()).toBe(false);
-  });
-
-  it('propagates adapter failures during update and exposes error state', async () => {
-    const manager = new DataManager<TestRecord>(adapter);
-    const failure = new Error('boom');
-    adapter.updateData.mockRejectedValueOnce(failure);
-
-    await expect(manager.updateData('missing', {})).rejects.toThrow('boom');
-    expect(manager.getError()).toBe(failure);
-    expect(manager.isLoading()).toBe(false);
-  });
-
-  it('creates rows and appends them to the local dataset', async () => {
-    const manager = new DataManager<TestRecord>(adapter);
-    adapter.createData.mockResolvedValueOnce({ id: '2', name: 'Bravo' });
-
-    const created = await manager.createData({ name: 'Bravo' });
-
-    expect(created).toEqual({ id: '2', name: 'Bravo' });
-    expect(manager.getData()).toContainEqual({ id: '2', name: 'Bravo' });
-  });
-
-  it('deletes rows and clears caches', async () => {
-    const manager = new DataManager<TestRecord>(adapter);
-    (manager as any).data = [
-      { id: '1', name: 'Alpha' },
-      { id: '2', name: 'Bravo' }
-    ];
-    manager.setCachedData('list', [{ id: '1', name: 'Alpha' }]);
-
-    await manager.deleteData('1');
-
-    expect(adapter.deleteData).toHaveBeenCalledWith('1');
-    expect(manager.getData()).toEqual([{ id: '2', name: 'Bravo' }]);
-    await expect(manager.getCachedData('list')).resolves.toBeNull();
-  });
-
-  it('expires cached data according to the configured timeout', async () => {
-    const manager = new DataManager<TestRecord>(adapter, 50);
-    manager.setCachedData('query', [{ id: '1', name: 'Alpha' }]);
-
-    const cacheEntry = (manager as any).cache.get('query');
-    cacheEntry.timestamp = Date.now() - 1000;
-
-    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);
-  });
-
-  it('handles createData errors and maintains loading state', async () => {
-    const manager = new DataManager<TestRecord>(adapter);
-    const failure = new Error('Create failed');
-    adapter.createData.mockRejectedValueOnce(failure);
-
-    await expect(manager.createData({ name: 'Test' })).rejects.toThrow('Create failed');
-    expect(manager.getError()).toBe(failure);
-    expect(manager.isLoading()).toBe(false);
-    expect(manager.getData()).toHaveLength(0);
-  });
-
-  it('handles deleteData errors and maintains loading state', async () => {
-    const manager = new DataManager<TestRecord>(adapter);
-    (manager as any).data = [{ id: '1', name: 'Alpha' }];
-    const failure = new Error('Delete failed');
-    adapter.deleteData.mockRejectedValueOnce(failure);
-
-    await expect(manager.deleteData('1')).rejects.toThrow('Delete failed');
-    expect(manager.getError()).toBe(failure);
-    expect(manager.isLoading()).toBe(false);
-    expect(manager.getData()).toHaveLength(1); // Data should not be removed on error
-  });
-
-  it('clears cache explicitly', async () => {
-    const manager = new DataManager<TestRecord>(adapter);
-    manager.setCachedData('key1', [{ id: '1', name: 'One' }]);
-    manager.setCachedData('key2', [{ id: '2', name: 'Two' }]);
-
-    manager.clearCache();
-
-    await expect(manager.getCachedData('key1')).resolves.toBeNull();
-    await expect(manager.getCachedData('key2')).resolves.toBeNull();
-  });
-
-  it('handles updateData when item not found in local data', async () => {
-    const manager = new DataManager<TestRecord>(adapter);
-    (manager as any).data = [];
-
-    await manager.updateData('missing', { name: 'Updated' });
-
-    expect(adapter.updateData).toHaveBeenCalledWith('missing', { name: 'Updated' });
-    expect(manager.getData()).toHaveLength(0); // Should not add item if not found
-  });
-
-  it('gets and sets adapter correctly', () => {
-    const manager = new DataManager<TestRecord>(adapter);
-    expect(manager.getAdapter()).toBe(adapter);
-
-    const newAdapter = createAdapter();
-    manager.setAdapter(newAdapter);
-    expect(manager.getAdapter()).toBe(newAdapter);
-  });
-
-  it('clears cache when adapter is changed', async () => {
-    const manager = new DataManager<TestRecord>(adapter);
-    manager.setCachedData('key1', [{ id: '1', name: 'One' }]);
-
-    const newAdapter = createAdapter();
-    manager.setAdapter(newAdapter);
-
-    await expect(manager.getCachedData('key1')).resolves.toBeNull();
-  });
-});

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

@@ -1,133 +0,0 @@
-/**
- * @file LocalDataAdapter Unit Tests
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Core/__tests__
- *
- * Exercises filtering, sorting, pagination, and export logic for the in-memory adapter.
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { LocalDataAdapter } from '../LocalDataAdapter';
-import type { DataRecord } from '../../types';
-
-interface TestRecord extends DataRecord {
-  id: string;
-  name: string;
-  role: string;
-  active: boolean;
-}
-
-describe('LocalDataAdapter', () => {
-  let adapter: LocalDataAdapter<TestRecord>;
-  const sample: TestRecord[] = [
-    { id: '1', name: 'Alice', role: 'admin', active: true },
-    { id: '2', name: 'Bob', role: 'viewer', active: false },
-    { id: '3', name: 'Charlie', role: 'admin', active: true },
-  ];
-
-  beforeEach(() => {
-    adapter = new LocalDataAdapter(sample);
-  });
-
-  it('filters by search term and column filters', async () => {
-    const result = await adapter.fetchData({
-      search: 'ali',
-      filters: { role: 'admin', active: true },
-    });
-
-    expect(result).toEqual([{ id: '1', name: 'Alice', role: 'admin', active: true }]);
-  });
-
-  it('sorts results case-insensitively', async () => {
-    const sortedDesc = await adapter.fetchData({ sortBy: 'name', sortDirection: 'desc' });
-    expect(sortedDesc.map(row => row.name)).toEqual(['Charlie', 'Bob', 'Alice']);
-
-    const sortedAsc = await adapter.fetchData({ sortBy: 'name', sortDirection: 'asc' });
-    expect(sortedAsc.map(row => row.name)).toEqual(['Alice', 'Bob', 'Charlie']);
-  });
-
-  it('paginates data correctly', async () => {
-    const page1 = await adapter.fetchData({ page: 0, pageSize: 2 });
-    expect(page1).toHaveLength(2);
-    expect(page1[0].name).toBe('Alice');
-    expect(page1[1].name).toBe('Bob');
-
-    const page2 = await adapter.fetchData({ page: 1, pageSize: 2 });
-    expect(page2).toHaveLength(1);
-    expect(page2[0].name).toBe('Charlie');
-  });
-
-  it('updates and deletes rows, throwing when ids are not found', async () => {
-    await adapter.updateData('1', { role: 'viewer' });
-    expect(adapter.getAllData().find(row => row.id === '1')?.role).toBe('viewer');
-
-    await adapter.deleteData('2');
-    expect(adapter.getAllData().map(row => row.id)).toEqual(['1', '3']);
-
-    await expect(adapter.updateData('missing', { name: 'Nope' })).rejects.toThrow('Item with ID "missing" not found');
-    await expect(adapter.deleteData('missing')).rejects.toThrow('Item with ID "missing" not found');
-  });
-
-  it('creates rows with generated identifiers', async () => {
-    const randomSpy = vi.spyOn(Math, 'random').mockReturnValue(0.123456789);
-    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(1700000000000);
-
-    const created = await adapter.createData({ name: 'Delta', role: 'editor', active: true });
-
-    expect(created).toMatchObject({ name: 'Delta', role: 'editor', active: true });
-    expect(adapter.getDataCount()).toBe(4);
-
-    randomSpy.mockRestore();
-    nowSpy.mockRestore();
-  });
-
-  it('exports to CSV format with headers', async () => {
-    const csv = await adapter.exportData('csv', { includeHeaders: true });
-    const lines = csv.split('\n');
-    expect(lines[0]).toContain('id');
-    expect(lines.length).toBeGreaterThan(1);
-  });
-
-  it('exports to JSON format', async () => {
-    const json = await adapter.exportData('json');
-    const parsed = JSON.parse(json);
-    expect(parsed).toHaveLength(3);
-    expect(parsed[0]).toHaveProperty('id');
-  });
-
-  it('exports to XLSX format', async () => {
-    const xlsx = await adapter.exportData('xlsx');
-    expect(xlsx).toContain('Alice');
-  });
-
-  it('throws error for unsupported export formats', async () => {
-    await expect(adapter.exportData('unsupported' as any)).rejects.toThrow('Unsupported export format: unsupported');
-  });
-
-  it('imports data and replaces existing data', async () => {
-    await adapter.importData([{ id: '9', name: 'Imported', role: 'viewer', active: false }]);
-    expect(adapter.getDataCount()).toBe(1);
-    expect(adapter.getAllData()[0].id).toBe('9');
-  });
-
-  it('clears all data', () => {
-    adapter.clearData();
-    expect(adapter.getDataCount()).toBe(0);
-    expect(adapter.getAllData()).toHaveLength(0);
-  });
-
-  it('reports connection state', () => {
-    expect(adapter.isConnected()).toBe(true);
-  });
-
-  it('reports error state after failed operations', async () => {
-    await expect(adapter.updateData('missing', { name: 'Nope' })).rejects.toThrow();
-    expect(adapter.getError()).toBeInstanceOf(Error);
-  });
-
-  it('handles empty data export', async () => {
-    adapter.clearData();
-    const emptyExport = await adapter.exportData('csv');
-    expect(emptyExport).toBe('');
-  });
-});

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

@@ -1,142 +0,0 @@
-/**
- * @file PluginRegistry Unit Tests
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Core/__tests__
- *
- * Ensures plugin registration, dependency resolution, lifecycle management, and rendering behave as expected.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { PluginRegistryImpl } from '../PluginRegistry';
-import type { DataTablePlugin } from '../interfaces';
-import type { DataRecord } from '../../types';
-
-type TestPlugin = DataTablePlugin<DataRecord> & {
-  initialize: ReturnType<typeof vi.fn>;
-  cleanup: ReturnType<typeof vi.fn>;
-  render: ReturnType<typeof vi.fn>;
-};
-
-const createPlugin = (name: string, dependencies: string[] = []): TestPlugin => ({
-  name,
-  version: '1.0.0',
-  priority: 0,
-  dependencies,
-  initialize: vi.fn().mockResolvedValue(undefined),
-  cleanup: vi.fn().mockResolvedValue(undefined),
-  render: vi.fn().mockReturnValue(`${name}-ui`),
-  onDataChange: vi.fn(),
-  onColumnChange: vi.fn(),
-  onStateChange: vi.fn(),
-});
-
-describe('PluginRegistryImpl', () => {
-  let registry: PluginRegistryImpl<DataRecord>;
-
-  beforeEach(() => {
-    registry = new PluginRegistryImpl();
-  });
-
-  it('prevents duplicate registrations and exposes plugin lookups', () => {
-    const plugin = createPlugin('alpha');
-    registry.register(plugin);
-
-    expect(registry.getPlugin('alpha')).toBe(plugin);
-    expect(() => registry.register(plugin)).toThrow('Plugin "alpha" is already registered');
-  });
-
-  it('orders plugins based on dependency requirements', () => {
-    const core = createPlugin('core');
-    const feature = createPlugin('feature', ['core']);
-    registry.register(feature);
-    registry.register(core);
-
-    const order = registry.getDependencyOrder().map(plugin => plugin.name);
-    expect(order.indexOf('core')).toBeLessThan(order.indexOf('feature'));
-  });
-
-  it('detects circular dependencies', () => {
-    registry = new PluginRegistryImpl();
-    const pluginA = createPlugin('A', ['B']);
-    const pluginB = createPlugin('B', ['A']);
-    registry.register(pluginA);
-    registry.register(pluginB);
-    expect(() => registry.getDependencyOrder()).toThrow('Circular dependency detected: A');
-  });
-
-  it('initializes plugins, tracks their lifecycle, and renders initialized entries', async () => {
-    const alpha = createPlugin('alpha');
-    const beta = createPlugin('beta', ['alpha']);
-    registry.register(alpha);
-    registry.register(beta);
-
-    const context = { dataManager: {} } as any;
-    await registry.initializePlugins(context);
-
-    expect(alpha.initialize).toHaveBeenCalledWith(context);
-    expect(beta.initialize).toHaveBeenCalledWith(context);
-    expect(registry.isPluginInitialized('alpha')).toBe(true);
-    expect(registry.renderPlugins()).toEqual(['alpha-ui', 'beta-ui']);
-  });
-
-  it('cleans up initialized plugins in reverse order and ignores uninitialized entries', async () => {
-    const alpha = createPlugin('alpha');
-    const beta = createPlugin('beta', ['alpha']);
-    registry.register(alpha);
-    registry.register(beta);
-
-    await registry.initializePlugins({} as any);
-    await registry.cleanupPlugins();
-
-    expect(beta.cleanup).toHaveBeenCalled();
-    expect(alpha.cleanup).toHaveBeenCalled();
-  });
-
-  it('unregisters plugins and runs cleanup if they were initialized', async () => {
-    const plugin = createPlugin('alpha');
-    registry.register(plugin);
-    await registry.initializePlugins({} as any);
-
-    registry.unregister('alpha');
-    expect(plugin.cleanup).toHaveBeenCalled();
-    expect(registry.getPlugin('alpha')).toBeUndefined();
-  });
-
-  it('validates dependencies and detects missing dependencies', () => {
-    const orphan = createPlugin('orphan', ['missing']);
-    registry.register(orphan);
-
-    const validation = registry.validateDependencies();
-    expect(validation.valid).toBe(false);
-    expect(validation.errors[0]).toContain('depends on "missing"');
-  });
-
-  it('checks if plugin dependencies are satisfied', () => {
-    const parent = createPlugin('parent');
-    const child = createPlugin('child', ['parent']);
-
-    registry.register(parent);
-    registry.register(child);
-
-    expect(registry.areDependenciesSatisfied('child')).toBe(true);
-    expect(registry.areDependenciesSatisfied('parent')).toBe(true);
-  });
-
-  it('gets dependents of a plugin', () => {
-    const parent = createPlugin('parent');
-    const child1 = createPlugin('child1', ['parent']);
-    const child2 = createPlugin('child2', ['parent']);
-
-    registry.register(parent);
-    registry.register(child1);
-    registry.register(child2);
-
-    const dependents = registry.getDependents('parent').map(plugin => plugin.name);
-    expect(dependents).toContain('child1');
-    expect(dependents).toContain('child2');
-  });
-
-  it('throws error when unregistering non-existent plugin', () => {
-    expect(() => registry.unregister('unknown')).toThrow('Plugin "unknown" is not registered');
-  });
-});

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

@@ -1,158 +0,0 @@
-/**
- * @file StateManager Unit Tests
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Core/__tests__
- *
- * Covers observer notifications, granular update helpers, and reset logic.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { StateManagerImpl } from '../StateManager';
-import type { DataRecord } from '../../types';
-import type { ColumnDef } from '@tanstack/react-table';
-
-interface TestRecord extends DataRecord {
-  id: string;
-  name: string;
-}
-
-describe('StateManagerImpl', () => {
-  const buildColumn = (id: string): ColumnDef<TestRecord> => ({
-    id,
-    accessorKey: id,
-  });
-
-  it('subscribes observers and emits notifications for data, columns, and errors', () => {
-    const manager = new StateManagerImpl<TestRecord>();
-    const observer = {
-      id: 'observer-1',
-      onDataChange: vi.fn(),
-      onColumnChange: vi.fn(),
-      onStateChange: vi.fn(),
-      onError: vi.fn(),
-    };
-
-    const unsubscribe = manager.subscribeToObserver(observer);
-    const rows = [{ id: '1', name: 'Alpha' }];
-    const cols = [buildColumn('name')];
-
-    manager.updateData(rows);
-    manager.updateColumns(cols);
-    manager.setError(new Error('boom'));
-
-    // Each data update triggers through setState + explicit notifyDataChange
-    // so we assert against the precise call count produced by the implementation.
-    expect(observer.onDataChange).toHaveBeenCalledTimes(2);
-    expect(observer.onDataChange).toHaveBeenCalledWith(rows);
-    expect(observer.onColumnChange).toHaveBeenCalledWith(cols);
-    expect(observer.onStateChange).toHaveBeenCalled();
-    expect(observer.onError).toHaveBeenCalledWith(new Error('boom'));
-
-    unsubscribe();
-    manager.updateData([{ id: '2', name: 'Beta' }]);
-    expect(observer.onDataChange).toHaveBeenCalledTimes(2);
-  });
-
-  it('updates discrete UI properties through helper methods', () => {
-    const manager = new StateManagerImpl<TestRecord>();
-
-    manager.updateGlobalFilter('search');
-    manager.updateColumnFilters([{ id: 'name', value: 'A' }]);
-    manager.updateSorting([{ id: 'name', desc: true }]);
-    manager.updateGrouping(['role']);
-    manager.updatePagination({ pageIndex: 2, pageSize: 25 });
-    manager.updateRowSelection({ row_1: true });
-    manager.updateEditing({ rowId: '1', data: { name: 'Alpha' }, isCreating: false, creationData: {} });
-    manager.updateModals({ export: true, import: false, view: true, viewData: null });
-
-    const ui = manager.getState().ui;
-    expect(ui.globalFilter).toBe('search');
-    expect(ui.columnFilters).toEqual([{ id: 'name', value: 'A' }]);
-    expect(ui.sorting).toEqual([{ id: 'name', desc: true }]);
-    expect(ui.grouping).toEqual(['role']);
-    expect(ui.pagination).toEqual({ pageIndex: 2, pageSize: 25 });
-    expect(ui.rowSelection).toEqual({ row_1: true });
-    expect(ui.editing.rowId).toBe('1');
-    expect(ui.modals.export).toBe(true);
-  });
-
-  it('tracks feature state', () => {
-    const manager = new StateManagerImpl<TestRecord>();
-    manager.updateFeatureState('aggregation', { enabled: true });
-
-    expect(manager.getState().features.get('aggregation')).toEqual({ enabled: true });
-  });
-
-  it('tracks plugin state', () => {
-    const manager = new StateManagerImpl<TestRecord>();
-    manager.updatePluginState('export', { format: 'csv' });
-
-    expect(manager.getState().plugins.get('export')).toEqual({ format: 'csv' });
-  });
-
-  it('resets state to defaults', () => {
-    const manager = new StateManagerImpl<TestRecord>({
-      ui: {
-        globalFilter: 'preset',
-        columnFilters: [],
-        sorting: [],
-        grouping: [],
-        expanded: {},
-        pagination: { pageIndex: 0, pageSize: 10 },
-        rowSelection: {},
-        editing: { rowId: null, data: {}, isCreating: false, creationData: {} },
-        modals: { import: false, export: false, view: false, viewData: null },
-      }
-    });
-
-    manager.updateFeatureState('aggregation', { enabled: true });
-    manager.updatePluginState('export', { format: 'csv' });
-
-    manager.reset();
-    expect(manager.getState().ui.globalFilter).toBe('');
-    expect(manager.getState().features.size).toBe(0);
-    expect(manager.getState().plugins.size).toBe(0);
-  });
-
-  it('handles multiple observers', () => {
-    const manager = new StateManagerImpl<TestRecord>();
-    const observer1 = {
-      id: 'observer-1',
-      onDataChange: vi.fn(),
-      onColumnChange: vi.fn(),
-      onStateChange: vi.fn(),
-      onError: vi.fn(),
-    };
-    const observer2 = {
-      id: 'observer-2',
-      onDataChange: vi.fn(),
-      onColumnChange: vi.fn(),
-      onStateChange: vi.fn(),
-      onError: vi.fn(),
-    };
-
-    manager.subscribeToObserver(observer1);
-    manager.subscribeToObserver(observer2);
-
-    manager.updateData([{ id: '1', name: 'Alpha' }]);
-
-    expect(observer1.onDataChange).toHaveBeenCalled();
-    expect(observer2.onDataChange).toHaveBeenCalled();
-  });
-
-  it('handles observer without all callbacks', () => {
-    const manager = new StateManagerImpl<TestRecord>();
-    const observer = {
-      id: 'observer-1',
-      onDataChange: vi.fn(),
-      // Missing other callbacks
-    } as any;
-
-    manager.subscribeToObserver(observer);
-    manager.updateData([{ id: '1', name: 'Alpha' }]);
-    manager.setError(new Error('test'));
-
-    expect(observer.onDataChange).toHaveBeenCalled();
-    // Should not throw when other callbacks are missing
-  });
-});