@jmruthers/pace-core 0.6.4 → 0.6.6

package/src/eslint-rules/utils/helpers.cjs

@@ -0,0 +1,42 @@
+/**
+ * Shared helper functions for ESLint rules
+ * @package @jmruthers/pace-core
+ * @module ESLintRules/utils/helpers
+ */
+
+// Helper function to get pace-core alternative for restricted imports
+function getPaceCoreAlternative(importSource) {
+  const alternatives = {
+    '@radix-ui/react-avatar': '/components',
+    '@radix-ui/react-checkbox': '/components',
+    '@radix-ui/react-dialog': '/components',
+    '@radix-ui/react-label': '/components',
+    '@radix-ui/react-switch': '/components',
+    '@radix-ui/react-tabs': '/components',
+    '@radix-ui/react-toast': '/components',
+    '@radix-ui/react-tooltip': '/components',
+    'react-day-picker': '/components',
+    '@tanstack/react-table': '/components',
+    'react-hook-form': '/components',
+    'zod': '/utils',
+    'lucide-react': '/icons'
+  };
+  
+  return alternatives[importSource] || '';
+}
+
+/**
+ * Check if a file is in the pace-core source directory
+ * @param {string} filename - The file path to check
+ * @returns {boolean} - True if the file is in packages/core/src
+ */
+function isPaceCoreSourceFile(filename) {
+  // Check for both Unix and Windows path separators
+  return filename.includes('packages/core/src') || filename.includes('packages\\core\\src');
+}
+
+module.exports = {
+  getPaceCoreAlternative,
+  isPaceCoreSourceFile,
+};
+

package/src/eslint-rules/utils/manifest-loader.cjs

