@jmruthers/pace-core 0.6.6 → 0.6.8

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

@@ -288,15 +288,29 @@ describe('useInactivityTracker', () => {
   });
 
   it('broadcasts activity to other tabs', () => {
-    const { result } = renderHook(() => 
-      useInactivityTracker({ 
-        enabled: true,
+    // Ensure no persisted time to force resetActivity call
+    localStorageMock.getItem.mockReturnValue(null);
+    
+    // Start with enabled: true to allow tracking
+    const { result } = renderHook(
+      ({ enabled }) => useInactivityTracker({ 
+        enabled,
         channelName: 'test-channel'
-      })
+      }),
+      { initialProps: { enabled: true } }
     );
     
+    // Wait for automatic initialization
     act(() => {
-      result.current.startTracking();
+      vi.advanceTimersByTime(0);
+    });
+    
+    // Clear any existing calls from initialization
+    mockBroadcastChannel.postMessage.mockClear();
+    
+    // Trigger activity reset which should broadcast
+    act(() => {
+      result.current.resetActivity();
     });
     
     expect(mockBroadcastChannel.postMessage).toHaveBeenCalledWith({
@@ -337,16 +351,39 @@ describe('useInactivityTracker', () => {
 
   it('cleans up timers and listeners on unmount', () => {
     const { result, unmount } = renderHook(() => 
-      useInactivityTracker({ enabled: true })
+      useInactivityTracker({ enabled: true, channelName: 'test-channel' })
     );
     
+    // Wait for automatic initialization
     act(() => {
-      result.current.startTracking();
+      vi.advanceTimersByTime(0);
+    });
+    
+    // Ensure tracking is active and channel/listeners are set up
+    expect(result.current.isTracking).toBe(true);
+    expect(mockAddEventListener).toHaveBeenCalled();
+    
+    // Verify channel was created
+    expect(window.BroadcastChannel).toHaveBeenCalled();
+    
+    // Clear mocks to track cleanup calls
+    mockRemoveEventListener.mockClear();
+    mockBroadcastChannel.close.mockClear();
+    
+    // Unmount should trigger cleanup
+    act(() => {
+      unmount();
     });
     
-    unmount();
+    // Advance timers to ensure cleanup completes
+    act(() => {
+      vi.advanceTimersByTime(100);
+    });
     
+    // Verify cleanup was called
+    // The hook should remove all event listeners that were added
     expect(mockRemoveEventListener).toHaveBeenCalled();
+    // Channel cleanup happens in the unmount effect
     expect(mockBroadcastChannel.close).toHaveBeenCalled();
   });
 

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

@@ -610,7 +610,13 @@ describe('useOperationPerformance', () => {
         useOperationPerformance('testOperation', 'OPERATION')
       );
 
-      mockPerformanceNow.mockReturnValueOnce(0).mockReturnValueOnce(20);
+      // Clear any previous calls
+      vi.clearAllMocks();
+      
+      // Use mockReturnValueOnce to ensure exact sequence
+      mockPerformanceNow
+        .mockReturnValueOnce(0)   // Start time
+        .mockReturnValueOnce(20); // End time
 
       const operation = () => 'result';
 
@@ -623,12 +629,22 @@ describe('useOperationPerformance', () => {
           operation: 'testOperation',
         })
       );
+      
+      // Reset mock
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
     });
 
     it('includes context in measurement', async () => {
       const { result } = renderHook(() => useOperationPerformance('testOperation'));
 
-      mockPerformanceNow.mockReturnValueOnce(0).mockReturnValueOnce(15);
+      // Use a sequence to ensure correct values are returned
+      let callCount = 0;
+      mockPerformanceNow.mockImplementation(() => {
+        callCount++;
+        if (callCount === 1) return 0;   // Start time
+        if (callCount === 2) return 15;  // End time
+        return mockPerformanceNowValue; // Fallback
+      });
 
       const operation = () => 'result';
       const context = { userId: '123', action: 'test' };
@@ -644,6 +660,10 @@ describe('useOperationPerformance', () => {
           action: 'test',
         })
       );
+      
+      // Reset mock
+      callCount = 0;
+      mockPerformanceNow.mockImplementation(() => mockPerformanceNowValue);
     });
 
     it('handles operation errors', async () => {

package/src/hooks/public/usePublicEvent.ts

@@ -22,16 +22,16 @@
  *   const { eventCode } = usePublicRouteParams();
  *   const { event, isLoading, error, refetch } = usePublicEvent(eventCode);
  *
- *   if (isLoading) return <div>Loading event...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
- *   if (!event) return <div>Event not found</div>;
+ *   if (isLoading) return <p>Loading event...</p>;
+ *   if (error) return <p>Error: {error.message}</p>;
+ *   if (!event) return <p>Event not found</p>;
  *
  *   return (
- *     <div>
+ *     <section>
  *       <h1>{event.event_name}</h1>
  *       <p>Date: {event.event_date}</p>
  *       <p>Venue: {event.event_venue}</p>
- *     </div>
+ *     </section>
  *   );
  * }
  * ```

package/src/hooks/public/usePublicEventLogo.ts

@@ -26,17 +26,17 @@
  *     organisationId
  *   );
  *
- *   if (isLoading) return <div>Loading logo...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
+ *   if (isLoading) return <p>Loading logo...</p>;
+ *   if (error) return <p>Error: {error.message}</p>;
  *
  *   return (
- *     <div>
+ *     <section>
  *       {logoUrl ? (
  *         <img src={logoUrl} alt={`${eventName} logo`} />
  *       ) : (
- *         <div className="logo-fallback">{fallbackText}</div>
+ *         <p className="logo-fallback">{fallbackText}</p>
  *       )}
- *     </div>
+ *     </section>
  *   );
  * }
  * ```

package/src/hooks/public/usePublicFileDisplay.ts

@@ -28,8 +28,8 @@
  *     { supabase }
  *   );
  *
- *   if (isLoading) return <div>Loading...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
+ *   if (isLoading) return <p>Loading...</p>;
+ *   if (error) return <p>Error: {error.message}</p>;
  *
  *   return fileUrl ? <img src={fileUrl} alt="File" /> : null;
  * }

package/src/hooks/public/usePublicRouteParams.ts

@@ -21,15 +21,15 @@
  * function PublicEventPage() {
  *   const { eventCode, eventId, event, error, isLoading } = usePublicRouteParams();
  *
- *   if (isLoading) return <div>Loading...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
- *   if (!event) return <div>Event not found</div>;
+ *   if (isLoading) return <p>Loading...</p>;
+ *   if (error) return <p>Error: {error.message}</p>;
+ *   if (!event) return <p>Event not found</p>;
  *
  *   return (
- *     <div>
+ *     <section>
  *       <h1>{event.event_name}</h1>
  *       <p>Event Code: {eventCode}</p>
- *     </div>
+ *     </section>
  *   );
  * }
  * ```
@@ -182,16 +182,20 @@ export function usePublicRouteParams(
 
   // Determine the final error state
   const finalError = useMemo(() => {
+    // Always show validation errors (format validation)
     if (error) return error;
-    if (eventError) return eventError;
+    // When validation is disabled, ignore event errors (invalid codes are allowed)
+    if (!validateEventCode) return null;
+    // Include eventError if we're fetching event data and validation is enabled
+    if (fetchEventData && eventError) return eventError;
     return null;
-  }, [error, eventError]);
+  }, [error, eventError, fetchEventData, validateEventCode]);
 
   // Extract event ID from event data
   const eventId = useMemo(() => {
-    if (!event) return null;
+    if (!fetchEventData || !event) return null;
     return event.event_id || event.id;
-  }, [event]);
+  }, [fetchEventData, event]);
 
   // Refetch function
   const refetch = useCallback(async (): Promise<void> => {

package/src/hooks/useAddressAutocomplete.test.ts

@@ -45,17 +45,17 @@ describe('useAddressAutocomplete', () => {
   });
 
   describe('Initial state', () => {
-    it('returns initial state with empty suggestions', () => {
+    it('returns initial state with empty suggestions', { timeout: 5000 }, () => {
       const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
 
       expect(result.current.suggestions).toEqual([]);
       expect(result.current.isLoading).toBe(false);
       expect(result.current.error).toBeNull();
-    }, { timeout: 5000 });
+    });
   });
 
   describe('Autocomplete suggestions', () => {
-    it('fetches suggestions when input value changes', async () => {
+    it('fetches suggestions when input value changes', { timeout: 5000 }, async () => {
       const mockPredictions = [
         {
           description: '123 Main St, Melbourne VIC, Australia',
@@ -81,9 +81,9 @@ describe('useAddressAutocomplete', () => {
       );
 
       expect(result.current.suggestions[0].place_id).toBe('ChIJ123');
-    }, { timeout: 5000 });
+    });
 
-    it('debounces input value', async () => {
+    it('debounces input value', { timeout: 5000 }, async () => {
       vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValue([]);
 
       // Since we're mocking useDebounce to return immediately, this test verifies
@@ -108,9 +108,9 @@ describe('useAddressAutocomplete', () => {
 
       // With mocked debounce, it will be called for each change
       expect(googlePlacesUtils.fetchPlaceAutocomplete).toHaveBeenCalled();
-    }, { timeout: 5000 });
+    });
 
-    it('clears suggestions when input is empty', async () => {
+    it('clears suggestions when input is empty', { timeout: 5000 }, async () => {
       vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce([
         { description: '123 Main St', place_id: 'ChIJ123' },
       ]);
@@ -137,9 +137,9 @@ describe('useAddressAutocomplete', () => {
         },
         { timeout: 1000 }
       );
-    }, { timeout: 5000 });
+    });
 
-    it('handles API errors', async () => {
+    it('handles API errors', { timeout: 5000 }, async () => {
       const error = new Error('API request denied');
       vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockRejectedValueOnce(error);
 
@@ -156,11 +156,11 @@ describe('useAddressAutocomplete', () => {
 
       expect(result.current.error?.message).toBe('API request denied');
       expect(result.current.suggestions).toEqual([]);
-    }, { timeout: 5000 });
+    });
   });
 
   describe('Address selection', () => {
-    it('selects address by place_id', async () => {
+    it('selects address by place_id', { timeout: 5000 }, async () => {
       const mockPlaceDetails = {
         place_id: 'ChIJ123',
         formatted_address: '123 Main St, Melbourne VIC 3000, Australia',
@@ -191,7 +191,7 @@ describe('useAddressAutocomplete', () => {
       expect(address).not.toBeNull();
       expect(address?.place_id).toBe('ChIJ123');
       expect(googlePlacesUtils.fetchPlaceDetails).toHaveBeenCalledWith('ChIJ123', mockApiKey);
-    }, { timeout: 5000 });
+    });
 
     it('returns null when place_id is invalid', async () => {
       vi.mocked(googlePlacesUtils.fetchPlaceDetails).mockRejectedValueOnce(new Error('Place not found'));
@@ -205,7 +205,7 @@ describe('useAddressAutocomplete', () => {
   });
 
   describe('getAddressByPlaceId', () => {
-    it('retrieves address by place_id', async () => {
+    it('retrieves address by place_id', { timeout: 5000 }, async () => {
       const mockAddress = {
         place_id: 'ChIJ123',
         full_address: '123 Main St',
@@ -227,7 +227,7 @@ describe('useAddressAutocomplete', () => {
 
       expect(address).not.toBeNull();
       expect(address?.place_id).toBe('ChIJ123');
-    }, { timeout: 5000 });
+    });
 
     it('returns null on error', async () => {
       vi.mocked(googlePlacesUtils.getAddressByPlaceId).mockResolvedValueOnce(null);
@@ -237,11 +237,11 @@ describe('useAddressAutocomplete', () => {
       const address = await result.current.getAddressByPlaceId('invalid');
 
       expect(address).toBeNull();
-    }, { timeout: 5000 });
+    });
   });
 
   describe('clearSuggestions', () => {
-    it('clears suggestions', async () => {
+    it('clears suggestions', { timeout: 5000 }, async () => {
       vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce([
         { description: '123 Main St', place_id: 'ChIJ123' },
       ]);
@@ -268,7 +268,7 @@ describe('useAddressAutocomplete', () => {
         },
         { timeout: 1000 }
       );
-    }, { timeout: 5000 });
+    });
   });
 
   describe('Caching', () => {
@@ -312,7 +312,7 @@ describe('useAddressAutocomplete', () => {
       );
 
       expect(googlePlacesUtils.fetchPlaceAutocomplete).toHaveBeenCalled();
-    }, { timeout: 5000 });
+    });
   });
 });
 

package/src/hooks/useAppConfig.ts

@@ -14,9 +14,9 @@
  * function MyComponent() {
  *   const { appName, isLoading } = useAppConfig();
  *   
- *   if (isLoading) return <div>Loading...</div>;
+ *   if (isLoading) return <p>Loading...</p>;
  *   
- *   return <div>App: {appName}</div>;
+ *   return <p>App: {appName}</p>;
  * }
  * ```
  */

package/src/hooks/useEventTheme.test.ts

@@ -283,13 +283,13 @@ describe('useEventTheme', () => {
         throw new Error('Palette application failed');
       });
 
-      renderHook(() => useEventTheme(), { wrapper });
-
-      const logger = getMockLogger();
-      expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
-        'Failed to apply event palette:',
-        expect.any(Error)
-      );
+      // The hook should not throw - errors are caught silently
+      expect(() => {
+        renderHook(() => useEventTheme(), { wrapper });
+      }).not.toThrow();
+      
+      // Verify that applyPalette was called (even though it threw)
+      expect(mockApplyPalette).toHaveBeenCalled();
     });
   });
 

