@jmruthers/pace-core 0.6.10 → 0.6.11

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

@@ -1,312 +0,0 @@
-/**
- * @file DataTable State Manager
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Architecture/Managers
- * @since 0.3.0
- */
-
-import type { StateManager, DataTableState, DataTableObserver, Observable, UIState } from './interfaces';
-import type { DataRecord, DataTableAction } from '../types';
-import type { ColumnDef } from '@tanstack/react-table';
-
-/**
- * State manager implementation with observer pattern
- * Responsible only for state management
- */
-export class StateManagerImpl<TData extends DataRecord> implements StateManager<TData>, Observable<TData> {
-  private state: DataTableState<TData>;
-  private observers: Map<string, DataTableObserver<TData>> = new Map();
-  private observerIdCounter = 0;
-
-  constructor(initialState?: Partial<DataTableState<TData>>) {
-    this.state = this.createInitialState(initialState);
-  }
-
-  /**
-   * Get current state
-   */
-  getState(): DataTableState<TData> {
-    return { ...this.state };
-  }
-
-  /**
-   * Set state with updater function
-   */
-  setState(updater: (state: DataTableState<TData>) => DataTableState<TData>): void {
-    const newState = updater(this.getState());
-    const oldState = this.state;
-    this.state = newState;
-
-    // Notify observers of state changes
-    this.notifyStateChange(oldState, newState);
-  }
-
-  /**
-   * Subscribe to state changes
-   */
-  subscribe(observer: DataTableObserver<TData> | ((state: DataTableState<TData>) => void)): () => void {
-    const observerId = `observer-${++this.observerIdCounter}`;
-    
-    let dataTableObserver: DataTableObserver<TData>;
-    
-    if (typeof observer === 'function') {
-      dataTableObserver = {
-        id: observerId,
-        onStateChange: observer,
-      };
-    } else {
-      dataTableObserver = observer;
-    }
-
-    this.observers.set(observerId, dataTableObserver);
-    
-    // Return unsubscribe function
-    return () => this.unsubscribe(observerId);
-  }
-
-  /**
-   * Subscribe to specific state changes
-   */
-  subscribeToObserver(observer: DataTableObserver<TData>): () => void {
-    this.observers.set(observer.id, observer);
-    return () => this.unsubscribe(observer.id);
-  }
-
-  /**
-   * Unsubscribe observer
-   */
-  unsubscribe(observerId: string): void {
-    this.observers.delete(observerId);
-  }
-
-  /**
-   * Notify all observers of an event
-   */
-  notify(event: string, data: unknown): void {
-    this.observers.forEach(observer => {
-      switch (event) {
-        case 'dataChange':
-          observer.onDataChange?.(data as TData[]);
-          break;
-        case 'columnChange':
-          observer.onColumnChange?.(data as ColumnDef<TData>[]);
-          break;
-        case 'stateChange':
-          observer.onStateChange?.(data as Partial<DataTableState<TData>>);
-          break;
-        case 'error':
-          observer.onError?.(data as Error);
-          break;
-      }
-    });
-  }
-
-  /**
-   * Update data and notify observers
-   */
-  updateData(data: TData[]): void {
-    const oldData = this.state.data;
-    this.setState(state => ({ ...state, data }));
-    
-    if (oldData !== data) {
-      this.notify('dataChange', data);
-    }
-  }
-
-  /**
-   * Update columns and notify observers
-   */
-  updateColumns(columns: ColumnDef<TData>[]): void {
-    const oldColumns = this.state.columns;
-    this.setState(state => ({ ...state, columns }));
-    
-    if (oldColumns !== columns) {
-      this.notify('columnChange', columns);
-    }
-  }
-
-  /**
-   * Update actions and notify observers
-   */
-  updateActions(actions: DataTableAction<TData>[]): void {
-    this.setState(state => ({ ...state, actions }));
-  }
-
-  /**
-   * Update UI state
-   */
-  updateUI(uiUpdates: Partial<UIState>): void {
-    this.setState(state => ({
-      ...state,
-      ui: { ...state.ui, ...uiUpdates }
-    }));
-  }
-
-  /**
-   * Update global filter
-   */
-  updateGlobalFilter(filter: string): void {
-    this.updateUI({ globalFilter: filter });
-  }
-
-  /**
-   * Update column filters
-   */
-  updateColumnFilters(filters: Array<{ id: string; value: unknown }>): void {
-    this.updateUI({ columnFilters: filters });
-  }
-
-  /**
-   * Update sorting
-   */
-  updateSorting(sorting: Array<{ id: string; desc: boolean }>): void {
-    this.updateUI({ sorting });
-  }
-
-  /**
-   * Update grouping
-   */
-  updateGrouping(grouping: string[]): void {
-    this.updateUI({ grouping });
-  }
-
-  /**
-   * Update pagination
-   */
-  updatePagination(pagination: { pageIndex: number; pageSize: number }): void {
-    this.updateUI({ pagination });
-  }
-
-  /**
-   * Update row selection
-   */
-  updateRowSelection(selection: Record<string, boolean>): void {
-    this.updateUI({ rowSelection: selection });
-  }
-
-  /**
-   * Update editing state
-   */
-  updateEditing(editing: DataTableState<TData>['ui']['editing']): void {
-    this.updateUI({ editing });
-  }
-
-  /**
-   * Update modal state
-   */
-  updateModals(modals: DataTableState<TData>['ui']['modals']): void {
-    this.updateUI({ modals });
-  }
-
-  /**
-   * Update feature state
-   */
-  updateFeatureState(featureName: string, state: unknown): void {
-    this.setState(currentState => ({
-      ...currentState,
-      features: new Map(currentState.features).set(featureName, state)
-    }));
-  }
-
-  /**
-   * Update plugin state
-   */
-  updatePluginState(pluginName: string, state: unknown): void {
-    this.setState(currentState => ({
-      ...currentState,
-      plugins: new Map(currentState.plugins).set(pluginName, state)
-    }));
-  }
-
-  /**
-   * Set loading state
-   */
-  setLoading(loading: boolean): void {
-    this.setState(state => ({ ...state, isLoading: loading }));
-  }
-
-  /**
-   * Set error state
-   */
-  setError(error: Error | null): void {
-    this.setState(state => ({ ...state, error }));
-    
-    if (error) {
-      this.notify('error', error);
-    }
-  }
-
-  /**
-   * Reset state to initial values
-   */
-  reset(): void {
-    this.state = this.createInitialState();
-    this.notify('stateChange', this.state);
-  }
-
-  /**
-   * Get observer count
-   */
-  getObserverCount(): number {
-    return this.observers.size;
-  }
-
-  /**
-   * Create initial state
-   */
-  private createInitialState(overrides?: Partial<DataTableState<TData>>): DataTableState<TData> {
-    const defaultState: DataTableState<TData> = {
-      data: [],
-      isLoading: false,
-      error: null,
-      columns: [],
-      columnVisibility: {},
-      actions: [],
-      ui: {
-        globalFilter: '',
-        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,
-        },
-      },
-      features: new Map(),
-      plugins: new Map(),
-    };
-
-    return { ...defaultState, ...overrides };
-  }
-
-  /**
-   * Notify observers of state changes
-   */
-  private notifyStateChange(oldState: DataTableState<TData>, newState: DataTableState<TData>): void {
-    // Check for specific changes and notify accordingly
-    if (oldState.data !== newState.data) {
-      this.notify('dataChange', newState.data);
-    }
-    
-    if (oldState.columns !== newState.columns) {
-      this.notify('columnChange', newState.columns);
-    }
-    
-    // Always notify of state change
-    this.notify('stateChange', newState);
-  }
-} 

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

