@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/hooks/useDataTablePerformance.ts

@@ -33,6 +33,98 @@ import {
 } from '../components/DataTable/utils/errorHandling';
 import { logger } from '../utils/core/logger';
 
+/** Error state and recovery returned by useDataTableErrorRecovery */
+export interface DataTableErrorRecoveryReturn {
+  errorState: {
+    hasErrors: boolean;
+    errorCount: number;
+    lastError: DataTableError | null;
+    fallbacksActive: string[];
+  };
+  retryLastOperation: () => Promise<void>;
+  clearErrors: () => void;
+}
+
+/** Hook for DataTable error state and recovery. Extracted to keep useDataTablePerformance under max-lines. */
+function useDataTableErrorRecovery(
+  fallbackConfig: FallbackConfig,
+  _onError: ((error: DataTableError) => void) | undefined,
+  _enableErrorRecovery: boolean
+): DataTableErrorRecoveryReturn {
+  const [errorState, setErrorState] = useState({
+    hasErrors: false,
+    errorCount: 0,
+    lastError: null as DataTableError | null,
+    fallbacksActive: [] as string[],
+  });
+  const [lastFailedOperation, setLastFailedOperation] = useState<(() => Promise<unknown>) | null>(null);
+  const errorRecoveryManagerRef = useRef<ErrorRecoveryManager>(new ErrorRecoveryManager(fallbackConfig));
+
+  const retryLastOperation = useCallback(async () => {
+    if (lastFailedOperation) {
+      try {
+        await lastFailedOperation();
+        setLastFailedOperation(null);
+        setErrorState(prev => ({ ...prev, hasErrors: false }));
+      } catch (error) {
+        logger.error('useDataTablePerformance', 'Retry failed:', error);
+      }
+    }
+  }, [lastFailedOperation]);
+
+  const clearErrors = useCallback(() => {
+    setErrorState({
+      hasErrors: false,
+      errorCount: 0,
+      lastError: null,
+      fallbacksActive: [],
+    });
+    setLastFailedOperation(null);
+    errorRecoveryManagerRef.current.clearErrorLog();
+  }, []);
+
+  return { errorState, retryLastOperation, clearErrors };
+}
+
+/** Computed values for DataTable performance. Extracted to keep useDataTablePerformance under max-lines. */
+function useDataTablePerformanceComputed<TData extends DataRecord>(
+  data: TData[],
+  serverSide: ServerSideConfig<TData> | undefined,
+  serverData: ServerSideResponse<TData> | null,
+  searchQuery: string,
+  searchResults: number[],
+  performance: PerformanceConfig
+): {
+  paginationMode: PaginationMode;
+  isVirtualized: boolean;
+  pageSizeOptions: number[];
+  processedData: TData[];
+  totalCount: number;
+} {
+  const paginationMode = useMemo(() => {
+    if (serverSide) return 'server';
+    return determinePaginationMode(data?.length || 0, performance.serverSideThreshold);
+  }, [data?.length, performance.serverSideThreshold, serverSide]);
+  const isVirtualized = false;
+  const pageSizeOptions = useMemo(
+    () => getOptimalPageSizeOptions(paginationMode, data?.length || 0),
+    [paginationMode, data?.length]
+  );
+  const processedData = useMemo(() => {
+    if (serverSide && serverData) return serverData.data;
+    let filteredData = data;
+    if (searchQuery && searchResults.length > 0) {
+      filteredData = searchResults.map(index => data[index]);
+    }
+    return filteredData;
+  }, [data, serverData, searchQuery, searchResults, serverSide]);
+  const totalCount = useMemo(() => {
+    if (serverSide && serverData) return serverData.totalCount;
+    return processedData?.length || 0;
+  }, [serverData, processedData?.length, serverSide]);
+  return { paginationMode, isVirtualized, pageSizeOptions, processedData, totalCount };
+}
+
 export interface UseDataTablePerformanceOptions<TData extends DataRecord> {
   data: TData[];
   performance?: PerformanceConfig;
@@ -104,15 +196,12 @@ export function useDataTablePerformance<TData extends DataRecord>({
   const [searchResults, setSearchResults] = useState<number[]>([]);
   const [serverData, setServerData] = useState<ServerSideResponse<TData> | null>(null);
   const [memoryUsage, setMemoryUsage] = useState(0);
-  
-  // Error handling state
-  const [errorState, setErrorState] = useState({
-    hasErrors: false,
-    errorCount: 0,
-    lastError: null as DataTableError | null,
-    fallbacksActive: [] as string[],
-  });
-  const [lastFailedOperation, setLastFailedOperation] = useState<(() => Promise<unknown>) | null>(null);
+
+  const { errorState, retryLastOperation, clearErrors } = useDataTableErrorRecovery(
+    fallbackConfig,
+    onError,
+    enableErrorRecovery
+  );
 
   // ============================================================================
   // REFS AND MANAGERS
@@ -121,60 +210,10 @@ export function useDataTablePerformance<TData extends DataRecord>({
   const chunkManagerRef = useRef<DataChunkManager<TData> | null>(null);
   const searchIndexRef = useRef<SearchIndex<TData> | null>(null);
   const visibilityTrackerRef = useRef<VisibilityTracker | null>(null);
-  
-  // Error handling managers
-  const errorRecoveryManagerRef = useRef<ErrorRecoveryManager>(new ErrorRecoveryManager(fallbackConfig));
   const memoryMonitorRef = useRef<MemoryMonitor | null>(null);
 
-  // ============================================================================
-  // COMPUTED VALUES
-  // ============================================================================
-  
-  const paginationMode = useMemo(() => {
-    // CRITICAL FIX: Only use 'server' mode if serverSide config is explicitly provided.
-    // determinePaginationMode now never returns 'server' - it only returns 'client' or 'hybrid'.
-    // This fixes pagination issues where large datasets would auto-detect 'server' mode
-    // but have no serverSide config, causing pagination controls to break.
-    if (serverSide) return 'server';
-    return determinePaginationMode(data?.length || 0, performance.serverSideThreshold);
-  }, [data?.length, performance.serverSideThreshold, serverSide]);
-
-  // Virtualization is now handled internally by UnifiedTableBody
-  const isVirtualized = false;
-
-  const pageSizeOptions = useMemo(() => {
-    return getOptimalPageSizeOptions(paginationMode, data?.length || 0);
-  }, [paginationMode, data?.length]);
-
-  // ============================================================================
-  // DATA PROCESSING
-  // ============================================================================
-  
-  const processedData = useMemo(() => {
-    if (serverSide && serverData) {
-      return serverData.data;
-    }
-
-    let filteredData = data;
-    
-    // Apply search filtering - ensure we don't exclude zero values
-    if (searchQuery && searchResults.length > 0) {
-      filteredData = searchResults.map(index => data[index]);
-    }
-
-    // Important: Ensure we don't accidentally filter out rows with zero values
-    // This was causing "no data" issues when rows contained zero values in numeric columns
-    // The filtering should be explicit, not implicit based on falsy values
-
-    return filteredData;
-  }, [data, serverData, searchQuery, searchResults, serverSide]);
-
-  const totalCount = useMemo(() => {
-    if (serverSide && serverData) {
-      return serverData.totalCount;
-    }
-    return processedData?.length || 0;
-  }, [serverData, processedData?.length, serverSide]);
+  const { paginationMode, isVirtualized, pageSizeOptions, processedData, totalCount } =
+    useDataTablePerformanceComputed(data, serverSide, serverData, searchQuery, searchResults, performance);
 
   // ============================================================================
   // CHUNK MANAGEMENT
@@ -290,61 +329,6 @@ export function useDataTablePerformance<TData extends DataRecord>({
     };
   }, [processedData]);
 
-  // ============================================================================
-  // ERROR HANDLING FUNCTIONS
-  // ============================================================================
-  
-  const _handleError = useCallback(async (error: DataTableError, operation?: () => Promise<unknown>) => {
-    if (enableErrorRecovery) {
-      try {
-        const recovery = await errorRecoveryManagerRef.current.handleError(error);
-        setErrorState(prev => ({
-          hasErrors: true,
-          errorCount: prev.errorCount + 1,
-          lastError: error,
-          fallbacksActive: [...prev.fallbacksActive, error.type],
-        }));
-        
-        if (operation) {
-          setLastFailedOperation(() => operation);
-        }
-        
-        onError?.(error);
-        return recovery;
-      } catch (recoveryError) {
-        logger.error('useDataTablePerformance', 'Error recovery failed:', recoveryError);
-      }
-    }
-    throw error;
-  }, [enableErrorRecovery, onError]);
-
-  const retryLastOperation = useCallback(async () => {
-    if (lastFailedOperation) {
-      try {
-        await lastFailedOperation();
-        setLastFailedOperation(null);
-        setErrorState(prev => ({ ...prev, hasErrors: false }));
-      } catch (error) {
-        logger.error('useDataTablePerformance', 'Retry failed:', error);
-      }
-    }
-  }, [lastFailedOperation]);
-
-  const clearErrors = useCallback(() => {
-    setErrorState({
-      hasErrors: false,
-      errorCount: 0,
-      lastError: null,
-      fallbacksActive: [],
-    });
-    setLastFailedOperation(null);
-    errorRecoveryManagerRef.current.clearErrorLog();
-  }, []);
-
-  // ============================================================================
-  // CLEANUP
-  // ============================================================================
-  
   const cleanup = useCallback(() => {
     chunkManagerRef.current?.clear();
     visibilityTrackerRef.current?.destroy();
@@ -355,10 +339,6 @@ export function useDataTablePerformance<TData extends DataRecord>({
     return cleanup;
   }, [cleanup]);
 
-  // ============================================================================
-  // RETURN VALUES
-  // ============================================================================
-  
   return {
     // Performance state
     paginationMode,

package/src/hooks/{__tests__/useDataTablePerformance.unit.test.ts → useDataTablePerformance.unit.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file useDataTablePerformance Hook Unit Tests
  * @package @jmruthers/pace-core
- * @module Hooks/__tests__
+ * @module Hooks
  * @since 0.3.0
  *
  * Tests focus on behavior: pagination mode determination, search functionality, server-side fetching,
@@ -10,11 +10,11 @@
 
 import { renderHook, waitFor, act } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { useDataTablePerformance } from '../useDataTablePerformance';
+import { useDataTablePerformance } from './useDataTablePerformance';
 import type { DataRecord, ServerSideConfig, ServerSideParams, ServerSideResponse } from '../../components/DataTable/types';
 
 // Mock performance utilities
-vi.mock('../../components/DataTable/utils/performanceUtils', () => ({
+vi.mock('../components/DataTable/utils/performanceUtils', () => ({
   determinePaginationMode: vi.fn((length: number) => {
     if (length < 1000) return 'client';
     return 'hybrid';
@@ -50,7 +50,7 @@ vi.mock('../../components/DataTable/utils/performanceUtils', () => ({
 }));
 
 // Mock error handling utilities
-vi.mock('../../components/DataTable/utils/errorHandling', () => ({
+vi.mock('../components/DataTable/utils/errorHandling', () => ({
   ErrorRecoveryManager: class {
     handleError = vi.fn().mockResolvedValue({ recovered: true });
     clearErrorLog = vi.fn();
@@ -81,7 +81,7 @@ vi.mock('../../components/DataTable/utils/errorHandling', () => ({
   safeExecute: vi.fn((fn: Function) => Promise.resolve(fn()))
 }));
 
-import { determinePaginationMode, getOptimalPageSizeOptions } from '../../components/DataTable/utils/performanceUtils';
+import { determinePaginationMode, getOptimalPageSizeOptions } from '../components/DataTable/utils/performanceUtils';
 
 describe('useDataTablePerformance Hook', () => {
   interface TestRecord extends DataRecord {

package/src/hooks/{__tests__/useDataTableState.test.ts → useDataTableState.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file useDataTableState Hook Unit Tests
  * @package @jmruthers/pace-core
- * @module Hooks/__tests__
+ * @module Hooks
  * @since 0.1.0
  *
  * Tests focus on behavior: pagination, selection, filtering, sorting, and state management.
@@ -9,7 +9,7 @@
 
 import { renderHook, act } from '@testing-library/react';
 import { describe, it, expect } from 'vitest';
-import { useDataTableState } from '../useDataTableState';
+import { useDataTableState } from './useDataTableState';
 
 const sampleData = Array.from({ length: 25 }, (_, i) => ({ id: i, name: `Item ${i}` }));
 

package/src/hooks/{__tests__/useDebounce.unit.test.ts → useDebounce.unit.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file useDebounce Hook Unit Tests
  * @package @jmruthers/pace-core
- * @module Hooks/__tests__
+ * @module Hooks
  * @since 0.1.0
  *
  * Tests focus on behavior: debouncing value changes, timer reset on rapid changes, and edge cases.
@@ -9,7 +9,7 @@
 
 import { renderHook, act } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { useDebounce } from '../useDebounce';
+import { useDebounce } from './useDebounce';
 
 describe('useDebounce Hook', () => {
   beforeEach(() => {

package/src/hooks/useEventTheme.test.ts

@@ -23,9 +23,12 @@ vi.mock('../theming/runtime', () => ({
   clearPalette: vi.fn()
 }));
 
-// Mock the Logger module
+// Mock the Logger module (hook uses log.debug and log.error)
 vi.mock('../utils/core/logger', () => {
   const mockLoggerInstance = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
     error: vi.fn(),
   };
   return {

package/src/hooks/useEventTheme.ts

@@ -106,8 +106,44 @@ export function useEventTheme(event?: Event | null): void {
   // Use EventServiceContext directly to handle missing provider gracefully
   // This allows the hook to work in public pages without EventProvider
   const eventServiceContext = useContext(EventServiceContext);
-  const eventsContextSelectedEvent = eventServiceContext?.eventService?.getSelectedEvent() ?? null;
-  
+  const eventService = eventServiceContext?.eventService ?? null;
+
+  // In authenticated mode (no event prop), subscribe to EventService and apply theme in the
+  // subscription callback. All events use the same CSS variables; we only overwrite with
+  // applyPalette(). We call clearPalette() only when there is genuinely no event selected.
+  useEffect(() => {
+    if (event !== undefined || !eventService) return;
+    const applyThemeFromService = () => {
+      const isOnLoginRoute = location.pathname === '/login' || location.pathname.startsWith('/login/');
+      if (isOnLoginRoute) {
+        clearPalette();
+        return;
+      }
+      const current = eventService.getSelectedEvent();
+      if (!current?.event_colours) {
+        clearPalette();
+        return;
+      }
+      const normalized = parseAndNormalizeEventColours(current.event_colours);
+      if (normalized) {
+        try {
+          applyPalette(normalized, current.event_name ?? '');
+        } catch (err) {
+          log.error('Failed to apply event palette (subscription):', err);
+        }
+      } else {
+        clearPalette();
+      }
+    };
+    applyThemeFromService();
+    const unsubscribe = eventService.subscribe(applyThemeFromService);
+    return () => {
+      unsubscribe();
+    };
+  }, [event, eventService, location.pathname]);
+
+  const eventsContextSelectedEvent = eventService?.getSelectedEvent() ?? null;
+
   // Determine which event to use: event prop (public mode) or EventProvider context (authenticated mode)
   // If event prop is provided, use it (public page mode)
   // Otherwise, use EventProvider context (authenticated mode)
@@ -116,45 +152,37 @@ export function useEventTheme(event?: Event | null): void {
     : eventsContextSelectedEvent;  // Authenticated mode - use EventProvider context
 
   useEffect(() => {
-    // Skip theme application when on login route
-    // This prevents event colors from styling the login screen
     const isOnLoginRoute = location.pathname === '/login' || location.pathname.startsWith('/login');
-    
+
     if (isOnLoginRoute) {
-      // Clear any active theme when on login route
       clearPalette();
       return;
     }
 
-    // If there's no selected event, clear any dynamic theming
+    // Authenticated mode: subscription is the only place that apply/clear; never run here
+    // (selectedEvent can be stale; calling clearPalette() here was wiping --print-event-name).
+    if (event === undefined) {
+      return;
+    }
+
+    // Public page mode: apply when we have an event, clear only when we genuinely have none
     if (!selectedEvent) {
       clearPalette();
       return;
     }
 
-    // Check if the event has theme colors
     const eventColours = selectedEvent.event_colours;
-
-    // Parse and normalize event_colours using shared utility
     const normalized = parseAndNormalizeEventColours(eventColours);
-    
+
     if (!normalized) {
       clearPalette();
       return;
     }
 
-    // Apply the normalized palette
     try {
-      applyPalette(normalized);
+      applyPalette(normalized, selectedEvent.event_name ?? '');
     } catch (error) {
-      // Log error but don't throw - theming is not critical
       log.error('Failed to apply event palette:', error);
     }
-
-    // Cleanup function to clear palette when component unmounts or event changes
-    return () => {
-      // Don't clear on unmount since we want the theme to persist
-      // The next event selection will update it
-    };
-  }, [selectedEvent, location.pathname]);
+  }, [selectedEvent, location.pathname, event]);
 }

package/src/hooks/useEvents.ts

@@ -11,10 +11,50 @@
  * For better performance, consider using useEventService directly.
  */
 
-import { useMemo, useRef } from 'react';
+import { useContext, useState, useEffect, useMemo, useRef } from 'react';
+import { EventServiceContext } from '../providers/services/EventServiceContext';
 import { useEventService } from './services/useEventService';
 import { Event } from '../types/event';
 
+/** Stable return value when EventServiceProvider is not present (avoids unnecessary re-renders). */
+const EMPTY_OPTIONAL_EVENTS: { selectedEvent: Event | null } = { selectedEvent: null };
+
+/**
+ * Optional event context hook that never throws.
+ * Use when a component must work with or without EventServiceProvider (e.g. PaceAppLayout).
+ *
+ * @returns `{ selectedEvent: Event | null }` — when provider is absent, `selectedEvent` is always null.
+ * @example
+ * const { selectedEvent } = useOptionalEvents();
+ * // selectedEvent is null when outside EventServiceProvider; otherwise the current selected event.
+ */
+export function useOptionalEvents(): { selectedEvent: Event | null } {
+  const context = useContext(EventServiceContext);
+
+  const [selectedEvent, setSelectedEvent] = useState<Event | null>(() =>
+    context?.eventService?.getSelectedEvent() ?? null
+  );
+
+  useEffect(() => {
+    if (!context) {
+      setSelectedEvent(null);
+      return undefined;
+    }
+    setSelectedEvent(context.eventService.getSelectedEvent());
+    const unsubscribe = context.eventService.subscribe(() => {
+      setSelectedEvent(context.eventService.getSelectedEvent());
+    });
+    return unsubscribe;
+  }, [context]);
+
+  return useMemo(() => {
+    if (!context) {
+      return EMPTY_OPTIONAL_EVENTS;
+    }
+    return { selectedEvent };
+  }, [context, selectedEvent]);
+}
+
 export interface EventContextType {
   events: Event[];
   selectedEvent: Event | null;

package/src/hooks/{__tests__/useEvents.unit.test.ts → useEvents.unit.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file useEvents Hook Unit Tests
  * @package @jmruthers/pace-core
- * @module Hooks/__tests__
+ * @module Hooks
  * @since 0.1.0
  *
  * Tests focus on behavior: accessing events, selecting events, refreshing, and clearing selection.
@@ -10,9 +10,9 @@
 
 import { renderHook, act } from '@testing-library/react';
 import { vi, describe, it, expect, beforeEach } from 'vitest';
-import { useEvents } from '../useEvents';
-import { Event } from '../../types/event';
-import { assertOrganisationId } from '../../types/core';
+import { useEvents } from './useEvents';
+import { Event } from '../types/event';
+import { assertOrganisationId } from '../types/core';
 
 // Mock useEventService
 const mockEventService = {
@@ -26,7 +26,7 @@ const mockEventService = {
   subscribe: vi.fn(() => vi.fn()), // Returns unsubscribe function
 };
 
-vi.mock('../services/useEventService', () => ({
+vi.mock('./services/useEventService', () => ({
   useEventService: vi.fn(() => mockEventService),
 }));