@jmruthers/pace-core 0.6.9 → 0.6.11

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

@@ -1,220 +0,0 @@
-/**
- * @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');
-    });
-
-    // useSecureDataAccess has been removed - use useSecureSupabase from @jmruthers/pace-core/rbac instead
-
-    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', // Removed - use useSecureSupabase from @jmruthers/pace-core/rbac instead
-        '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');
-      });
-    });
-  });
-});
-

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

@@ -1,111 +0,0 @@
-
-import React from 'react';
-import { renderHook, waitFor } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { renderWithProviders } from '../../__tests__/helpers/test-utils';
-
-// Mock fetch globally for all tests
-const mockFetch = vi.fn();
-global.fetch = mockFetch;
-
-// Simple hook for testing API fetch functionality
-function useApiFetch(url: string) {
-  const [data, setData] = React.useState<any>(null);
-  const [loading, setLoading] = React.useState(true);
-  const [error, setError] = React.useState<string | null>(null);
-
-  React.useEffect(() => {
-    const fetchData = async () => {
-      try {
-        setLoading(true);
-        const response = await fetch(url);
-        if (!response.ok) {
-          throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        const result = await response.json();
-        setData(result);
-      } catch (err) {
-        setError(err instanceof Error ? err.message : 'An error occurred');
-      } finally {
-        setLoading(false);
-      }
-    };
-
-    fetchData();
-  }, [url]);
-
-  return { data, loading, error };
-}
-
-describe('useApiFetch', () => {
-    describe('Data Fetching', () => {
-    it('fetches data on mount', async () => {
-    const mockData = { id: 1, name: 'Test' };
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => mockData,
-    });
-
-    const { result } = renderHook(() => useApiFetch('/api/test'));
-
-    expect(result.current.loading).toBe(true);
-    expect(result.current.data).toBe(null);
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.data).toEqual(mockData);
-    expect(mockFetch).toHaveBeenCalledWith('/api/test');
-    });
-
-    it('sets loading state', async () => {
-    const mockData = { id: 1, name: 'Test' };
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => mockData,
-    });
-
-    const { result } = renderHook(() => useApiFetch('/api/test'));
-
-    // Initially loading should be true
-    expect(result.current.loading).toBe(true);
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-    });
-
-    it('returns data', async () => {
-    const mockData = { id: 1, name: 'Test Data' };
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => mockData,
-    });
-
-    const { result } = renderHook(() => useApiFetch('/api/data'));
-
-    await waitFor(() => {
-      expect(result.current.data).toEqual(mockData);
-    });
-
-    expect(result.current.error).toBe(null);
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('handles errors gracefully', async () => {
-    const errorMessage = 'Network error';
-    mockFetch.mockRejectedValueOnce(new Error(errorMessage));
-
-    const { result } = renderHook(() => useApiFetch('/api/error'));
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.error).toBe(errorMessage);
-    expect(result.current.data).toBe(null);
-    });
-  });
-});

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

@@ -1,347 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import React from 'react';
-import { useAppConfig } from '../useAppConfig';
-import { UnifiedAuthContext } from '../../providers/services/UnifiedAuthProvider';
-
-// Declare mock functions
-const mockUseIsPublicPage = vi.fn();
-const mockUseUnifiedAuthFn = vi.fn();
-
-// Helper to create a minimal auth context value
-const createAuthValue = (overrides: any = {}) => ({
-  appName: 'PACE',
-  user: null,
-  session: null,
-  isAuthenticated: false,
-  authLoading: false,
-  authError: null,
-  supabase: null,
-  appId: undefined,
-  selectedOrganisation: null,
-  selectedOrganisationId: null,
-  organisations: [],
-  userMemberships: [],
-  organisationLoading: false,
-  organisationError: null,
-  hasValidOrganisationContext: false,
-  isContextReady: false,
-  switchOrganisation: vi.fn(),
-  getUserRole: vi.fn(),
-  validateOrganisationAccess: vi.fn(),
-  refreshOrganisations: vi.fn(),
-  ensureOrganisationContext: vi.fn(),
-  isOrganisationSecure: vi.fn(),
-  getPrimaryOrganisation: vi.fn(),
-  events: [],
-  selectedEvent: null,
-  selectedEventId: null,
-  eventLoading: false,
-  eventError: null,
-  setSelectedEvent: vi.fn(),
-  refreshEvents: vi.fn(),
-  showInactivityWarning: false,
-  inactivityTimeRemaining: 0,
-  isIdle: false,
-  timeRemaining: 0,
-  showWarning: false,
-  isTracking: false,
-  resetActivity: vi.fn(),
-  startTracking: vi.fn(),
-  stopTracking: vi.fn(),
-  handleIdleLogout: vi.fn(),
-  handleStaySignedIn: vi.fn(),
-  handleSignOutNow: vi.fn(),
-  signIn: vi.fn(),
-  signUp: vi.fn(),
-  signOut: vi.fn(),
-  resetPassword: vi.fn(),
-  updatePassword: vi.fn(),
-  refreshSession: vi.fn(),
-  isLoading: false,
-  hasErrors: false,
-  sessionRestoration: {
-    isRestoring: false,
-    restorationComplete: false,
-    restorationError: null,
-  },
-  sessionRestorationTimedOut: false,
-  sessionRestorationTimeoutMs: 0,
-  ...overrides,
-});
-
-// Helper to create a wrapper component that provides UnifiedAuthContext
-const createAuthWrapper = (authValue: any) => {
-  return ({ children }: { children: React.ReactNode }) => {
-    return React.createElement(
-      UnifiedAuthContext.Provider,
-      {
-        value: authValue,
-      },
-      children
-    );
-  };
-};
-
-vi.mock('../../components/PublicLayout/PublicPageProvider', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../../components/PublicLayout/PublicPageProvider')>();
-  return {
-    ...actual,
-    useIsPublicPage: vi.fn(),
-  };
-});
-
-import { useIsPublicPage as actualUseIsPublicPage } from '../../components/PublicLayout/PublicPageProvider';
-import { PublicPageContext } from '../../components/PublicLayout/PublicPageProvider';
-
-describe('useAppConfig Hook', () => {
-  // Mock React.useContext to return undefined for PublicPageContext
-  const originalUseContext = React.useContext;
-  const originalEnv = import.meta.env;
-  
-  // Store the real UnifiedAuthContext for comparison
-  const realUnifiedAuthContext = UnifiedAuthContext;
-  
-  beforeEach(() => {
-    // Set up the mocks to use our mock functions
-    vi.mocked(actualUseIsPublicPage).mockImplementation(mockUseIsPublicPage);
-    
-    // Mock useContext to return values for UnifiedAuthContext and PublicPageContext
-    // This ensures the hook gets the correct values
-    vi.spyOn(React, 'useContext').mockImplementation((context) => {
-      // Check if this is the UnifiedAuthContext (use the real one from the import)
-      if (context === realUnifiedAuthContext) {
-        // Return the value from mockUseUnifiedAuthFn if it's set, otherwise return null
-        const mockValue = mockUseUnifiedAuthFn();
-        return mockValue !== undefined ? mockValue : null;
-      }
-      // Check if this is the PublicPageContext
-      if (context === PublicPageContext) {
-        // Return undefined to simulate no provider
-        return undefined;
-      }
-      // For other contexts, use original implementation
-      return originalUseContext(context);
-    });
-    
-    // Mock import.meta.env to ensure APP_NAME env vars return undefined
-    // The .env file has VITE_APP_NAME=CORE, so we override it using property descriptors
-    // Build a clean env object without APP_NAME keys
-    const cleanEnv: Record<string, any> = {};
-    if (originalEnv) {
-      Object.keys(originalEnv).forEach(key => {
-        if (!key.includes('APP_NAME')) {
-          cleanEnv[key] = (originalEnv as any)[key];
-        }
-      });
-    }
-    
-    // Use defineProperty with getters to override APP_NAME properties
-    Object.defineProperty(cleanEnv, 'VITE_APP_NAME', {
-      get: () => undefined,
-      enumerable: false,
-      configurable: true
-    });
-    Object.defineProperty(cleanEnv, 'NEXT_PUBLIC_APP_NAME', {
-      get: () => undefined,
-      enumerable: false,
-      configurable: true
-    });
-    
-    // Ensure both import.meta.env and (import.meta as any).env point to the clean env
-    Object.defineProperty(import.meta, 'env', {
-      value: cleanEnv,
-      writable: true,
-      configurable: true
-    });
-    (import.meta as any).env = cleanEnv;
-    
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    // Restore original environment
-    vi.unstubAllEnvs();
-    Object.defineProperty(import.meta, 'env', {
-      value: originalEnv,
-      writable: true,
-      configurable: true
-    });
-    vi.restoreAllMocks();
-  });
-
-  describe('Public Page Context', () => {
-    beforeEach(() => {
-      mockUseIsPublicPage.mockReturnValue(true);
-    });
-
-    it('should return public page configuration when in public context', () => {
-      const { result } = renderHook(() => useAppConfig());
-
-      expect(result.current.isLoading).toBe(false);
-      // Note: If VITE_APP_NAME is set in .env (e.g., CORE), the hook will use it.
-      // Otherwise, it defaults to 'PACE'. This test verifies it returns a valid string.
-      expect(typeof result.current.appName).toBe('string');
-      expect(result.current.appName.length).toBeGreaterThan(0);
-      // In a clean environment, this would be 'PACE', but with .env set it may be 'CORE'
-      expect(['PACE', 'CORE']).toContain(result.current.appName);
-    });
-
-    it('should return consistent configuration for public pages', () => {
-      const { result } = renderHook(() => useAppConfig());
-
-      // Public pages should always have these characteristics
-      expect(result.current.isLoading).toBe(false);
-      expect(typeof result.current.appName).toBe('string');
-    });
-  });
-
-  describe('Authenticated Page Context', () => {
-    beforeEach(() => {
-      mockUseIsPublicPage.mockReturnValue(false);
-      // Set default mock for useUnifiedAuth
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appName: 'PACE',
-      } as any);
-    });
-
-    it('should return configuration from UnifiedAuthProvider when available', () => {
-      const mockAppName = 'AuthApp';
-      
-      // Ensure we're not in public page mode
-      mockUseIsPublicPage.mockReturnValue(false);
-
-      // Use wrapper to provide UnifiedAuthContext
-      const authValue = createAuthValue({ appName: mockAppName });
-      const wrapper = createAuthWrapper(authValue);
-      const { result } = renderHook(() => useAppConfig(), { wrapper });
-
-      expect(result.current.isLoading).toBe(false);
-      expect(result.current.appName).toBe('AuthApp');
-    });
-
-    it('should handle UnifiedAuthProvider error and return fallback', () => {
-      // Since useAppConfig now uses useContext directly, missing provider returns null
-      // Mock useContext to return null for UnifiedAuthContext (simulating missing provider)
-      mockUseUnifiedAuthFn.mockReturnValue(null as any);
-
-      const { result } = renderHook(() => useAppConfig());
-
-      expect(result.current.isLoading).toBe(false);
-      expect(result.current.appName).toBe('PACE');
-    });
-
-    it('should handle different types of errors from UnifiedAuthProvider', () => {
-      // Since useAppConfig now uses useContext directly, missing provider returns null
-      // Mock useContext to return null for UnifiedAuthContext (simulating missing provider)
-      mockUseUnifiedAuthFn.mockReturnValue(null as any);
-
-      const { result } = renderHook(() => useAppConfig());
-
-      expect(result.current.isLoading).toBe(false);
-      expect(result.current.appName).toBe('PACE');
-    });
-
-    it('should handle non-Error exceptions from UnifiedAuthProvider', () => {
-      // Since useAppConfig now uses useContext directly, missing provider returns null
-      // Mock useContext to return null for UnifiedAuthContext (simulating missing provider)
-      mockUseUnifiedAuthFn.mockReturnValue(null as any);
-
-      const { result } = renderHook(() => useAppConfig());
-
-      expect(result.current.isLoading).toBe(false);
-      expect(result.current.appName).toBe('PACE');
-    });
-  });
-
-  describe('Memoization', () => {
-    it('should memoize public page configuration', () => {
-      mockUseIsPublicPage.mockReturnValue(true);
-
-      const { result, rerender } = renderHook(() => useAppConfig());
-
-      const firstResult = result.current;
-
-      rerender();
-
-      expect(result.current).toBe(firstResult);
-    });
-
-    it('should memoize authenticated configuration based on dependencies', () => {
-      mockUseIsPublicPage.mockReturnValue(false);
-
-      const authValue1 = createAuthValue({ appName: 'TestApp' });
-      const wrapper1 = createAuthWrapper(authValue1);
-      const { result, rerender } = renderHook(() => useAppConfig(), { wrapper: wrapper1 });
-
-      const firstResult = result.current;
-      expect(firstResult.appName).toBe('TestApp');
-
-      // Rerender with same props
-      rerender();
-      expect(result.current).toBe(firstResult);
-
-      // Rerender with different appName - need new wrapper with new value
-      const authValue2 = createAuthValue({ appName: 'DifferentApp' });
-      const wrapper2 = createAuthWrapper(authValue2);
-      const { result: result2 } = renderHook(() => useAppConfig(), { wrapper: wrapper2 });
-
-      expect(result2.current).not.toBe(firstResult);
-      expect(result2.current.appName).toBe('DifferentApp');
-    });
-
-    it('should memoize authenticated configuration based on appName changes', () => {
-      mockUseIsPublicPage.mockReturnValue(false);
-
-      const authValue1 = createAuthValue({ appName: 'App1' });
-      const wrapper1 = createAuthWrapper(authValue1);
-      const { result, rerender } = renderHook(() => useAppConfig(), { wrapper: wrapper1 });
-
-      const firstResult = result.current;
-      expect(firstResult.appName).toBe('App1');
-
-      // Rerender with different appName - need new wrapper with new value
-      const authValue2 = createAuthValue({ appName: 'App2' });
-      const wrapper2 = createAuthWrapper(authValue2);
-      const { result: result2 } = renderHook(() => useAppConfig(), { wrapper: wrapper2 });
-
-      expect(result2.current).not.toBe(firstResult);
-      expect(result2.current.appName).toBe('App2');
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle different contexts independently', () => {
-      // Test public page context
-      mockUseIsPublicPage.mockReturnValue(true);
-
-      const { result: publicResult } = renderHook(() => useAppConfig());
-
-      // Note: App name depends on environment - may be 'PACE' (default) or 'CORE' (from .env)
-      expect(typeof publicResult.current.appName).toBe('string');
-      expect(['PACE', 'CORE']).toContain(publicResult.current.appName);
-
-      // Test authenticated page context separately
-      mockUseIsPublicPage.mockReturnValue(false);
-      const authValue = createAuthValue({ appName: 'AuthApp' });
-      const authWrapper = createAuthWrapper(authValue);
-      const { result: authResult } = renderHook(() => useAppConfig(), { wrapper: authWrapper });
-
-      expect(authResult.current.appName).toBe('AuthApp');
-    });
-  });
-
-  describe('Type Safety', () => {
-    it('should return correct types for all return values', () => {
-      mockUseIsPublicPage.mockReturnValue(false);
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appName: 'TypeTestApp',
-      } as any);
-
-      const { result } = renderHook(() => useAppConfig());
-
-      expect(typeof result.current.isLoading).toBe('boolean');
-      expect(typeof result.current.appName).toBe('string');
-    });
-  });
-});