@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/components/Toast/Toast.test.tsx

@@ -21,6 +21,9 @@ import {
 import { reset } from '../../hooks/useToast';
 import { renderWithProviders } from '../../__tests__/helpers/test-utils';
 
+// Following testing standards: use timeout parameter to prevent hanging
+const TEST_TIMEOUT = 10000; // 10 seconds per test
+
 describe('Toast Component System', () => {
   beforeEach(() => {
     reset();
@@ -129,5 +132,422 @@ describe('Toast Component System', () => {
         expect(screen.getByTestId('toast-open')).toHaveTextContent('false');
       });
     });
+
+    it('renders multiple toasts', async () => {
+      function MultipleToastsHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({ title: 'Toast 1', description: 'First toast' });
+          toast({ title: 'Toast 2', description: 'Second toast' });
+          toast({ title: 'Toast 3', description: 'Third toast' });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<MultipleToastsHarness />);
+
+      expect(await screen.findByText('Toast 1')).toBeInTheDocument();
+      expect(screen.getByText('Toast 2')).toBeInTheDocument();
+      expect(screen.getByText('Toast 3')).toBeInTheDocument();
+    }, TEST_TIMEOUT);
+
+    it('renders toast with variant prop', async () => {
+      function VariantToastHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            title: 'Success Toast',
+            description: 'This is a success toast',
+            variant: 'success',
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<VariantToastHarness />);
+
+      expect(await screen.findByText('Success Toast')).toBeInTheDocument();
+      expect(screen.getByText('This is a success toast')).toBeInTheDocument();
+    }, TEST_TIMEOUT);
+
+    it('renders toast with destructive variant', async () => {
+      function DestructiveToastHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            title: 'Error Toast',
+            description: 'This is an error toast',
+            variant: 'destructive',
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<DestructiveToastHarness />);
+
+      expect(await screen.findByText('Error Toast')).toBeInTheDocument();
+      const toastRoot = screen.getByTestId('toast-root');
+      expect(toastRoot).toHaveClass('group');
+    }, TEST_TIMEOUT);
+
+    it('renders toast with custom duration', async () => {
+      function CustomDurationHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            title: 'Custom Duration',
+            description: 'This toast has custom duration',
+            duration: 10000,
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<CustomDurationHarness />);
+
+      expect(await screen.findByText('Custom Duration')).toBeInTheDocument();
+    }, TEST_TIMEOUT);
+
+    it('renders toast without title', async () => {
+      function NoTitleHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            description: 'Toast without title',
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<NoTitleHarness />);
+
+      expect(await screen.findByText('Toast without title')).toBeInTheDocument();
+      expect(screen.queryByTestId('toast-title')).not.toBeInTheDocument();
+    }, TEST_TIMEOUT);
+
+    it('renders toast without description', async () => {
+      function NoDescriptionHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            title: 'Toast without description',
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<NoDescriptionHarness />);
+
+      expect(await screen.findByText('Toast without description')).toBeInTheDocument();
+      expect(screen.queryByTestId('toast-description')).not.toBeInTheDocument();
+    }, TEST_TIMEOUT);
+
+    it('renders toast with only title and no description', async () => {
+      function TitleOnlyHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            title: 'Title Only Toast',
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<TitleOnlyHarness />);
+
+      expect(await screen.findByText('Title Only Toast')).toBeInTheDocument();
+      expect(screen.queryByTestId('toast-description')).not.toBeInTheDocument();
+    }, TEST_TIMEOUT);
+
+    it('renders toast with React node as title', async () => {
+      function ReactNodeTitleHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            title: <span data-testid="custom-title">Custom Title Node</span>,
+            description: 'Description',
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<ReactNodeTitleHarness />);
+
+      expect(await screen.findByTestId('custom-title')).toBeInTheDocument();
+      expect(screen.getByText('Custom Title Node')).toBeInTheDocument();
+    }, TEST_TIMEOUT);
+
+    it('renders toast with React node as description', async () => {
+      function ReactNodeDescriptionHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            title: 'Title',
+            description: <span data-testid="custom-desc">Custom Description Node</span>,
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<ReactNodeDescriptionHarness />);
+
+      expect(await screen.findByTestId('custom-desc')).toBeInTheDocument();
+      expect(screen.getByText('Custom Description Node')).toBeInTheDocument();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Toast Component Primitives', () => {
+    it('renders Toast with custom className', () => {
+      renderWithProviders(
+        <ToastProvider>
+          <ToastViewport />
+          <Toast open className="custom-toast">
+            <ToastTitle>Title</ToastTitle>
+          </Toast>
+        </ToastProvider>
+      );
+
+      const toast = screen.getByTestId('toast-root');
+      expect(toast).toHaveClass('custom-toast');
+    }, TEST_TIMEOUT);
+
+    it('renders ToastTitle with custom className', () => {
+      renderWithProviders(
+        <ToastProvider>
+          <ToastViewport />
+          <Toast open>
+            <ToastTitle className="custom-title">Title</ToastTitle>
+          </Toast>
+        </ToastProvider>
+      );
+
+      const title = screen.getByTestId('toast-title');
+      expect(title).toHaveClass('custom-title');
+    }, TEST_TIMEOUT);
+
+    it('renders ToastDescription with custom className', () => {
+      renderWithProviders(
+        <ToastProvider>
+          <ToastViewport />
+          <Toast open>
+            <ToastDescription className="custom-desc">Description</ToastDescription>
+          </Toast>
+        </ToastProvider>
+      );
+
+      const desc = screen.getByTestId('toast-description');
+      expect(desc).toHaveClass('custom-desc');
+    }, TEST_TIMEOUT);
+
+    it('renders ToastClose with custom className', () => {
+      renderWithProviders(
+        <ToastProvider>
+          <ToastViewport />
+          <Toast open>
+            <ToastClose className="custom-close" />
+          </Toast>
+        </ToastProvider>
+      );
+
+      const close = screen.getByTestId('toast-close');
+      expect(close).toHaveClass('custom-close');
+    }, TEST_TIMEOUT);
+
+    it('renders ToastAction with custom className', () => {
+      renderWithProviders(
+        <ToastProvider>
+          <ToastViewport />
+          <Toast open>
+            <ToastAction className="custom-action" altText="Action">
+              Action
+            </ToastAction>
+          </Toast>
+        </ToastProvider>
+      );
+
+      const action = screen.getByTestId('toast-action');
+      expect(action).toHaveClass('custom-action');
+    }, TEST_TIMEOUT);
+
+    it('handles Toast close button click', async () => {
+      const user = userEvent.setup();
+      const handleClose = vi.fn();
+
+      renderWithProviders(
+        <ToastProvider>
+          <ToastViewport />
+          <Toast open onOpenChange={handleClose}>
+            <ToastTitle>Title</ToastTitle>
+            <ToastClose />
+          </Toast>
+        </ToastProvider>
+      );
+
+      const closeButton = screen.getByTestId('toast-close');
+      await user.click(closeButton);
+
+      expect(handleClose).toHaveBeenCalled();
+    }, TEST_TIMEOUT);
+
+    it('forwards refs correctly on all toast components', () => {
+      const viewportRef = React.createRef<HTMLElement>();
+      const toastRef = React.createRef<HTMLElement>();
+      const titleRef = React.createRef<HTMLElement>();
+      const descRef = React.createRef<HTMLElement>();
+      const closeRef = React.createRef<HTMLButtonElement>();
+      const actionRef = React.createRef<HTMLButtonElement>();
+
+      renderWithProviders(
+        <ToastProvider>
+          <ToastViewport ref={viewportRef} />
+          <Toast ref={toastRef} open>
+            <ToastTitle ref={titleRef}>Title</ToastTitle>
+            <ToastDescription ref={descRef}>Description</ToastDescription>
+            <ToastAction ref={actionRef} altText="Action">
+              Action
+            </ToastAction>
+            <ToastClose ref={closeRef} />
+          </Toast>
+        </ToastProvider>
+      );
+
+      expect(viewportRef.current).toBeInstanceOf(HTMLElement);
+      expect(toastRef.current).toBeInstanceOf(HTMLElement);
+      expect(titleRef.current).toBeInstanceOf(HTMLElement);
+      expect(descRef.current).toBeInstanceOf(HTMLElement);
+      expect(actionRef.current).toBeInstanceOf(HTMLButtonElement);
+      expect(closeRef.current).toBeInstanceOf(HTMLButtonElement);
+    }, TEST_TIMEOUT);
+  });
+
+  describe('ToastViewport', () => {
+    it('renders with default positioning classes', () => {
+      renderWithProviders(
+        <ToastProvider>
+          <ToastViewport />
+        </ToastProvider>
+      );
+
+      const viewport = screen.getByTestId('toast-viewport');
+      expect(viewport).toHaveClass('fixed', 'top-0', 'z-[9999]');
+    }, TEST_TIMEOUT);
+
+    it('renders with custom positioning via className', () => {
+      renderWithProviders(
+        <ToastProvider>
+          <ToastViewport className="bottom-0 left-0" />
+        </ToastProvider>
+      );
+
+      const viewport = screen.getByTestId('toast-viewport');
+      expect(viewport).toHaveClass('bottom-0', 'left-0');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Edge Cases', () => {
+    it('handles toast with empty title and description', async () => {
+      function EmptyToastHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            title: '',
+            description: '',
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<EmptyToastHarness />);
+
+      // Toast should still render even with empty content
+      await waitFor(() => {
+        expect(screen.getByTestId('toast-root')).toBeInTheDocument();
+      });
+    }, TEST_TIMEOUT);
+
+    it('handles toast with very long content', async () => {
+      const longContent = 'A'.repeat(1000);
+      function LongContentHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            title: longContent,
+            description: longContent,
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<LongContentHarness />);
+
+      // Both title and description have the same content, so use getAllByText
+      const elements = await screen.findAllByText(longContent);
+      expect(elements.length).toBeGreaterThanOrEqual(1);
+      expect(elements[0]).toBeInTheDocument();
+    }, TEST_TIMEOUT);
+
+    it('handles toast with special characters', async () => {
+      const specialContent = '<>&"\'';
+      function SpecialCharsHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({
+            title: specialContent,
+            description: specialContent,
+          });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<SpecialCharsHarness />);
+
+      // Both title and description have the same content, so use getAllByText
+      const elements = await screen.findAllByText(specialContent);
+      expect(elements.length).toBeGreaterThanOrEqual(1);
+      expect(elements[0]).toBeInTheDocument();
+    }, TEST_TIMEOUT);
+
+    it('handles multiple toasts with same content', async () => {
+      function DuplicateContentHarness() {
+        const { toast } = useToast();
+
+        React.useEffect(() => {
+          toast({ title: 'Same Title', description: 'Same Description' });
+          toast({ title: 'Same Title', description: 'Same Description' });
+          toast({ title: 'Same Title', description: 'Same Description' });
+        }, [toast]);
+
+        return <Toaster />;
+      }
+
+      renderWithProviders(<DuplicateContentHarness />);
+
+      const titles = await screen.findAllByText('Same Title');
+      expect(titles.length).toBeGreaterThanOrEqual(1);
+    }, TEST_TIMEOUT);
   });
 });

