@jmruthers/pace-core 0.5.118 → 0.5.120

package/src/components/DataTable/utils/__tests__/exportUtils.test.ts

@@ -6,7 +6,8 @@
  */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { generateCSVContent, exportToCSV } from '../exportUtils';
+import { generateCSVContent, exportToCSV, exportToCSVWithTableRows } from '../exportUtils';
+import type { ExportColumn } from '../exportUtils';
 
 // Mock DOM methods
 const mockCreateElement = vi.fn();
@@ -486,3 +487,456 @@ describe('[unit] CSV Escaping and Security', () => {
     expect(sanitized).toContain("'=FORMULA");
   });
 });
+
+describe('[unit] exportToCSVWithTableRows', () => {
+  let mockLink: any;
+  let mockColumnIdToTableColumn: Map<string, any>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    
+    mockLink = {
+      setAttribute: vi.fn(),
+      style: { display: 'none' },
+      click: vi.fn(() => {
+        // Simulate onclick being called after click
+        if (mockLink.onclick) {
+          mockLink.onclick();
+        }
+      }),
+      onclick: null as any,
+    };
+    
+    mockCreateElement.mockReturnValue(mockLink);
+    mockCreateObjectURL.mockReturnValue('blob:mock-url');
+    mockColumnIdToTableColumn = new Map();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  const createMockTableRow = (original: any, getValue: (columnId: string) => any = () => undefined) => ({
+    original,
+    getValue,
+    id: `row-${original.id}`,
+  });
+
+  it('exports CSV with table rows using getValue()', async () => {
+    const tableRows = [
+      createMockTableRow(
+        { id: 1, name: 'John Doe', email: 'john@example.com' },
+        (columnId) => {
+          if (columnId === 'name') return 'John Doe';
+          if (columnId === 'email') return 'john@example.com';
+          return undefined;
+        }
+      ),
+    ];
+
+    const columns: ExportColumn[] = [
+      { id: 'name', header: 'Name', accessorKey: 'name' },
+      { id: 'email', header: 'Email', accessorKey: 'email' },
+    ];
+
+    mockColumnIdToTableColumn.set('name', {});
+    mockColumnIdToTableColumn.set('email', {});
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn);
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    expect(csvContent).toContain('"Name","Email"');
+    expect(csvContent).toContain('"John Doe","john@example.com"');
+  });
+
+  it('handles ID columns by getting directly from original data', async () => {
+    const tableRows = [
+      createMockTableRow(
+        { id: 1, name: 'John Doe', referenceId: 'ref-123' },
+        (columnId) => {
+          if (columnId === 'name') return 'John Doe';
+          return undefined;
+        }
+      ),
+    ];
+
+    const columns: ExportColumn[] = [
+      { id: 'name', header: 'Name', accessorKey: 'name' },
+      { id: 'referenceId', header: 'Reference ID', accessorKey: 'referenceId', isIdColumn: true },
+    ];
+
+    mockColumnIdToTableColumn.set('name', {});
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn);
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    expect(csvContent).toContain('"Reference ID"');
+    expect(csvContent).toContain('"ref-123"');
+  });
+
+  it('falls back to accessorFn when getValue() fails', async () => {
+    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    
+    const tableRows = [
+      createMockTableRow(
+        { id: 1, name: 'John Doe' },
+        () => {
+          throw new Error('getValue failed');
+        }
+      ),
+    ];
+
+    const columns: ExportColumn[] = [
+      {
+        id: 'name',
+        header: 'Name',
+        accessorKey: 'name',
+        accessorFn: (row: any) => row.name.toUpperCase(),
+      },
+    ];
+
+    mockColumnIdToTableColumn.set('name', {});
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn);
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    expect(csvContent).toContain('"JOHN DOE"');
+    expect(consoleWarnSpy).not.toHaveBeenCalled();
+    
+    consoleWarnSpy.mockRestore();
+  });
+
+  it('falls back to direct property access when getValue() fails and no accessorFn', async () => {
+    const tableRows = [
+      createMockTableRow(
+        { id: 1, name: 'John Doe' },
+        () => {
+          throw new Error('getValue failed');
+        }
+      ),
+    ];
+
+    const columns: ExportColumn[] = [
+      { id: 'name', header: 'Name', accessorKey: 'name' },
+    ];
+
+    mockColumnIdToTableColumn.set('name', {});
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn);
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    expect(csvContent).toContain('"John Doe"');
+  });
+
+  it('handles accessorFn error gracefully', async () => {
+    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    
+    const tableRows = [
+      createMockTableRow(
+        { id: 1, name: 'John Doe' },
+        () => {
+          throw new Error('getValue failed');
+        }
+      ),
+    ];
+
+    const columns: ExportColumn[] = [
+      {
+        id: 'name',
+        header: 'Name',
+        accessorKey: 'name',
+        accessorFn: () => {
+          throw new Error('accessorFn failed');
+        },
+      },
+    ];
+
+    mockColumnIdToTableColumn.set('name', {});
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn);
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    // Should export empty value for failed accessorFn
+    expect(csvContent).toContain('"Name"');
+    expect(consoleWarnSpy).toHaveBeenCalled();
+    
+    consoleWarnSpy.mockRestore();
+  });
+
+  it('falls back to direct property access when column not in columnIdToTableColumn', async () => {
+    const tableRows = [
+      createMockTableRow({ id: 1, name: 'John Doe' }),
+    ];
+
+    const columns: ExportColumn[] = [
+      { id: 'name', header: 'Name', accessorKey: 'name' },
+    ];
+
+    // Don't add to columnIdToTableColumn
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn);
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    expect(csvContent).toContain('"John Doe"');
+  });
+
+  it('formats values according to locale', async () => {
+    const tableRows = [
+      createMockTableRow(
+        { id: 1, value: 1234.56, date: new Date('2025-01-15'), active: true },
+        (columnId) => {
+          if (columnId === 'value') return 1234.56;
+          if (columnId === 'date') return new Date('2025-01-15');
+          if (columnId === 'active') return true;
+          return undefined;
+        }
+      ),
+    ];
+
+    const columns: ExportColumn[] = [
+      { id: 'value', header: 'Value', accessorKey: 'value' },
+      { id: 'date', header: 'Date', accessorKey: 'date' },
+      { id: 'active', header: 'Active', accessorKey: 'active' },
+    ];
+
+    mockColumnIdToTableColumn.set('value', {});
+    mockColumnIdToTableColumn.set('date', {});
+    mockColumnIdToTableColumn.set('active', {});
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn, 'test.csv', {
+      locale: 'en-US',
+    });
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    // Locale formatting should be applied
+    expect(csvContent).toBeTruthy();
+  });
+
+  it('sanitizes values for security by default', async () => {
+    const tableRows = [
+      createMockTableRow(
+        { id: 1, name: '=SUM(A1:A10)' },
+        (columnId) => {
+          if (columnId === 'name') return '=SUM(A1:A10)';
+          return undefined;
+        }
+      ),
+    ];
+
+    const columns: ExportColumn[] = [
+      { id: 'name', header: 'Name', accessorKey: 'name' },
+    ];
+
+    mockColumnIdToTableColumn.set('name', {});
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn);
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    // Should sanitize CSV injection attempts
+    expect(csvContent).toContain("'=SUM");
+  });
+
+  it('allows disabling security sanitization', async () => {
+    const tableRows = [
+      createMockTableRow(
+        { id: 1, name: '=SUM(A1:A10)' },
+        (columnId) => {
+          if (columnId === 'name') return '=SUM(A1:A10)';
+          return undefined;
+        }
+      ),
+    ];
+
+    const columns: ExportColumn[] = [
+      { id: 'name', header: 'Name', accessorKey: 'name' },
+    ];
+
+    mockColumnIdToTableColumn.set('name', {});
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn, 'test.csv', {
+      sanitizeForSecurity: false,
+    });
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    // Should still quote but not prefix with single quote
+    expect(csvContent).toContain('"=SUM');
+    expect(csvContent).not.toContain("'=SUM");
+  });
+
+  it('throws error when window is undefined (SSR)', async () => {
+    const originalWindow = global.window;
+    // @ts-expect-error - Testing SSR scenario
+    delete global.window;
+
+    const tableRows = [createMockTableRow({ id: 1 })];
+    const columns: ExportColumn[] = [{ id: 'id', header: 'ID', accessorKey: 'id' }];
+
+    await expect(
+      exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn)
+    ).rejects.toThrow('CSV export is only available in browser environments');
+
+    global.window = originalWindow;
+  });
+
+  it('throws error when tableRows is empty', async () => {
+    const columns: ExportColumn[] = [{ id: 'id', header: 'ID', accessorKey: 'id' }];
+
+    await expect(
+      exportToCSVWithTableRows([], columns, mockColumnIdToTableColumn)
+    ).rejects.toThrow('No data to export');
+  });
+
+  it('throws error when columns is empty', async () => {
+    const tableRows = [createMockTableRow({ id: 1 })];
+
+    await expect(
+      exportToCSVWithTableRows(tableRows, [], mockColumnIdToTableColumn)
+    ).rejects.toThrow('No columns defined for export');
+  });
+
+  it('handles multiple rows correctly', async () => {
+    const tableRows = [
+      createMockTableRow(
+        { id: 1, name: 'John Doe' },
+        (columnId) => columnId === 'name' ? 'John Doe' : undefined
+      ),
+      createMockTableRow(
+        { id: 2, name: 'Jane Smith' },
+        (columnId) => columnId === 'name' ? 'Jane Smith' : undefined
+      ),
+    ];
+
+    const columns: ExportColumn[] = [
+      { id: 'name', header: 'Name', accessorKey: 'name' },
+    ];
+
+    mockColumnIdToTableColumn.set('name', {});
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn);
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    expect(csvContent).toContain('"John Doe"');
+    expect(csvContent).toContain('"Jane Smith"');
+  });
+
+  it('uses custom filename when provided', async () => {
+    const tableRows = [createMockTableRow({ id: 1 })];
+    const columns: ExportColumn[] = [{ id: 'id', header: 'ID', accessorKey: 'id' }];
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn, 'custom-export.csv');
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    expect(mockLink.setAttribute).toHaveBeenCalledWith('download', 'custom-export.csv');
+  });
+
+  it('handles columns with computed values via accessorFn in getValue()', async () => {
+    const tableRows = [
+      createMockTableRow(
+        { id: 1, firstName: 'John', lastName: 'Doe' },
+        (columnId) => {
+          if (columnId === 'fullName') return 'John Doe';
+          return undefined;
+        }
+      ),
+    ];
+
+    const columns: ExportColumn[] = [
+      {
+        id: 'fullName',
+        header: 'Full Name',
+        accessorFn: (row: any) => `${row.firstName} ${row.lastName}`,
+      },
+    ];
+
+    mockColumnIdToTableColumn.set('fullName', {});
+
+    const promise = exportToCSVWithTableRows(tableRows, columns, mockColumnIdToTableColumn);
+    
+    // Advance timers to trigger onclick setTimeout
+    vi.advanceTimersByTime(100);
+    
+    await promise;
+
+    const blobCall = mockCreateObjectURL.mock.calls[0][0];
+    const csvContent = blobCall.content[0];
+    
+    expect(csvContent).toContain('"Full Name"');
+    expect(csvContent).toContain('"John Doe"');
+  });
+});

