@jmruthers/pace-core 0.5.191 → 0.6.1

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

@@ -70,7 +70,7 @@ describe('[component] DataTable', () => {
   const testData = createTestData(3);
   const testColumns = createTestColumns();
   const defaultRBAC = { pageId: 'test-page-id' };
-  const defaultProps = {
+  const baseProps = {
     data: testData,
     columns: testColumns,
     rbac: defaultRBAC,
@@ -90,7 +90,7 @@ describe('[component] DataTable', () => {
 
   describe('Rendering', () => {
     it('renders DataTableCore with required props', () => {
-      render(<DataTable {...defaultProps} />);
+      render(<DataTable {...baseProps} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
       expect(getMockedDataTableCore()).toHaveBeenCalledTimes(1);
@@ -99,7 +99,7 @@ describe('[component] DataTable', () => {
     it('renders with title and description', () => {
       render(
         <DataTable 
-          {...defaultProps} 
+          {...baseProps} 
           title="Test Table" 
           description="Test description" 
         />
@@ -111,14 +111,14 @@ describe('[component] DataTable', () => {
     });
 
     it('renders with custom variant', () => {
-      render(<DataTable {...defaultProps} variant="compact" />);
+      render(<DataTable {...baseProps} variant="compact" />);
       
       const core = screen.getByTestId('data-table-core');
       expect(core).toHaveAttribute('data-variant', 'compact');
     });
 
     it('renders with custom className', () => {
-      render(<DataTable {...defaultProps} className="custom-table-class" />);
+      render(<DataTable {...baseProps} className="custom-table-class" />);
       
       const core = screen.getByTestId('data-table-core');
       expect(core).toHaveAttribute('data-class-name', 'custom-table-class');
@@ -127,7 +127,7 @@ describe('[component] DataTable', () => {
 
   describe('Feature Configuration', () => {
     it('normalizes undefined features to default disabled features', () => {
-      render(<DataTable {...defaultProps} />);
+      render(<DataTable {...baseProps} />);
       
       const core = screen.getByTestId('data-table-core');
       const features = JSON.parse(core.getAttribute('data-features') || '{}');
@@ -157,7 +157,7 @@ describe('[component] DataTable', () => {
         pagination: true,
       };
       
-      render(<DataTable {...defaultProps} features={partialFeatures} />);
+      render(<DataTable {...baseProps} features={partialFeatures} />);
       
       const core = screen.getByTestId('data-table-core');
       const features = JSON.parse(core.getAttribute('data-features') || '{}');
@@ -170,7 +170,7 @@ describe('[component] DataTable', () => {
 
     it('passes fully normalized features to DataTableCore', () => {
       const features = createFullFeatures();
-      render(<DataTable {...defaultProps} features={features} />);
+      render(<DataTable {...baseProps} features={features} />);
       
       const core = screen.getByTestId('data-table-core');
       const normalizedFeatures = JSON.parse(core.getAttribute('data-features') || '{}');
@@ -192,11 +192,11 @@ describe('[component] DataTable', () => {
 
     it('memoizes normalized features when features prop does not change', () => {
       const features = createDefaultFeatures();
-      const { rerender } = render(<DataTable {...defaultProps} features={features} />);
+      const { rerender } = render(<DataTable {...baseProps} features={features} />);
       
       expect(getMockedDataTableCore()).toHaveBeenCalledTimes(1);
       
-      rerender(<DataTable {...defaultProps} features={features} />);
+      rerender(<DataTable {...baseProps} features={features} />);
       
       // Should not re-normalize if features object reference is the same
       expect(getMockedDataTableCore()).toHaveBeenCalledTimes(2);
@@ -205,14 +205,14 @@ describe('[component] DataTable', () => {
 
   describe('RBAC Configuration', () => {
     it('passes rbac with pageId to DataTableCore', () => {
-      render(<DataTable {...defaultProps} rbac={{ pageId: 'custom-page-id' }} />);
+      render(<DataTable {...baseProps} rbac={{ pageId: 'custom-page-id' }} />);
       
       const core = screen.getByTestId('data-table-core');
       expect(core).toHaveAttribute('data-page-id', 'custom-page-id');
     });
 
     it('passes rbac with pageName to DataTableCore', () => {
-      render(<DataTable {...defaultProps} rbac={{ pageName: 'custom-page-name' }} />);
+      render(<DataTable {...baseProps} rbac={{ pageName: 'custom-page-name' }} />);
       
       const core = screen.getByTestId('data-table-core');
       expect(core).toHaveAttribute('data-page-name', 'custom-page-name');
@@ -223,7 +223,7 @@ describe('[component] DataTable', () => {
     it('logs debug information in development mode', () => {
       // Note: Debug logging has been removed from DataTable component
       // The component now uses a logger utility instead of console.log
-      render(<DataTable {...defaultProps} />);
+      render(<DataTable {...baseProps} />);
       
       // Verify component renders correctly
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
@@ -241,7 +241,7 @@ describe('[component] DataTable', () => {
       mockLogger.info.mockClear();
       
       // Render without features prop - should trigger the warning in development mode
-      render(<DataTable {...defaultProps} />);
+      render(<DataTable {...baseProps} />);
       
       // Wait for useEffect to run - it runs after render
       // The effect checks: if (!features && import.meta.env?.MODE === 'development')
@@ -259,7 +259,7 @@ describe('[component] DataTable', () => {
     });
 
     it('does not log info message when features are provided', () => {
-      render(<DataTable {...defaultProps} features={createDefaultFeatures()} />);
+      render(<DataTable {...baseProps} features={createDefaultFeatures()} />);
       
       expect(mockLogger.info).not.toHaveBeenCalled();
     });
@@ -270,7 +270,7 @@ describe('[component] DataTable', () => {
         deletion: false,
       });
       
-      render(<DataTable {...defaultProps} features={invalidFeatures} />);
+      render(<DataTable {...baseProps} features={invalidFeatures} />);
       
       expect(mockLogger.warn).toHaveBeenCalledWith(
         'deleteSelected requires deletion to be enabled'
@@ -283,7 +283,7 @@ describe('[component] DataTable', () => {
         deletion: true,
       });
       
-      render(<DataTable {...defaultProps} features={validFeatures} />);
+      render(<DataTable {...baseProps} features={validFeatures} />);
       
       expect(mockLogger.warn).not.toHaveBeenCalled();
     });
@@ -292,81 +292,57 @@ describe('[component] DataTable', () => {
   describe('Event Handlers', () => {
     it('passes onEditRow handler to DataTableCore', () => {
       const onEditRow = vi.fn();
-      render(<DataTable {...defaultProps} onEditRow={onEditRow} />);
+      render(<DataTable {...baseProps} onEditRow={onEditRow} />);
       
-      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
-        expect.objectContaining({
-          onEditRow,
-        }),
-        expect.anything()
-      );
+      const mockCall = getMockedDataTableCore().mock.calls[0];
+      expect(mockCall[0]).toHaveProperty('onEditRow', onEditRow);
     });
 
     it('passes onDeleteRow handler to DataTableCore', () => {
       const onDeleteRow = vi.fn();
-      render(<DataTable {...defaultProps} onDeleteRow={onDeleteRow} />);
+      render(<DataTable {...baseProps} onDeleteRow={onDeleteRow} />);
       
-      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
-        expect.objectContaining({
-          onDeleteRow,
-        }),
-        expect.anything()
-      );
+      const mockCall = getMockedDataTableCore().mock.calls[0];
+      expect(mockCall[0]).toHaveProperty('onDeleteRow', onDeleteRow);
     });
 
     it('passes onCreateRow handler to DataTableCore', () => {
       const onCreateRow = vi.fn();
-      render(<DataTable {...defaultProps} onCreateRow={onCreateRow} />);
+      render(<DataTable {...baseProps} onCreateRow={onCreateRow} />);
       
-      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
-        expect.objectContaining({
-          onCreateRow,
-        }),
-        expect.anything()
-      );
+      const mockCall = getMockedDataTableCore().mock.calls[0];
+      expect(mockCall[0]).toHaveProperty('onCreateRow', onCreateRow);
     });
 
     it('passes onImport handler to DataTableCore', () => {
       const onImport = vi.fn();
-      render(<DataTable {...defaultProps} onImport={onImport} />);
+      render(<DataTable {...baseProps} onImport={onImport} />);
       
-      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
-        expect.objectContaining({
-          onImport,
-        }),
-        expect.anything()
-      );
+      const mockCall = getMockedDataTableCore().mock.calls[0];
+      expect(mockCall[0]).toHaveProperty('onImport', onImport);
     });
 
     it('passes onRowSelectionChange handler to DataTableCore', () => {
       const onRowSelectionChange = vi.fn();
-      render(<DataTable {...defaultProps} onRowSelectionChange={onRowSelectionChange} />);
+      render(<DataTable {...baseProps} onRowSelectionChange={onRowSelectionChange} />);
       
-      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
-        expect.objectContaining({
-          onRowSelectionChange,
-        }),
-        expect.anything()
-      );
+      const mockCall = getMockedDataTableCore().mock.calls[0];
+      expect(mockCall[0]).toHaveProperty('onRowSelectionChange', onRowSelectionChange);
     });
 
     it('passes onDeleteSelected handler to DataTableCore', () => {
       const onDeleteSelected = vi.fn();
-      render(<DataTable {...defaultProps} onDeleteSelected={onDeleteSelected} />);
+      render(<DataTable {...baseProps} onDeleteSelected={onDeleteSelected} />);
       
-      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
-        expect.objectContaining({
-          onDeleteSelected,
-        }),
-        expect.anything()
-      );
+      const mockCall = getMockedDataTableCore().mock.calls[0];
+      expect(mockCall[0]).toHaveProperty('onDeleteSelected', onDeleteSelected);
     });
   });
 
   describe('Data Handling', () => {
     it('handles empty data array', () => {
       // Note: Debug logging has been removed from DataTable component
-      render(<DataTable {...defaultProps} data={[]} />);
+      render(<DataTable {...baseProps} data={[]} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
     });
@@ -374,7 +350,7 @@ describe('[component] DataTable', () => {
     it('handles single data item', () => {
       // Note: Debug logging has been removed from DataTable component
       const singleData = testDataScenarios.single;
-      render(<DataTable {...defaultProps} data={singleData} />);
+      render(<DataTable {...baseProps} data={singleData} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
     });
@@ -382,14 +358,14 @@ describe('[component] DataTable', () => {
     it('handles large dataset', () => {
       // Note: Debug logging has been removed from DataTable component
       const largeData = testDataScenarios.large;
-      render(<DataTable {...defaultProps} data={largeData} />);
+      render(<DataTable {...baseProps} data={largeData} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
     });
 
     it('handles data with null values', () => {
       const dataWithNulls = testDataScenarios.withNulls;
-      render(<DataTable {...defaultProps} data={dataWithNulls} />);
+      render(<DataTable {...baseProps} data={dataWithNulls} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
     });
@@ -402,14 +378,10 @@ describe('[component] DataTable', () => {
         enableChunking: true,
       };
       
-      render(<DataTable {...defaultProps} performance={performance} />);
+      render(<DataTable {...baseProps} performance={performance} />);
       
-      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
-        expect.objectContaining({
-          performance,
-        }),
-        expect.anything()
-      );
+      const mockCall = getMockedDataTableCore().mock.calls[0];
+      expect(mockCall[0]).toHaveProperty('performance', performance);
     });
 
     it('passes serverSide config to DataTableCore', () => {
@@ -418,32 +390,24 @@ describe('[component] DataTable', () => {
         enableServerSorting: true,
       };
       
-      render(<DataTable {...defaultProps} serverSide={serverSide} />);
+      render(<DataTable {...baseProps} serverSide={serverSide} />);
       
-      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
-        expect.objectContaining({
-          serverSide,
-        }),
-        expect.anything()
-      );
+      const mockCall = getMockedDataTableCore().mock.calls[0];
+      expect(mockCall[0]).toHaveProperty('serverSide', serverSide);
     });
 
     it('passes paginationMode to DataTableCore', () => {
-      render(<DataTable {...defaultProps} paginationMode="server" />);
+      render(<DataTable {...baseProps} paginationMode="server" />);
       
-      expect(getMockedDataTableCore()).toHaveBeenCalledWith(
-        expect.objectContaining({
-          paginationMode: 'server',
-        }),
-        expect.anything()
-      );
+      const mockCall = getMockedDataTableCore().mock.calls[0];
+      expect(mockCall[0]).toHaveProperty('paginationMode', 'server');
     });
   });
 
   describe('Component Integration', () => {
     it('passes all props to DataTableCore except features', () => {
       const allProps = {
-        ...defaultProps,
+        ...baseProps,
         title: 'Test Table',
         description: 'Test description',
         variant: 'compact' as const,
@@ -490,7 +454,7 @@ describe('[component] DataTable', () => {
 
   describe('Memory Management', () => {
     it('cleans up resources on unmount', () => {
-      const { unmount } = render(<DataTable {...defaultProps} />);
+      const { unmount } = render(<DataTable {...baseProps} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
       
@@ -499,11 +463,11 @@ describe('[component] DataTable', () => {
     });
 
     it('handles rapid mount/unmount cycles', () => {
-      const { unmount: unmount1 } = render(<DataTable {...defaultProps} />);
+      const { unmount: unmount1 } = render(<DataTable {...baseProps} />);
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
       unmount1();
       
-      const { unmount: unmount2 } = render(<DataTable {...defaultProps} />);
+      const { unmount: unmount2 } = render(<DataTable {...baseProps} />);
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
       unmount2();
       
@@ -514,27 +478,27 @@ describe('[component] DataTable', () => {
   describe('Edge Cases', () => {
     it('handles missing columns gracefully', () => {
       // Note: Debug logging has been removed from DataTable component
-      render(<DataTable {...defaultProps} columns={[]} />);
+      render(<DataTable {...baseProps} columns={[]} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
     });
 
     it('handles undefined rbac pageId and pageName', () => {
       // Note: Debug logging has been removed from DataTable component
-      render(<DataTable {...defaultProps} rbac={{}} />);
+      render(<DataTable {...baseProps} rbac={{}} />);
       
       expect(screen.getByTestId('data-table-core')).toBeInTheDocument();
     });
 
     it('handles rapid feature prop changes', () => {
-      const { rerender } = render(<DataTable {...defaultProps} features={{ search: true }} />);
+      const { rerender } = render(<DataTable {...baseProps} features={{ search: true }} />);
       
       expect(getMockedDataTableCore()).toHaveBeenCalledTimes(1);
       
-      rerender(<DataTable {...defaultProps} features={{ search: false }} />);
+      rerender(<DataTable {...baseProps} features={{ search: false }} />);
       expect(getMockedDataTableCore()).toHaveBeenCalledTimes(2);
       
-      rerender(<DataTable {...defaultProps} features={{ search: true, pagination: true }} />);
+      rerender(<DataTable {...baseProps} features={{ search: true, pagination: true }} />);
       expect(getMockedDataTableCore()).toHaveBeenCalledTimes(3);
     });
   });

package/src/components/DataTable/DataTable.tsx

@@ -424,7 +424,7 @@ export interface DataTableProps<TData extends DataRecord> {
   /** Whether the table is in a loading state */
   isLoading?: boolean;
   /** Custom component to display when table is empty */
-  emptyState?: EmptyStateConfig | React.ReactElement;
+  emptyState?: EmptyStateConfig | React.ReactElement<any>;
   /** Array of aggregation functions for grouped data */
   aggregates?: AggregateConfig[];
   
@@ -463,7 +463,7 @@ export interface DataTableProps<TData extends DataRecord> {
  * Features are configured through the unified `features` prop for maximum flexibility.
  */
 export function DataTable<TData extends DataRecord>(props: DataTableProps<TData>) {
-  const logger = React.useMemo(() => createLogger('DataTable'), []);
+  const logger = createLogger('DataTable');
   const { features, ...rest } = props;
 
   const normalizedFeatures = React.useMemo(