@@ -1,235 +0,0 @@
-/**
- * @file ActionManager Unit Tests
- * @package @jmruthers/pace-core
- * @module Components/DataTable/Core/__tests__
- *
- * Focused tests for the ActionManager implementation covering lifecycle, validation,
- * and disabled-action enforcement.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { ActionManagerImpl } from '../ActionManager';
-import type { DataRecord, DataTableAction } from '../../types';
-
-interface TestRecord extends DataRecord {
-  id: string;
-  status: 'draft' | 'published';
-}
-
-const buildAction = (overrides: Partial<DataTableAction<TestRecord>> = {}): DataTableAction<TestRecord> => ({
-  label: overrides.label ?? 'Edit',
-  testId: overrides.testId ?? 'edit',
-  onClick: overrides.onClick ?? vi.fn(),
-  variant: overrides.variant,
-  disabled: overrides.disabled,
-});
-
-describe('ActionManagerImpl', () => {
-  it('adds actions and replaces existing entries that share an identifier', () => {
-    const manager = new ActionManagerImpl<TestRecord>();
-    const original = buildAction({ label: 'Initial' });
-    const updated = buildAction({ label: 'Updated' });
-
-    manager.addAction(original);
-    manager.addAction(updated);
-
-    expect(manager.getAction('edit')).toBe(updated);
-    expect(manager.getActionCount()).toBe(1);
-  });
-
-  it('updates actions and throws when an action cannot be found', () => {
-    const manager = new ActionManagerImpl<TestRecord>([buildAction({ label: 'Original' })]);
-
-    manager.updateAction('edit', { label: 'Renamed' });
-    expect(manager.getAction('edit')?.label).toBe('Renamed');
-
-    expect(() => manager.updateAction('missing', { label: 'x' })).toThrow('Action with ID "missing" not found');
-  });
-
-  it('returns enabled actions and respects disabled predicates', () => {
-    const enabled = buildAction({ testId: 'enabled', label: 'Enabled' });
-    const disabledBoolean = buildAction({ testId: 'disabled', disabled: true });
-    const disabledPredicate = buildAction({
-      testId: 'predicate',
-      disabled: () => true,
-    });
-
-    const manager = new ActionManagerImpl<TestRecord>([enabled, disabledBoolean, disabledPredicate]);
-
-    const visible = manager.getEnabledActions();
-    expect(visible).toHaveLength(1);
-    expect(visible[0].testId).toBe('enabled');
-  });
-
-  it('executes actions and guards against disabled rows', () => {
-    const onClick = vi.fn();
-    const row: TestRecord = { id: '1', status: 'draft' };
-    const manager = new ActionManagerImpl<TestRecord>([
-      buildAction({
-        testId: 'publish',
-        onClick,
-        disabled: record => record.status === 'published',
-      })
-    ]);
-
-    manager.executeAction('publish', row);
-    expect(onClick).toHaveBeenCalledWith(row);
-
-    expect(() => manager.executeAction('publish', { ...row, status: 'published' })).toThrow(
-      'Action "publish" is disabled for this row'
-    );
-  });
-
-  it('moves actions and validates requested indices', () => {
-    const manager = new ActionManagerImpl<TestRecord>([
-      buildAction({ testId: 'first', label: 'First' }),
-      buildAction({ testId: 'second', label: 'Second' })
-    ]);
-
-    manager.moveAction('second', 0);
-    expect(manager.getActionByIndex(0)?.testId).toBe('second');
-
-    expect(() => manager.moveAction('missing', 0)).toThrow('Action with ID "missing" not found');
-    expect(() => manager.moveAction('second', 5)).toThrow('Invalid index: 5');
-  });
-
-  it('reports disabled state for missing actions and boolean flags', () => {
-    const manager = new ActionManagerImpl<TestRecord>([
-      buildAction({ testId: 'disabled', disabled: true })
-    ]);
-
-    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', () => {
-    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']);
-  });
-
-  it('clears all actions', () => {
-    const manager = new ActionManagerImpl<TestRecord>([
-      buildAction({ testId: 'action1' }),
-      buildAction({ testId: 'action2' }),
-    ]);
-
-    manager.clearActions();
-    expect(manager.getActionCount()).toBe(0);
-    expect(manager.getActions()).toHaveLength(0);
-  });
-
-  it('sets all actions at once', () => {
-    const actions = [
-      buildAction({ testId: 'primary', variant: 'default' }),
-      buildAction({ testId: 'secondary', variant: 'secondary' }),
-    ];
-
-    const manager = new ActionManagerImpl<TestRecord>();
-    manager.setActions(actions);
-    expect(manager.getActionIds()).toEqual(['primary', 'secondary']);
-    expect(manager.getActionCount()).toBe(2);
-  });
-
-  it('checks if action exists and gets all actions', () => {
-    const manager = new ActionManagerImpl<TestRecord>([
-      buildAction({ testId: 'edit', label: 'Edit' }),
-      buildAction({ testId: 'delete', label: 'Delete' }),
-    ]);
-
-    expect(manager.hasAction('edit')).toBe(true);
-    expect(manager.hasAction('missing')).toBe(false);
-
-    const allActions = manager.getActions();
-    expect(allActions).toHaveLength(2);
-    expect(allActions.map(a => a.testId)).toEqual(['edit', 'delete']);
-  });
-
-  it('removes actions by ID', () => {
-    const manager = new ActionManagerImpl<TestRecord>([
-      buildAction({ testId: 'edit', label: 'Edit' }),
-      buildAction({ testId: 'delete', label: 'Delete' }),
-    ]);
-
-    manager.removeAction('edit');
-    expect(manager.hasAction('edit')).toBe(false);
-    expect(manager.getActionCount()).toBe(1);
-    expect(manager.getAction('delete')).toBeDefined();
-  });
-
-  it('gets action index by ID', () => {
-    const manager = new ActionManagerImpl<TestRecord>([
-      buildAction({ testId: 'first', label: 'First' }),
-      buildAction({ testId: 'second', label: 'Second' }),
-      buildAction({ testId: 'third', label: 'Third' }),
-    ]);
-
-    expect(manager.getActionIndex('first')).toBe(0);
-    expect(manager.getActionIndex('second')).toBe(1);
-    expect(manager.getActionIndex('third')).toBe(2);
-    expect(manager.getActionIndex('missing')).toBe(-1);
-  });
-
-  it('gets actions by variant using getActionsByVariant', () => {
-    const manager = new ActionManagerImpl<TestRecord>([
-      buildAction({ testId: 'primary1', variant: 'default' }),
-      buildAction({ testId: 'primary2', variant: 'default' }),
-      buildAction({ testId: 'secondary1', variant: 'secondary' }),
-    ]);
-
-    const primaryActions = manager.getActionsByVariant('default');
-    expect(primaryActions).toHaveLength(2);
-    expect(primaryActions.map(a => a.testId)).toEqual(['primary1', 'primary2']);
-
-    const secondaryActions = manager.getActionsByVariant('secondary');
-    expect(secondaryActions).toHaveLength(1);
-    expect(secondaryActions[0].testId).toBe('secondary1');
-  });
-
-  it('handles getEnabledActions with function-based disabled using mock row', () => {
-    const manager = new ActionManagerImpl<TestRecord>([
-      buildAction({ testId: 'enabled', disabled: false }),
-      buildAction({
-        testId: 'conditional',
-        disabled: (row: TestRecord) => row.status === 'published',
-      }),
-    ]);
-
-    // getEnabledActions uses an empty object as mock row for function-based disabled
-    // Since empty object doesn't have status='published', conditional action will be enabled
-    const enabled = manager.getEnabledActions();
-    expect(enabled.length).toBe(2);
-    expect(enabled.map(a => a.testId)).toContain('enabled');
-    expect(enabled.map(a => a.testId)).toContain('conditional');
-  });
-
-  it('handles executeAction with boolean disabled flag (note: boolean disabled not checked in executeAction)', () => {
-    const onClick = vi.fn();
-    const manager = new ActionManagerImpl<TestRecord>([
-      buildAction({
-        testId: 'disabled',
-        onClick,
-        disabled: true,
-      }),
-    ]);
-
-    // Note: executeAction only checks function-based disabled, not boolean disabled
-    // This is the current implementation behavior
-    manager.executeAction('disabled', { id: '1', status: 'draft' });
-    expect(onClick).toHaveBeenCalled();
-  });
-
-  it('throws error when executing non-existent action', () => {
-    const manager = new ActionManagerImpl<TestRecord>();
-    expect(() => manager.executeAction('missing', { id: '1', status: 'draft' })).toThrow(
-      'Action with ID "missing" not found'
-    );
-  });
-});

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

@@ -1,141 +0,0 @@
-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();
-  });
-
-  it('handles empty column arrays', () => {
-    const manager = new ColumnManagerImpl<TestRecord>();
-
-    expect(manager.getColumns()).toHaveLength(0);
-    expect(manager.getColumnCount()).toBe(0);
-    expect(manager.getColumnIds()).toHaveLength(0);
-    expect(manager.getSortableColumns()).toHaveLength(0);
-    expect(manager.getFilterableColumns()).toHaveLength(0);
-    expect(manager.getGroupableColumns()).toHaveLength(0);
-    expect(manager.getVisibleColumns()).toHaveLength(0);
-  });
-
-  it('handles getVisibleColumns filtering correctly', () => {
-    const visible = buildColumn({ id: 'visible', enableHiding: true });
-    const hidden = buildColumn({ id: 'hidden', enableHiding: false });
-    const manager = new ColumnManagerImpl<TestRecord>([visible, hidden]);
-
-    const visibleColumns = manager.getVisibleColumns();
-    expect(visibleColumns).toHaveLength(1);
-    expect(visibleColumns[0].id).toBe('visible');
-  });
-
-  it('handles getColumnByIndex edge cases', () => {
-    const manager = new ColumnManagerImpl<TestRecord>([
-      buildColumn({ id: 'first' }),
-      buildColumn({ id: 'second' }),
-    ]);
-
-    expect(manager.getColumnByIndex(0)?.id).toBe('first');
-    expect(manager.getColumnByIndex(1)?.id).toBe('second');
-    expect(manager.getColumnByIndex(2)).toBeUndefined();
-    expect(manager.getColumnByIndex(-1)).toBeUndefined();
-  });
-
-  it('clears all columns', () => {
-    const manager = new ColumnManagerImpl<TestRecord>([
-      buildColumn({ id: 'first' }),
-      buildColumn({ id: 'second' }),
-    ]);
-
-    manager.clearColumns();
-    expect(manager.getColumnCount()).toBe(0);
-    expect(manager.getColumns()).toHaveLength(0);
-  });
-
-  it('sets all columns at once', () => {
-    const manager = new ColumnManagerImpl<TestRecord>();
-    const columns = [
-      buildColumn({ id: 'first' }),
-      buildColumn({ id: 'second' }),
-    ];
-
-    manager.setColumns(columns);
-    expect(manager.getColumnCount()).toBe(2);
-    expect(manager.getColumnIds()).toEqual(['first', 'second']);
-  });
-});