@jmruthers/pace-core 0.5.134 → 0.5.136

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

@@ -17,7 +17,7 @@ const mockLogger = {
   info: vi.fn(),
 };
 
-vi.mock('../../../utils/logger', () => ({
+vi.mock('../../../utils/core/logger', () => ({
   createLogger: () => mockLogger,
 }));
 

package/src/components/DataTable/utils/aggregationUtils.ts

@@ -0,0 +1,161 @@
+/**
+ * @file Aggregation Utility Functions
+ * @package @jmruthers/pace-core
+ * @module Components/DataTable/Utils
+ * @since 0.6.0
+ * 
+ * Utility functions for common aggregation operations in grouped DataTable rows.
+ * These functions can be used as the `aggregateFn` property in column definitions.
+ */
+
+import type { DataTableColumn, DataRecord } from '../types';
+
+/**
+ * Creates a sum aggregation function for a specific field.
+ * 
+ * @param accessorKey - The field key to sum (e.g., 'cost', 'quantity')
+ * @returns An aggregation function that sums the specified field across all rows
+ * 
+ * @example
+ * ```tsx
+ * {
+ *   accessorKey: 'cost',
+ *   header: 'Total Cost',
+ *   aggregateFn: sum('cost'),
+ * }
+ * ```
+ */
+export function sum<TData extends DataRecord = DataRecord>(accessorKey: keyof TData | string) {
+  return <TRow extends DataRecord = TData>(rows: TRow[], column: DataTableColumn<TRow>): number => {
+    return rows.reduce((total, row) => {
+      const value = (row as any)[accessorKey];
+      const numValue = typeof value === 'number' ? value : parseFloat(String(value || 0));
+      return total + (isNaN(numValue) ? 0 : numValue);
+    }, 0);
+  };
+}
+
+/**
+ * Creates an average aggregation function for a specific field.
+ * 
+ * @param accessorKey - The field key to average (e.g., 'price', 'rating')
+ * @returns An aggregation function that calculates the average of the specified field across all rows
+ * 
+ * @example
+ * ```tsx
+ * {
+ *   accessorKey: 'price',
+ *   header: 'Avg Price',
+ *   aggregateFn: average('price'),
+ * }
+ * ```
+ */
+export function average<TData extends DataRecord = DataRecord>(accessorKey: keyof TData | string) {
+  return <TRow extends DataRecord = TData>(rows: TRow[], column: DataTableColumn<TRow>): number => {
+    if (rows.length === 0) return 0;
+    
+    const validValues = rows
+      .map(row => (row as any)[accessorKey])
+      .filter(value => value != null && value !== '')
+      .map(value => {
+        const numValue = typeof value === 'number' ? value : parseFloat(String(value));
+        return isNaN(numValue) ? null : numValue;
+      })
+      .filter((value): value is number => value !== null);
+    
+    if (validValues.length === 0) return 0;
+    
+    const sum = validValues.reduce((total, value) => total + value, 0);
+    return sum / validValues.length;
+  };
+}
+
+/**
+ * Creates a count aggregation function.
+ * Returns the number of rows in the group.
+ * 
+ * @returns An aggregation function that counts the number of rows
+ * 
+ * @example
+ * ```tsx
+ * {
+ *   accessorKey: 'id',
+ *   header: 'Count',
+ *   aggregateFn: count(),
+ * }
+ * ```
+ */
+export function count<TData extends DataRecord = DataRecord>() {
+  return <TRow extends DataRecord = TData>(rows: TRow[], column: DataTableColumn<TRow>): number => {
+    return rows.length;
+  };
+}
+
+/**
+ * Creates a minimum aggregation function for a specific field.
+ * 
+ * @param accessorKey - The field key to find the minimum of (e.g., 'price', 'date')
+ * @returns An aggregation function that returns the minimum value of the specified field
+ * 
+ * @example
+ * ```tsx
+ * {
+ *   accessorKey: 'price',
+ *   header: 'Min Price',
+ *   aggregateFn: min('price'),
+ * }
+ * ```
+ */
+export function min<TData extends DataRecord = DataRecord>(accessorKey: keyof TData | string) {
+  return <TRow extends DataRecord = TData>(rows: TRow[], column: DataTableColumn<TRow>): number | null => {
+    if (rows.length === 0) return null;
+    
+    const validValues = rows
+      .map(row => (row as any)[accessorKey])
+      .filter(value => value != null && value !== '')
+      .map(value => {
+        const numValue = typeof value === 'number' ? value : parseFloat(String(value));
+        return isNaN(numValue) ? null : numValue;
+      })
+      .filter((value): value is number => value !== null);
+    
+    if (validValues.length === 0) return null;
+    
+    return Math.min(...validValues);
+  };
+}
+
+/**
+ * Creates a maximum aggregation function for a specific field.
+ * 
+ * @param accessorKey - The field key to find the maximum of (e.g., 'price', 'date')
+ * @returns An aggregation function that returns the maximum value of the specified field
+ * 
+ * @example
+ * ```tsx
+ * {
+ *   accessorKey: 'price',
+ *   header: 'Max Price',
+ *   aggregateFn: max('price'),
+ * }
+ * ```
+ */
+export function max<TData extends DataRecord = DataRecord>(accessorKey: keyof TData | string) {
+  return <TRow extends DataRecord = TData>(rows: TRow[], column: DataTableColumn<TRow>): number | null => {
+    if (rows.length === 0) return null;
+    
+    const validValues = rows
+      .map(row => (row as any)[accessorKey])
+      .filter(value => value != null && value !== '')
+      .map(value => {
+        const numValue = typeof value === 'number' ? value : parseFloat(String(value));
+        return isNaN(numValue) ? null : numValue;
+      })
+      .filter((value): value is number => value !== null);
+    
+    if (validValues.length === 0) return null;
+    
+    return Math.max(...validValues);
+  };
+}
+

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

@@ -15,7 +15,7 @@
  * - Browser download handling
  */
 
-import { createLogger } from '../../../utils/logger';
+import { createLogger } from '../../../utils/core/logger';
 import type { DataRecord } from '../types';
 
 /**

package/src/components/DataTable/utils/flexibleImport.ts

@@ -8,7 +8,7 @@
  * This utility can be used across different data tables with different column structures.
  */
 
-import { createLogger } from '../../../utils/logger';
+import { createLogger } from '../../../utils/core/logger';
 import type { CellValue } from '../types';
 
 export interface ColumnMapping {
@@ -273,10 +273,6 @@ export function flexibleImport<T extends Record<string, unknown>>(
   };
 } {
   const logger = createLogger('FlexibleImport');
-  logger.info('Starting flexible import...');
-  logger.debug('Available CSV columns:', Object.keys(csvData[0] || {}));
-  logger.debug('Target fields:', targetFields);
-  
   const maxRows = options.maxRows || 10000;
   
   // Check row limit
@@ -354,7 +350,6 @@ export function flexibleImport<T extends Record<string, unknown>>(
                normalizedPossible.includes(normalizedCol);
       });
       if (found) {
-        logger.debug(`Mapped ${targetField} -> ${found}`);
         return found;
       }
     }
@@ -368,8 +363,6 @@ export function flexibleImport<T extends Record<string, unknown>>(
     mappings[field] = findColumn(field);
   });
   
-  logger.debug('Column mappings:', mappings);
-  
   // Enhanced date parsing with multiple format support
   const parseDate = (dateStr: string, fieldName?: string): Date | null => {
     if (!dateStr || typeof dateStr !== 'string') return null;
@@ -530,7 +523,6 @@ export function flexibleImport<T extends Record<string, unknown>>(
   
   for (let index = 0; index < csvData.length; index++) {
     const row = csvData[index];
-    logger.debug(`Processing row ${index + 1}:`, row);
     
     const transformedRow: Record<string, unknown> = {};
     let hasErrors = false;
@@ -563,8 +555,6 @@ export function flexibleImport<T extends Record<string, unknown>>(
     if (!options.schemaValidation || !hasErrors) {
       mappedData.push(transformedRow as T);
     }
-    
-    logger.debug(`Transformed row ${index + 1}:`, transformedRow);
   }
 
   // Calculate unique error rows (multiple errors per row still count as 1 error row)

package/src/components/DataTable/utils/index.ts

@@ -1,3 +1,4 @@
+export * from './aggregationUtils';
 export * from './exportUtils';
 export * from './rowUtils';
 export * from './hierarchicalUtils';

package/src/components/DataTable/utils/paginationUtils.ts

@@ -9,7 +9,7 @@
 
 import { Table } from '@tanstack/react-table';
 import type { PaginationMode, ServerSideResponse, DataRecord } from '../types';
-import { createLogger } from '../../../utils/logger';
+import { createLogger } from '../../../utils/core/logger';
 
 // ============================================================================
 // TYPES

package/src/components/Dialog/Dialog.tsx

@@ -156,8 +156,8 @@
 import * as React from 'react';
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 import { X } from 'lucide-react';
-import { cn } from '../../utils/cn';
-import { renderSafeHtml } from './utils/safeHtml';
+import { cn } from '../../utils/core/cn';
+import { renderSafeHtml } from '../../utils/validation/htmlSanitization';
 import { useState, useEffect } from 'react';
 import { debounce } from 'lodash';
 

package/src/components/ErrorBoundary/ErrorBoundary.test.tsx

@@ -12,7 +12,7 @@ import { ErrorBoundary } from './ErrorBoundary';
 import { renderWithProviders } from '../../__tests__/helpers/test-utils';
 
 // Mock the performance budget monitor
-vi.mock('../../utils/performanceBudgets', () => ({
+vi.mock('../../utils/performance/performanceBudgets', () => ({
   performanceBudgetMonitor: {
     measure: vi.fn()
   }
@@ -76,7 +76,21 @@ const RecoverableComponent = ({ shouldThrow = true }: { shouldThrow?: boolean })
 };
 
 describe('ErrorBoundary Component', () => {
+  let originalMode: string | undefined;
+
   beforeEach(() => {
+    // Ensure logger is enabled by setting MODE to development
+    originalMode = import.meta.env.MODE;
+    (import.meta.env as any).MODE = 'development';
+    
+    import('../../utils/core/logger').then(({ Logger, LogLevel }) => {
+      Logger.configure({
+        level: LogLevel.DEBUG,
+        includeTimestamp: false,
+        includeComponent: true,
+      });
+    });
+    
     vi.clearAllMocks();
     // Mock console methods to avoid noise in tests
     vi.spyOn(console, 'error').mockImplementation(() => {});
@@ -354,7 +368,7 @@ describe('ErrorBoundary Component', () => {
 
     it('calls performance monitor when error occurs', async () => {
       const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      const { performanceBudgetMonitor } = await import('../../utils/performanceBudgets');
+      const { performanceBudgetMonitor } = await import('../../utils/performance/performanceBudgets');
       
       renderWithProviders(
         <ErrorBoundary componentName="TestComponent">
@@ -387,12 +401,18 @@ describe('ErrorBoundary Component', () => {
       );
       
       await waitFor(() => {
-        expect(consoleSpy).toHaveBeenCalledWith(
-          expect.stringContaining('ErrorBoundary [TestComponent] caught error'),
-          expect.any(Error),
-          expect.any(Object)
+        // React logs its own error message first, then our logger logs
+        // Check that our logger was called with the correct format
+        const calls = consoleSpy.mock.calls;
+        const ourLogCall = calls.find(call => 
+          call[0] && typeof call[0] === 'string' && 
+          call[0].includes('[ERROR] [ErrorBoundary]') &&
+          call[0].includes('[TestComponent] Caught error')
         );
-      }, { interval: 10 });
+        expect(ourLogCall).toBeDefined();
+        expect(ourLogCall![1]).toBeInstanceOf(Error);
+        expect(ourLogCall![2]).toBeDefined();
+      }, { timeout: 2000 });
       
       consoleSpy.mockRestore();
     });
@@ -745,4 +765,12 @@ describe('ErrorBoundary Component', () => {
       consoleSpy.mockRestore();
     });
   });
+
+  afterEach(() => {
+    // Restore original mode
+    if (originalMode !== undefined) {
+      (import.meta.env as any).MODE = originalMode;
+    }
+    vi.clearAllMocks();
+  });
 });

package/src/components/ErrorBoundary/ErrorBoundary.tsx

@@ -81,7 +81,8 @@
  */
 
 import React, { Component, ReactNode } from 'react';
-import { performanceBudgetMonitor } from '../../utils/performanceBudgets';
+import { performanceBudgetMonitor } from '../../utils/performance/performanceBudgets';
+import { logger } from '../../utils/core/logger';
 
 /**
  * State interface for the ErrorBoundary component
@@ -165,7 +166,7 @@ export class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundarySt
     this.setState({ errorInfo });
     
     // Enhanced logging with component name and error ID
-    console.error(`ErrorBoundary [${componentName}] caught error ${errorId}:`, error, errorInfo);
+    logger.error('ErrorBoundary', `[${componentName}] Caught error ${errorId}:`, error, errorInfo);
     
     // Performance monitoring - track error occurrence
     performanceBudgetMonitor.measure('ERROR_BOUNDARY_TRIGGER', 1, {
@@ -191,7 +192,7 @@ export class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundarySt
     if (import.meta.env.MODE === 'production') {
       // Example: Send to error reporting service
       // errorReportingService.report({ error, errorInfo, errorId, componentName });
-      console.warn('Error reporting would be triggered in production:', { errorId, componentName });
+      logger.warn('ErrorBoundary', 'Error reporting would be triggered in production:', { errorId, componentName });
     }
   };
 
@@ -200,7 +201,7 @@ export class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundarySt
     const { retryCount } = this.state;
 
     if (retryCount < maxRetries) {
-      console.log(`Retrying component render (attempt ${retryCount + 1}/${maxRetries})`);
+      logger.debug('ErrorBoundary', `Retrying component render (attempt ${retryCount + 1}/${maxRetries})`);
       
       this.setState(prevState => ({
         hasError: false,

package/src/components/EventSelector/EventSelector.tsx

@@ -92,7 +92,8 @@ import { RefreshCw, AlertCircle, Lock, Calendar, Star } from 'lucide-react';
 import { useEvents } from '../../hooks/useEvents';
 import { Event } from '../../types';
 import { useEffect, useMemo } from 'react';
-import { cn } from '../../utils/cn';
+import { cn } from '../../utils/core/cn';
+import { logger } from '../../utils/core/logger';
 
 export interface EventSelectorProps {
   /** Placeholder text for the dropdown */
@@ -145,7 +146,7 @@ export function EventSelector({
     refreshEvents,
   } = useEvents();
 
-  console.log('[EventSelector] Component render:', {
+  logger.debug('EventSelector', 'Component render:', {
     eventsCount: events.length,
     events: events.map(e => ({ id: e.event_id, name: e.event_name })),
     selectedEvent: selectedEvent ? { id: selectedEvent.event_id, name: selectedEvent.event_name } : null,

package/src/components/FileDisplay/FileDisplay.tsx

@@ -7,6 +7,7 @@ import { PublicPageContext, useIsPublicPage } from '../PublicLayout/PublicPagePr
 import { useUnifiedAuth } from '../../providers/services/UnifiedAuthProvider';
 import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogBody, DialogFooter } from '../Dialog/Dialog';
 import { Button } from '../Button/Button';
+import { logger } from '../../utils/core/logger';
 
 /**
  * Size classes for fallback display
@@ -502,21 +503,6 @@ function FileDisplayPublic({
   const publicPageContext = useContext(PublicPageContext);
   const supabase = publicPageContext?.supabase ?? null;
 
-  // Step 4: Log Supabase client context
-  console.log('[FileDisplayPublic] Supabase Client Context:', {
-    hasPublicPageContext: !!publicPageContext,
-    hasSupabaseClient: !!supabase,
-    supabaseUrl: publicPageContext?.environment?.supabaseUrl || 'not available',
-    hasAnonKey: !!publicPageContext?.environment?.supabaseKey,
-    hasAuth: !!supabase?.auth,
-    organisation_id,
-    table_name,
-    record_id,
-    category,
-    context: 'public_page_anonymous_user',
-    note: 'Public pages use anonymous Supabase client (no user session)'
-  });
-
   if (!supabase) {
     // If fallback is enabled, show fallback UI instead of error
     if (showFallback) {
@@ -573,7 +559,7 @@ function FileDisplayPublic({
 
   // Log errors for debugging public file display issues
   if (error) {
-    console.error('[FileDisplayPublic] Error fetching file:', {
+    logger.error('FileDisplayPublic', 'Error fetching file', {
       table_name,
       record_id,
       organisation_id,
@@ -583,26 +569,6 @@ function FileDisplayPublic({
     });
   }
 
-  // Log when file is successfully loaded
-  if (fileUrl && !isLoading && !error) {
-    console.log('[FileDisplayPublic] File loaded successfully:', {
-      table_name,
-      record_id,
-      category,
-      fileUrl: fileUrl.substring(0, 50) + '...' // Truncate URL for logging
-    });
-  }
-
-  // Log when no file is found (but not an error - might be expected)
-  if (!isLoading && !error && !fileUrl && !fileReference) {
-    console.log('[FileDisplayPublic] No file found (will show fallback if enabled):', {
-      table_name,
-      record_id,
-      category,
-      showFallback
-    });
-  }
-
   // Public context doesn't support delete operations
   const handleDelete = async () => {
     // Delete operations are not available in public context for security reasons

package/src/components/FileUpload/FileUpload.test.tsx

@@ -161,8 +161,8 @@ import { renderWithProviders, createMockSupabaseClient } from '../../__tests__/h
 
 // Mock dependencies
 import * as useFileReferenceModule from '../../hooks/useFileReference';
-import * as appNameResolver from '../../utils/appNameResolver';
-import * as appIdResolver from '../../utils/appIdResolver';
+import * as appNameResolver from '../../utils/app/appNameResolver';
+import * as appIdResolver from '../../utils/app/appIdResolver';
 
 const mockUseFileReference = vi.fn();
 const mockGetCurrentAppName = vi.fn();

package/src/components/FileUpload/FileUpload.tsx

@@ -5,8 +5,8 @@ import React, { useState, useCallback, useRef, useEffect, useMemo } from 'react'
 import { SupabaseClient } from '@supabase/supabase-js';
 import { FileCategory, FileUploadResult, UploadProgress } from '../../types/file-reference';
 import { useFileReference } from '../../hooks/useFileReference';
-import { getCurrentAppName } from '../../utils/appNameResolver';
-import { getAppId } from '../../utils/appIdResolver';
+import { getCurrentAppName } from '../../utils/app/appNameResolver';
+import { getAppId } from '../../utils/app/appIdResolver';
 
 export interface FileUploadProps {
   supabase: SupabaseClient;

package/src/components/Footer/Footer.tsx

@@ -85,7 +85,7 @@
  * - Tailwind CSS - Styling
  */
 import React from 'react';
-import { cn } from '../../utils/cn';
+import { cn } from '../../utils/core/cn';
 
 export interface FooterProps {
   /**