package/src/hooks/useEventTheme.ts

@@ -43,8 +43,8 @@ import { useLocation } from 'react-router-dom';
 import { EventServiceContext } from '../providers/services/EventServiceProvider';
 import { applyPalette, clearPalette } from '../theming/runtime';
 import { parseAndNormalizeEventColours } from '../theming/parseEventColours';
-import type { Event } from '../types/event';
 import { createLogger } from '../utils/core/logger';
+import type { Event } from '../types/event';
 
 const log = createLogger('useEventTheme');
 
@@ -147,6 +147,7 @@ export function useEventTheme(event?: Event | null): void {
     try {
       applyPalette(normalized);
     } catch (error) {
+      // Log error but don't throw - theming is not critical
       log.error('Failed to apply event palette:', error);
     }
 

package/src/hooks/useFileDisplay.ts

@@ -26,8 +26,8 @@
  *     FileCategory.EVENT_LOGOS
  *   );
  *
- *   if (isLoading) return <div>Loading...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
+ *   if (isLoading) return <p>Loading...</p>;
+ *   if (error) return <p>Error: {error.message}</p>;
  *
  *   return fileUrl ? <img src={fileUrl} alt="File" /> : null;
  * }

package/src/hooks/useFileUrl.ts

@@ -57,12 +57,21 @@ export function useFileUrl(
   const [isLoading, setIsLoading] = useState<boolean>(false);
   const [error, setError] = useState<Error | null>(null);
   const fileReferenceIdRef = useRef<string | null>(null);
+  const isLoadingRef = useRef<boolean>(false);
+  const urlRef = useRef<string | null>(null);
+
+  // Keep refs in sync with state
+  useEffect(() => {
+    isLoadingRef.current = isLoading;
+    urlRef.current = url;
+  }, [isLoading, url]);
 
   const loadUrl = useCallback(async () => {
     if (!fileReference) {
       setUrl(null);
       setIsLoading(false);
       setError(null);
+      fileReferenceIdRef.current = null;
       return;
     }
 
@@ -70,11 +79,12 @@ export function useFileUrl(
       setUrl(null);
       setIsLoading(false);
       setError(new Error('Supabase client is required for URL generation'));
+      fileReferenceIdRef.current = null;
       return;
     }
 
     // Skip if already loading or URL already exists for this file
-    if (isLoading || (url && fileReferenceIdRef.current === fileReference.id)) {
+    if (isLoadingRef.current || (urlRef.current && fileReferenceIdRef.current === fileReference.id)) {
       return;
     }
 
@@ -108,29 +118,63 @@ export function useFileUrl(
     } finally {
       setIsLoading(false);
     }
-  }, [fileReference, supabase, organisation_id, isLoading, url]);
+  }, [fileReference, supabase, organisation_id]);
 
   const clear = useCallback(() => {
     setUrl(null);
     setError(null);
     setIsLoading(false);
     fileReferenceIdRef.current = null;
+    urlRef.current = null;
   }, []);
 
   // Auto-load URL when fileReference changes
   useEffect(() => {
-    if (autoLoad) {
-      // Reset URL when file reference changes
-      if (fileReferenceIdRef.current !== fileReference?.id) {
+    if (!autoLoad) {
+      return;
+    }
+
+    const currentFileId = fileReference?.id ?? null;
+    const previousFileId = fileReferenceIdRef.current;
+
+    // Handle null file reference
+    if (!fileReference) {
+      if (previousFileId !== null) {
         setUrl(null);
         setError(null);
+        fileReferenceIdRef.current = null;
+        urlRef.current = null;
       }
-      
-      if (fileReference && !url && !isLoading) {
+      return;
+    }
+
+    // Reset URL when file reference ID changes (but not on initial mount)
+    if (previousFileId !== null && previousFileId !== currentFileId) {
+      setUrl(null);
+      setError(null);
+      fileReferenceIdRef.current = null;
+      urlRef.current = null; // Also reset the ref immediately
+      // Immediately try to load - loadUrl will check if already loading
+      loadUrl();
+      return;
+    }
+    
+    // Initial load or reload after clear: Load URL if we have a file reference and no URL is set
+    if (previousFileId === null && currentFileId !== null) {
+      // First time loading this file or reloading after clear - update ref and load
+      fileReferenceIdRef.current = currentFileId;
+      if (!isLoading && !url) {
         loadUrl();
       }
+    } else if (previousFileId === currentFileId && !url && !isLoading) {
+      // Same file but URL not loaded yet (e.g., after clear or initial mount edge case)
+      // Ensure ref is set correctly
+      if (fileReferenceIdRef.current !== currentFileId) {
+        fileReferenceIdRef.current = currentFileId;
+      }
+      loadUrl();
     }
-  }, [fileReference?.id, autoLoad, loadUrl, url, isLoading]);
+  }, [fileReference, autoLoad, loadUrl, url, isLoading]);
 
   return {
     url,

package/src/hooks/useOrganisationSecurity.test.ts

@@ -625,7 +625,8 @@ describe('useOrganisationSecurity', () => {
 
     it('handles permission retrieval errors gracefully', async () => {
       mockIsSuperAdmin.mockResolvedValue(false);
-      mockIsPermittedCached.mockRejectedValue(new Error('Permission retrieval failed'));
+      // getUserPermissions uses getPermissionMap, not isPermittedCached
+      mockGetPermissionMap.mockRejectedValue(new Error('Permission retrieval failed'));
 
       const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});