package/src/components/{__tests__/index.test.ts → index.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file Components Index Barrel File Tests
  * @package @jmruthers/pace-core
- * @module Components/__tests__
+ * @module Components
  * @since 0.1.0
  *
  * Comprehensive tests for the components barrel file (src/components/index.ts) ensuring
@@ -9,7 +9,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import * as ComponentExports from '../index';
+import * as ComponentExports from './index';
 
 // Following testing standards: use timeout parameter to prevent hanging
 const TEST_TIMEOUT = 10000; // 10 seconds per test

package/src/constants/{__tests__/performance.test.ts → performance.test.ts}

@@ -1,7 +1,7 @@
 /**
  * @file Performance Constants Tests
  * @package @jmruthers/pace-core
- * @module Constants/__tests__
+ * @module Constants
  * @since 0.1.0
  *
  * Comprehensive tests for performance constants covering:
@@ -11,7 +11,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { PERFORMANCE_THRESHOLDS } from '../performance';
+import { PERFORMANCE_THRESHOLDS } from './performance';
 
 // Following testing standards: use timeout parameter to prevent hanging
 const TEST_TIMEOUT = 10000; // 10 seconds per test

package/src/hooks/{__tests__/ServiceHooks.test.tsx → ServiceHooks.test.tsx}

@@ -1,7 +1,7 @@
 /**
  * @file Service Hooks Unit Tests
  * @package @jmruthers/pace-core
- * @module Hooks/__tests__
+ * @module Hooks
  * @since 0.1.0
  *
  * Comprehensive unit tests for service hooks covering:
@@ -18,13 +18,13 @@ import * as React from 'react';
 
 // Following testing standards: use timeout parameter to prevent hanging
 const TEST_TIMEOUT = 10000; // 10 seconds per test
-import { useAuthService } from '../services/useAuthService';
-import { useOrganisationService } from '../services/useOrganisationService';
-import { useEventService } from '../services/useEventService';
-import { useInactivityService } from '../services/useInactivityService';
-import { useAuth } from '../services/useAuth';
-import { useCurrentOrganisation } from '../services/useCurrentOrganisation';
-import { useCurrentEvent } from '../services/useCurrentEvent';
+import { useAuthService } from './services/useAuthService';
+import { useOrganisationService } from './services/useOrganisationService';
+import { useEventService } from './services/useEventService';
+import { useInactivityService } from './services/useInactivityService';
+import { useAuth } from './services/useAuth';
+import { useCurrentOrganisation } from './services/useCurrentOrganisation';
+import { useCurrentEvent } from './services/useCurrentEvent';
 
 
 // Create a mock for useContext that can be controlled

package/src/hooks/{__tests__/hooks.integration.test.tsx → hooks.integration.test.tsx}

@@ -4,18 +4,18 @@ import { renderHook } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import '@testing-library/jest-dom';
 import { vi, describe, it, beforeEach, afterEach } from 'vitest';
-import { renderWithProviders } from '../../__tests__/helpers/test-utils';
-import { useDebounce } from '../useDebounce';
-import { useIsMobile } from '../useIsMobile';
+import { renderWithProviders } from '../__tests__/helpers/test-utils';
+import { useDebounce } from './useDebounce';
+import { useIsMobile } from './useIsMobile';
 // useZodForm removed - not used in tests
-import { useKeyboardShortcuts } from '../useKeyboardShortcuts';
-import { useFocusManagement } from '../useFocusManagement';
-import { useComponentPerformance } from '../useComponentPerformance';
-import { usePerformanceMonitor } from '../usePerformanceMonitor';
-import { useDataTableState } from '../useDataTableState';
-import { Button } from '../../components/Button/Button';
-import { Input } from '../../components/Input/Input';
-import { Form } from '../../components/Form/Form';
+import { useKeyboardShortcuts } from './useKeyboardShortcuts';
+import { useFocusManagement } from './useFocusManagement';
+import { useComponentPerformance } from './useComponentPerformance';
+import { usePerformanceMonitor } from './usePerformanceMonitor';
+import { useDataTableState } from './useDataTableState';
+import { Button } from '../components/Button/Button';
+import { Input } from '../components/Input/Input';
+import { Form } from '../components/Form/Form';
 import { z } from 'zod';
 import { useForm, useFormState } from 'react-hook-form';
 

package/src/hooks/index.ts

@@ -21,8 +21,11 @@ export { useFocusManagement } from './useFocusManagement';
 export { useFocusTrap } from './useFocusTrap';
 export { useKeyboardShortcuts } from './useKeyboardShortcuts';
 export { useIsMobile } from './useIsMobile';
+export { useIsPrint } from './useIsPrint';
 
 // === EVENT HOOKS ===
+export { useEvents, useOptionalEvents } from './useEvents';
+export type { EventContextType } from './useEvents';
 export { useEventTheme } from './useEventTheme';
 
 // === DATA & STATE HOOKS ===
@@ -57,8 +60,8 @@ export { useDataTablePerformance } from './useDataTablePerformance';
 export type { UseDataTablePerformanceOptions, UseDataTablePerformanceReturn } from './useDataTablePerformance';
 
 // === FILE DISPLAY HOOKS ===
-export { useFileDisplay, clearFileDisplayCache, getFileDisplayCacheStats, invalidateFileDisplayCache } from './useFileDisplay';
-export type { UseFileDisplayReturn, UseFileDisplayOptions } from './useFileDisplay';
+export { useFileDisplay, clearFileDisplayCache, getFileDisplayCacheStats, invalidateFileDisplayCache } from '../components/FileDisplay/useFileDisplay';
+export type { UseFileDisplayReturn, UseFileDisplayOptions } from '../components/FileDisplay/useFileDisplay';
 export { useFileUrlCache } from './useFileUrlCache';
 export type { UseFileUrlCacheReturn } from './useFileUrlCache';
 
@@ -68,7 +71,7 @@ export type { UseStorageOptions, UseStorageReturn } from './useStorage';
 
 // === PUBLIC DATA ACCESS HOOKS ===
 export { usePublicEvent, clearPublicEventCache, getPublicEventCacheStats } from './public/usePublicEvent';
-export { usePublicFileDisplay, clearPublicFileDisplayCache, getPublicFileDisplayCacheStats } from './public/usePublicFileDisplay';
+export { usePublicFileDisplay, clearPublicFileDisplayCache, getPublicFileDisplayCacheStats } from '../components/FileDisplay/usePublicFileDisplay';
 export { usePublicEventLogo, clearPublicLogoCache, getPublicLogoCacheStats } from './public/usePublicEventLogo';
 export { 
   usePublicRouteParams, 
@@ -77,7 +80,7 @@ export {
   extractEventCodeFromPath
 } from './public/usePublicRouteParams';
 export type { UsePublicEventReturn, UsePublicEventOptions } from './public/usePublicEvent';
-export type { UsePublicFileDisplayReturn, UsePublicFileDisplayOptions } from './public/usePublicFileDisplay';
+export type { UsePublicFileDisplayReturn, UsePublicFileDisplayOptions } from '../components/FileDisplay/usePublicFileDisplay';
 export type { UsePublicEventLogoReturn, UsePublicEventLogoOptions } from './public/usePublicEventLogo';
 export type { UsePublicRouteParamsReturn } from './public/usePublicRouteParams';
 

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

@@ -1,7 +1,7 @@
 /**
  * @file Hooks Index Exports Unit Tests
  * @package @jmruthers/pace-core
- * @module Hooks/__tests__
+ * @module Hooks
  * @since 0.1.0
  *
  * Tests to verify that all exports from the hooks index file are properly accessible.
@@ -9,7 +9,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import * as Hooks from '../index';
+import * as Hooks from './index';
 
 describe('hooks index exports', () => {
   describe('UI Interaction Hooks', () => {

package/src/hooks/public/usePublicEvent.test.ts

@@ -1,7 +1,7 @@
 /**
  * @file Unit Tests for usePublicEvent Hook
  * @package @jmruthers/pace-core
- * @module Hooks/Public/__tests__
+ * @module Hooks/Public
  * @since 1.0.0
  */
 

package/src/hooks/public/usePublicEventLogo.test.ts

@@ -1,7 +1,7 @@
 /**
  * @file Unit Tests for usePublicEventLogo Hook
  * @package @jmruthers/pace-core
- * @module Hooks/Public/__tests__
+ * @module Hooks/Public
  * @since 1.0.0
  */
 

package/src/hooks/public/usePublicRouteParams.test.ts

@@ -1,7 +1,7 @@
 /**
  * @file Unit Tests for usePublicRouteParams Hook
  * @package @jmruthers/pace-core
- * @module Hooks/Public/__tests__
+ * @module Hooks/Public
  * @since 1.0.0
  */
 

package/src/hooks/services/useAuth.ts

@@ -10,6 +10,8 @@
 
 import { useAuthService } from './useAuthService';
 import { type User, type Session, type SupabaseClient, AuthError } from '@supabase/supabase-js';
+import type { ApiResult } from '../../types/api-result';
+import type { AuthSessionData } from '../../services/interfaces/IAuthService';
 
 /**
  * Authentication state and methods returned by the useAuth hook.
@@ -28,19 +30,19 @@ export interface AuthState {
   /** Supabase client instance, or null if not available */
   supabase: SupabaseClient | null;
   
-  // Auth methods
+  // Auth methods (return standard ApiResult)
   /** Sign in with email and optional password */
-  signIn: (email: string, password?: string) => Promise<{ error: AuthError | null }>;
+  signIn: (email: string, password?: string) => Promise<ApiResult<AuthSessionData>>;
   /** Sign up with email and password */
-  signUp: (email: string, password: string) => Promise<{ error: AuthError | null }>;
+  signUp: (email: string, password: string) => Promise<ApiResult<AuthSessionData>>;
   /** Sign out the current user */
-  signOut: () => Promise<{ error: AuthError | null }>;
+  signOut: () => Promise<ApiResult<AuthSessionData>>;
   /** Request a password reset email */
-  resetPassword: (email: string) => Promise<{ error: AuthError | null }>;
+  resetPassword: (email: string) => Promise<ApiResult<AuthSessionData>>;
   /** Update the current user's password */
-  updatePassword: (password: string) => Promise<{ error: AuthError | null }>;
+  updatePassword: (password: string) => Promise<ApiResult<AuthSessionData>>;
   /** Refresh the current session */
-  refreshSession: () => Promise<{ error: AuthError | null }>;
+  refreshSession: () => Promise<ApiResult<AuthSessionData>>;
 }
 
 /**