@jmruthers/pace-core 0.5.181 → 0.5.182

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

@@ -6,7 +6,8 @@
  */
 
 import type { StateManager, DataTableState, DataTableObserver, Observable, UIState } from './interfaces';
-import type { DataRecord } from '../types';
+import type { DataRecord, DataTableAction } from '../types';
+import type { ColumnDef } from '@tanstack/react-table';
 
 /**
  * State manager implementation with observer pattern
@@ -81,20 +82,20 @@ export class StateManagerImpl<TData extends DataRecord> implements StateManager<
   /**
    * Notify all observers of an event
    */
-  notify(event: string, data: any): void {
+  notify(event: string, data: unknown): void {
     this.observers.forEach(observer => {
       switch (event) {
         case 'dataChange':
-          observer.onDataChange?.(data);
+          observer.onDataChange?.(data as TData[]);
           break;
         case 'columnChange':
-          observer.onColumnChange?.(data);
+          observer.onColumnChange?.(data as ColumnDef<TData>[]);
           break;
         case 'stateChange':
-          observer.onStateChange?.(data);
+          observer.onStateChange?.(data as Partial<DataTableState<TData>>);
           break;
         case 'error':
-          observer.onError?.(data);
+          observer.onError?.(data as Error);
           break;
       }
     });
@@ -115,7 +116,7 @@ export class StateManagerImpl<TData extends DataRecord> implements StateManager<
   /**
    * Update columns and notify observers
    */
-  updateColumns(columns: any[]): void {
+  updateColumns(columns: ColumnDef<TData>[]): void {
     const oldColumns = this.state.columns;
     this.setState(state => ({ ...state, columns }));
     
@@ -127,7 +128,7 @@ export class StateManagerImpl<TData extends DataRecord> implements StateManager<
   /**
    * Update actions and notify observers
    */
-  updateActions(actions: any[]): void {
+  updateActions(actions: DataTableAction<TData>[]): void {
     this.setState(state => ({ ...state, actions }));
   }
 
@@ -151,7 +152,7 @@ export class StateManagerImpl<TData extends DataRecord> implements StateManager<
   /**
    * Update column filters
    */
-  updateColumnFilters(filters: Array<{ id: string; value: any }>): void {
+  updateColumnFilters(filters: Array<{ id: string; value: unknown }>): void {
     this.updateUI({ columnFilters: filters });
   }
 
@@ -200,7 +201,7 @@ export class StateManagerImpl<TData extends DataRecord> implements StateManager<
   /**
    * Update feature state
    */
-  updateFeatureState(featureName: string, state: any): void {
+  updateFeatureState(featureName: string, state: unknown): void {
     this.setState(currentState => ({
       ...currentState,
       features: new Map(currentState.features).set(featureName, state)
@@ -210,7 +211,7 @@ export class StateManagerImpl<TData extends DataRecord> implements StateManager<
   /**
    * Update plugin state
    */
-  updatePluginState(pluginName: string, state: any): void {
+  updatePluginState(pluginName: string, state: unknown): void {
     this.setState(currentState => ({
       ...currentState,
       plugins: new Map(currentState.plugins).set(pluginName, state)

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

@@ -0,0 +1,104 @@
+/**
+ * @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);
+  });
+});

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

@@ -0,0 +1,101 @@
+/**
+ * @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();
+  });
+});

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

@@ -0,0 +1,84 @@
+/**
+ * @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 and paginates slices', async () => {
+    const sortedDesc = await adapter.fetchData({ sortBy: 'name', sortDirection: 'desc' });
+    expect(sortedDesc.map(row => row.name)).toEqual(['Charlie', 'Bob', 'Alice']);
+
+    const paged = await adapter.fetchData({ page: 0, pageSize: 2 });
+    expect(paged).toHaveLength(2);
+    expect(paged[0].name).toBe('Alice');
+  });
+
+  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 and JSON formats while surfacing unsupported formats', async () => {
+    const csv = await adapter.exportData('csv', { includeHeaders: true });
+    expect(csv.split('\n')[0]).toContain('id');
+
+    const json = await adapter.exportData('json');
+    expect(JSON.parse(json)).toHaveLength(3);
+
+    await expect(adapter.exportData('xlsx')).resolves.toContain('Alice');
+    await expect(adapter.exportData('unsupported' as any)).rejects.toThrow('Unsupported export format: unsupported');
+  });
+});

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

@@ -0,0 +1,102 @@
+/**
+ * @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 and detects cycles', () => {
+    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'));
+
+    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();
+  });
+});

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

@@ -0,0 +1,104 @@
+/**
+ * @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/plugin state and resets 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' });
+
+    expect(manager.getState().features.get('aggregation')).toEqual({ enabled: true });
+    expect(manager.getState().plugins.get('export')).toEqual({ format: 'csv' });
+
+    manager.reset();
+    expect(manager.getState().ui.globalFilter).toBe('');
+    expect(manager.getState().features.size).toBe(0);
+  });
+});

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

@@ -56,19 +56,19 @@ export interface StateManager<TData extends DataRecord> {
   
   // Additional methods for convenience
   updateData(data: TData[]): void;
-  updateColumns(columns: any[]): void;
-  updateActions(actions: any[]): void;
+  updateColumns(columns: ColumnDef<TData>[]): void;
+  updateActions(actions: DataTableAction<TData>[]): void;
   updateUI(uiUpdates: Partial<UIState>): void;
   updateGlobalFilter(filter: string): void;
-  updateColumnFilters(filters: Array<{ id: string; value: any }>): void;
+  updateColumnFilters(filters: Array<{ id: string; value: unknown }>): void;
   updateSorting(sorting: Array<{ id: string; desc: boolean }>): void;
   updateGrouping(grouping: string[]): void;
   updatePagination(pagination: { pageIndex: number; pageSize: number }): void;
   updateRowSelection(selection: Record<string, boolean>): void;
   updateEditing(editing: DataTableState<TData>['ui']['editing']): void;
   updateModals(modals: DataTableState<TData>['ui']['modals']): void;
-  updateFeatureState(featureName: string, state: any): void;
-  updatePluginState(pluginName: string, state: any): void;
+  updateFeatureState(featureName: string, state: unknown): void;
+  updatePluginState(pluginName: string, state: unknown): void;
   setLoading(loading: boolean): void;
   setError(error: Error | null): void;
   reset(): void;
@@ -88,7 +88,7 @@ export interface DataTableFeature<TData extends DataRecord = DataRecord> {
   initialize(context: DataTableContext<TData>): void;
   render(): React.ReactNode;
   cleanup(): void;
-  getState(): any;
+  getState(): unknown;
 }
 
 /**
@@ -96,7 +96,7 @@ export interface DataTableFeature<TData extends DataRecord = DataRecord> {
  */
 export interface FeatureConfig {
   enabled: boolean;
-  options?: Record<string, any>;
+  options?: Record<string, unknown>;
 }
 
 // ============================================================================
@@ -161,7 +161,7 @@ export interface FetchOptions {
   pageSize?: number;
   sortBy?: string;
   sortDirection?: 'asc' | 'desc';
-  filters?: Record<string, any>;
+  filters?: Record<string, unknown>;
   search?: string;
 }
 
@@ -200,7 +200,7 @@ export interface DataTableObserver<TData extends DataRecord = DataRecord> {
 export interface Observable<TData extends DataRecord = DataRecord> {
   subscribe(observer: DataTableObserver<TData> | ((state: DataTableState<TData>) => void)): () => void;
   unsubscribe(observerId: string): void;
-  notify(event: string, data: any): void;
+  notify(event: string, data: unknown): void;
 }
 
 // ============================================================================
@@ -227,10 +227,10 @@ export interface DataTableState<TData extends DataRecord = DataRecord> {
   ui: UIState;
   
   // Feature state
-  features: Map<string, any>;
+  features: Map<string, unknown>;
   
   // Plugin state
-  plugins: Map<string, any>;
+  plugins: Map<string, unknown>;
 }
 
 /**
@@ -239,7 +239,7 @@ export interface DataTableState<TData extends DataRecord = DataRecord> {
 export interface UIState {
   // Filtering
   globalFilter: string;
-  columnFilters: Array<{ id: string; value: any }>;
+  columnFilters: Array<{ id: string; value: unknown }>;
   
   // Sorting
   sorting: Array<{ id: string; desc: boolean }>;
@@ -260,9 +260,9 @@ export interface UIState {
   // Editing
   editing: {
     rowId: string | null;
-    data: Record<string, any>;
+    data: Record<string, unknown>;
     isCreating: boolean;
-    creationData: Record<string, any>;
+    creationData: Record<string, unknown>;
   };
   
   // Modals
@@ -270,7 +270,7 @@ export interface UIState {
     import: boolean;
     export: boolean;
     view: boolean;
-    viewData: any;
+    viewData: unknown;
   };
 }
 
@@ -332,7 +332,7 @@ export interface DataTableConfig<TData extends DataRecord = DataRecord> {
  */
 export interface DataTableUtils<TData extends DataRecord = DataRecord> {
   getRowId: (row: TData, index: number) => string;
-  formatValue: (value: any, column: ColumnDef<TData>) => string;
+  formatValue: (value: unknown, column: ColumnDef<TData>) => string;
   validateData: (data: Partial<TData>) => string[] | null;
-  debounce: <T extends (...args: any[]) => any>(func: T, delay: number) => T;
+  debounce: <T extends (...args: unknown[]) => unknown>(func: T, delay: number) => T;
 }