package/src/components/Toast/Toast.tsx

@@ -12,7 +12,7 @@
  * - Customizable positioning and styling
  * - Swipe gestures for dismissal
  * - Keyboard navigation support
- * - Auto-dismiss with default 10 second duration managed internally
+ * - Auto-dismiss with default 5 second duration managed internally
  * - Action buttons and close functionality
  * - Responsive design
  * - Accessibility compliant

package/src/hooks/__tests__/index.unit.test.ts

@@ -0,0 +1,223 @@
+/**
+ * @file Hooks Index Exports Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/__tests__
+ * @since 0.1.0
+ *
+ * Tests to verify that all exports from the hooks index file are properly accessible.
+ * This ensures the module structure is correct and all re-exports work as expected.
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as Hooks from '../index';
+
+describe('hooks index exports', () => {
+  describe('UI Interaction Hooks', () => {
+    it('should export useToast', () => {
+      expect(Hooks).toHaveProperty('useToast');
+      expect(typeof Hooks.useToast).toBe('function');
+    });
+
+    it('should export useFocusManagement', () => {
+      expect(Hooks).toHaveProperty('useFocusManagement');
+      expect(typeof Hooks.useFocusManagement).toBe('function');
+    });
+
+    it('should export useFocusTrap', () => {
+      expect(Hooks).toHaveProperty('useFocusTrap');
+      expect(typeof Hooks.useFocusTrap).toBe('function');
+    });
+
+    it('should export useKeyboardShortcuts', () => {
+      expect(Hooks).toHaveProperty('useKeyboardShortcuts');
+      expect(typeof Hooks.useKeyboardShortcuts).toBe('function');
+    });
+
+    it('should export useIsMobile', () => {
+      expect(Hooks).toHaveProperty('useIsMobile');
+      expect(typeof Hooks.useIsMobile).toBe('function');
+    });
+  });
+
+  describe('Event Theming Hook', () => {
+    it('should export useEventTheme', () => {
+      expect(Hooks).toHaveProperty('useEventTheme');
+      expect(typeof Hooks.useEventTheme).toBe('function');
+    });
+  });
+
+  describe('Data & State Hooks', () => {
+    it('should export useDebounce', () => {
+      expect(Hooks).toHaveProperty('useDebounce');
+      expect(typeof Hooks.useDebounce).toBe('function');
+    });
+
+    it('should export useDataTableState', () => {
+      expect(Hooks).toHaveProperty('useDataTableState');
+      expect(typeof Hooks.useDataTableState).toBe('function');
+    });
+  });
+
+  describe('Organisation Hooks', () => {
+    it('should export useOrganisationPermissions', () => {
+      expect(Hooks).toHaveProperty('useOrganisationPermissions');
+      expect(typeof Hooks.useOrganisationPermissions).toBe('function');
+    });
+
+    it('should export useSecureDataAccess', () => {
+      expect(Hooks).toHaveProperty('useSecureDataAccess');
+      expect(typeof Hooks.useSecureDataAccess).toBe('function');
+    });
+
+    it('should export useOrganisationSecurity', () => {
+      expect(Hooks).toHaveProperty('useOrganisationSecurity');
+      expect(typeof Hooks.useOrganisationSecurity).toBe('function');
+    });
+  });
+
+  describe('Form Hooks', () => {
+    it('should export useZodForm', () => {
+      expect(Hooks).toHaveProperty('useZodForm');
+      expect(typeof Hooks.useZodForm).toBe('function');
+    });
+  });
+
+  describe('Performance Hooks', () => {
+    it('should export useComponentPerformance', () => {
+      expect(Hooks).toHaveProperty('useComponentPerformance');
+      expect(typeof Hooks.useComponentPerformance).toBe('function');
+    });
+
+    it('should export useAppConfig', () => {
+      expect(Hooks).toHaveProperty('useAppConfig');
+      expect(typeof Hooks.useAppConfig).toBe('function');
+    });
+
+    it('should export usePerformanceMonitor', () => {
+      expect(Hooks).toHaveProperty('usePerformanceMonitor');
+      expect(typeof Hooks.usePerformanceMonitor).toBe('function');
+    });
+
+    it('should export useDataTablePerformance', () => {
+      expect(Hooks).toHaveProperty('useDataTablePerformance');
+      expect(typeof Hooks.useDataTablePerformance).toBe('function');
+    });
+  });
+
+  describe('File Display Hooks', () => {
+    it('should export useFileDisplay', () => {
+      expect(Hooks).toHaveProperty('useFileDisplay');
+      expect(typeof Hooks.useFileDisplay).toBe('function');
+    });
+
+    it('should export clearFileDisplayCache', () => {
+      expect(Hooks).toHaveProperty('clearFileDisplayCache');
+      expect(typeof Hooks.clearFileDisplayCache).toBe('function');
+    });
+
+    it('should export getFileDisplayCacheStats', () => {
+      expect(Hooks).toHaveProperty('getFileDisplayCacheStats');
+      expect(typeof Hooks.getFileDisplayCacheStats).toBe('function');
+    });
+
+    it('should export invalidateFileDisplayCache', () => {
+      expect(Hooks).toHaveProperty('invalidateFileDisplayCache');
+      expect(typeof Hooks.invalidateFileDisplayCache).toBe('function');
+    });
+  });
+
+  describe('Public Data Access Hooks', () => {
+    it('should export public hooks via wildcard export', () => {
+      // Wildcard export from './public' should include public hooks
+      // These are tested through actual usage, but we verify the export path exists
+      expect(Hooks).toBeDefined();
+    });
+  });
+
+  describe('Type Exports', () => {
+    it('should export UseOrganisationPermissionsReturn type', () => {
+      // Type exports are compile-time only, but we verify they're referenced
+      // This is mainly for documentation purposes
+      expect(Hooks).toBeDefined();
+    });
+
+    it('should export SecureDataAccessReturn type', () => {
+      // Type exports are compile-time only
+      expect(Hooks).toBeDefined();
+    });
+
+    it('should export OrganisationSecurityHook type', () => {
+      // Type exports are compile-time only
+      expect(Hooks).toBeDefined();
+    });
+
+    it('should export UseAppConfigReturn type', () => {
+      // Type exports are compile-time only
+      expect(Hooks).toBeDefined();
+    });
+
+    it('should export UseDataTablePerformanceOptions type', () => {
+      // Type exports are compile-time only
+      expect(Hooks).toBeDefined();
+    });
+
+    it('should export UseDataTablePerformanceReturn type', () => {
+      // Type exports are compile-time only
+      expect(Hooks).toBeDefined();
+    });
+
+    it('should export UseFileDisplayReturn type', () => {
+      // Type exports are compile-time only
+      expect(Hooks).toBeDefined();
+    });
+
+    it('should export UseFileDisplayOptions type', () => {
+      // Type exports are compile-time only
+      expect(Hooks).toBeDefined();
+    });
+  });
+
+  describe('Module Structure', () => {
+    it('should maintain correct module structure for re-exports', () => {
+      // Verify that all hooks are functions
+      const hookNames = [
+        'useToast',
+        'useFocusManagement',
+        'useFocusTrap',
+        'useKeyboardShortcuts',
+        'useIsMobile',
+        'useEventTheme',
+        'useDebounce',
+        'useDataTableState',
+        'useOrganisationPermissions',
+        'useSecureDataAccess',
+        'useOrganisationSecurity',
+        'useZodForm',
+        'useComponentPerformance',
+        'useAppConfig',
+        'usePerformanceMonitor',
+        'useDataTablePerformance',
+        'useFileDisplay'
+      ];
+
+      hookNames.forEach((hookName) => {
+        expect(Hooks).toHaveProperty(hookName);
+        expect(typeof Hooks[hookName as keyof typeof Hooks]).toBe('function');
+      });
+    });
+
+    it('should export utility functions', () => {
+      const utilityFunctions = [
+        'clearFileDisplayCache',
+        'getFileDisplayCacheStats',
+        'invalidateFileDisplayCache'
+      ];
+
+      utilityFunctions.forEach((funcName) => {
+        expect(Hooks).toHaveProperty(funcName);
+        expect(typeof Hooks[funcName as keyof typeof Hooks]).toBe('function');
+      });
+    });
+  });
+});
+