@@ -0,0 +1,75 @@
+/**
+ * Shared utility for loading core-usage-manifest.json
+ * @package @jmruthers/pace-core
+ * @module ESLintRules/utils/manifest-loader
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Load manifest data
+let manifestData = null;
+try {
+  const manifestPath = path.join(__dirname, '../../../core-usage-manifest.json');
+  if (fs.existsSync(manifestPath)) {
+    manifestData = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  }
+} catch (error) {
+  // If manifest can't be loaded, rules will use hardcoded defaults
+  console.warn('Warning: Could not load core-usage-manifest.json, using defaults');
+}
+
+// Get restricted imports from manifest or use defaults
+const getRestrictedImports = () => {
+  if (manifestData && manifestData.restrictedImports) {
+    return manifestData.restrictedImports;
+  }
+  // Fallback defaults
+  return [
+    { module: '@radix-ui/react-avatar', reason: 'Use Avatar component from pace-core instead' },
+    { module: '@radix-ui/react-checkbox', reason: 'Use Checkbox component from pace-core instead' },
+    { module: '@radix-ui/react-dialog', reason: 'Use Dialog component from pace-core instead' },
+    { module: '@radix-ui/react-label', reason: 'Use Label component from pace-core instead' },
+    { module: '@radix-ui/react-slot', reason: 'Use Button component from pace-core which handles slot composition' },
+    { module: '@radix-ui/react-switch', reason: 'Use Switch component from pace-core instead' },
+    { module: '@radix-ui/react-tabs', reason: 'Use Tabs component from pace-core instead' },
+    { module: '@radix-ui/react-toast', reason: 'Use Toast component and useToast hook from pace-core instead' },
+    { module: '@radix-ui/react-tooltip', reason: 'Use Tooltip component from pace-core instead' },
+    { module: 'react-day-picker', reason: 'Use Calendar component from pace-core instead' },
+    { module: '@tanstack/react-table', reason: 'Use DataTable component and related hooks from pace-core instead. DataTable wraps and standardizes table functionality' },
+    { module: 'react-hook-form', reason: 'Use Form component and useZodForm hook from pace-core instead' },
+    { module: 'zod', reason: 'Use validation utilities and schemas from pace-core instead. pace-core provides standardized validation helpers' }
+  ];
+};
+
+// Get pace-core components from manifest or use defaults
+const getPaceCoreComponents = () => {
+  if (manifestData && manifestData.components) {
+    return manifestData.components;
+  }
+  return ['Button', 'Card', 'Dialog', 'Input', 'Form', 'Select', 'Alert', 'Badge', 'Checkbox', 'Switch', 'Textarea', 'Label', 'Table', 'DataTable', 'Toast', 'Tooltip', 'Tabs', 'Calendar', 'Avatar', 'Progress'];
+};
+
+// Get pace-core hooks from manifest or use defaults
+const getPaceCoreHooks = () => {
+  if (manifestData && manifestData.hooks) {
+    return manifestData.hooks;
+  }
+  return ['useToast', 'useDebounce', 'useUnifiedAuth', 'useEvents', 'useOrganisations', 'useFileReference', 'useStorage', 'useZodForm', 'useRBAC', 'usePermissions'];
+};
+
+// Get pace-core utils from manifest or use defaults
+const getPaceCoreUtils = () => {
+  if (manifestData && manifestData.utils) {
+    return manifestData.utils;
+  }
+  return ['formatDate', 'formatCurrency', 'formatNumber', 'formatTime', 'formatDateTime', 'cn', 'validateUserInput', 'sanitizeUserInput', 'hasPermission', 'getAppConfig'];
+};
+
+module.exports = {
+  getRestrictedImports,
+  getPaceCoreComponents,
+  getPaceCoreHooks,
+  getPaceCoreUtils,
+};
+

package/src/hooks/__tests__/hooks.integration.test.tsx

@@ -433,15 +433,13 @@ describe('Hooks Integration', () => {
       });
 
       // Assert that onSubmit was called with the correct form data
+      // Note: Form component only passes data, not methods (react-hook-form behavior)
       await waitFor(() => {
-        expect(mockOnSubmit).toHaveBeenCalledWith(
-          {
-            name: 'John Doe',
-            email: 'john@example.com',
-            age: 25,
-          },
-          expect.any(Object) // Form methods object
-        );
+        expect(mockOnSubmit).toHaveBeenCalledWith({
+          name: 'John Doe',
+          email: 'john@example.com',
+          age: 25,
+        });
       });
     });
   });

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

@@ -2,18 +2,87 @@ 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();
 
-vi.mock('../../providers/services/UnifiedAuthProvider', () => {
-  return {
-    useUnifiedAuth: () => mockUseUnifiedAuthFn(),
-    UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => React.createElement(React.Fragment, null, children),
-  };
+// 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 {
@@ -22,7 +91,6 @@ vi.mock('../../components/PublicLayout/PublicPageProvider', async (importOrigina
   };
 });
 
-import { useUnifiedAuth as actualUseUnifiedAuth } from '../../providers/services/UnifiedAuthProvider';
 import { useIsPublicPage as actualUseIsPublicPage } from '../../components/PublicLayout/PublicPageProvider';
 import { PublicPageContext } from '../../components/PublicLayout/PublicPageProvider';
 
@@ -31,25 +99,28 @@ describe('useAppConfig Hook', () => {
   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 undefined for PublicPageContext (no appName from context)
-    // This ensures the hook falls back to env vars or default 'PACE'
+    // 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 PublicPageContext by comparing the context object
-      // We can't directly compare, so we check if it's a context created by React.createContext
-      if (context && typeof context === 'object' && 'Provider' in context && 'Consumer' in context) {
-        // This is likely PublicPageContext - return undefined to simulate no provider
-        try {
-          // Try to access the context to see if it throws (no provider) or returns a value
-          // If it's PublicPageContext and there's no provider, return undefined
-          return undefined;
-        } catch {
-          return undefined;
-        }
+      // 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);
     });
     
@@ -136,21 +207,23 @@ describe('useAppConfig Hook', () => {
 
     it('should return configuration from UnifiedAuthProvider when available', () => {
       const mockAppName = 'AuthApp';
+      
+      // Ensure we're not in public page mode
+      mockUseIsPublicPage.mockReturnValue(false);
 
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appName: mockAppName,
-      } as any);
-
-      const { result } = renderHook(() => useAppConfig());
+      // 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', () => {
-      mockUseUnifiedAuthFn.mockImplementation(() => {
-        throw new Error('Provider not available');
-      });
+      // 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());
 
@@ -159,9 +232,9 @@ describe('useAppConfig Hook', () => {
     });
 
     it('should handle different types of errors from UnifiedAuthProvider', () => {
-      mockUseUnifiedAuthFn.mockImplementation(() => {
-        throw new Error('Network error');
-      });
+      // 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());
 
@@ -170,9 +243,9 @@ describe('useAppConfig Hook', () => {
     });
 
     it('should handle non-Error exceptions from UnifiedAuthProvider', () => {
-      mockUseUnifiedAuthFn.mockImplementation(() => {
-        throw 'String error';
-      });
+      // 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());
 
@@ -197,52 +270,43 @@ describe('useAppConfig Hook', () => {
     it('should memoize authenticated configuration based on dependencies', () => {
       mockUseIsPublicPage.mockReturnValue(false);
 
-      const mockAppName = 'TestApp';
-
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appName: mockAppName,
-      } as any);
-
-      const { result, rerender } = renderHook(() => useAppConfig());
+      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
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appName: 'DifferentApp',
-      } as any);
+      // 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 });
 
-      rerender();
-
-      expect(result.current).not.toBe(firstResult);
-      expect(result.current.appName).toBe('DifferentApp');
+      expect(result2.current).not.toBe(firstResult);
+      expect(result2.current.appName).toBe('DifferentApp');
     });
 
     it('should memoize authenticated configuration based on appName changes', () => {
       mockUseIsPublicPage.mockReturnValue(false);
 
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appName: 'App1',
-      } as any);
-
-      const { result, rerender } = renderHook(() => useAppConfig());
+      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
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appName: 'App2',
-      } as any);
+      // 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 });
 
-      rerender();
-
-      expect(result.current).not.toBe(firstResult);
-      expect(result.current.appName).toBe('App2');
+      expect(result2.current).not.toBe(firstResult);
+      expect(result2.current.appName).toBe('App2');
     });
   });
 
@@ -259,11 +323,9 @@ describe('useAppConfig Hook', () => {
 
       // Test authenticated page context separately
       mockUseIsPublicPage.mockReturnValue(false);
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appName: 'AuthApp',
-      } as any);
-
-      const { result: authResult } = renderHook(() => useAppConfig());
+      const authValue = createAuthValue({ appName: 'AuthApp' });
+      const authWrapper = createAuthWrapper(authValue);
+      const { result: authResult } = renderHook(() => useAppConfig(), { wrapper: authWrapper });
 
       expect(authResult.current.appName).toBe('AuthApp');
     });