@jmruthers/pace-core 0.5.181 → 0.5.183

package/src/hooks/useCounter.test.ts

@@ -1,131 +0,0 @@
-/**
- * @file useCounter Hook Tests
- * @description Example hook testing patterns and best practices
- */
-
-import React from 'react';
-import { renderHook, act } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// Mock hook implementation for demonstration
-const useCounter = (initialValue = 0) => {
-  const [count, setCount] = React.useState(initialValue);
-  
-  const increment = () => setCount(c => c + 1);
-  const decrement = () => setCount(c => c - 1);
-  const reset = () => setCount(initialValue);
-  
-  return { count, increment, decrement, reset };
-};
-
-describe('useCounter Hook', () => {
-    describe('Initialization', () => {
-    it('initializes with default value', () => {
-      const { result } = renderHook(() => useCounter());
-      expect(result.current.count).toBe(0);
-    });
-
-    it('initializes with custom value', () => {
-      const { result } = renderHook(() => useCounter(5));
-      expect(result.current.count).toBe(5);
-    });
-  });
-
-  describe('State Updates', () => {
-    it('increments count', () => {
-      const { result } = renderHook(() => useCounter(0));
-      
-      act(() => {
-        result.current.increment();
-      });
-      
-      expect(result.current.count).toBe(1);
-    });
-
-    it('decrements count', () => {
-      const { result } = renderHook(() => useCounter(5));
-      
-      act(() => {
-        result.current.decrement();
-      });
-      
-      expect(result.current.count).toBe(4);
-    });
-
-    it('resets count to initial value', () => {
-      const { result } = renderHook(() => useCounter(10));
-      
-      act(() => {
-        result.current.increment();
-        result.current.increment();
-      });
-      
-      expect(result.current.count).toBe(12);
-      
-      act(() => {
-        result.current.reset();
-      });
-      
-      expect(result.current.count).toBe(10);
-    });
-  });
-
-  describe('Multiple Updates', () => {
-    it('handles multiple increments', () => {
-      const { result } = renderHook(() => useCounter(0));
-      
-      act(() => {
-        result.current.increment();
-        result.current.increment();
-        result.current.increment();
-      });
-      
-      expect(result.current.count).toBe(3);
-    });
-
-    it('handles mixed operations', () => {
-      const { result } = renderHook(() => useCounter(10));
-      
-      act(() => {
-        result.current.increment();
-        result.current.decrement();
-        result.current.increment();
-        result.current.increment();
-      });
-      
-      expect(result.current.count).toBe(12);
-    });
-  });
-
-  describe('Hook Re-renders', () => {
-    it('maintains state across re-renders', () => {
-      const { result, rerender } = renderHook(() => useCounter(0));
-      
-      act(() => {
-        result.current.increment();
-      });
-      
-      expect(result.current.count).toBe(1);
-      
-      rerender();
-      
-      expect(result.current.count).toBe(1);
-    });
-  });
-});
-
-// Example of testing a hook with dependencies
-describe('useCounter with Dependencies', () => {
-  it('updates when initial value changes', () => {
-    let initialValue = 0;
-    const { result, rerender } = renderHook(() => useCounter(initialValue));
-    
-    expect(result.current.count).toBe(0);
-    
-    initialValue = 10;
-    rerender();
-    
-    // Note: This would require the hook to be updated to handle prop changes
-    // This is just an example of how you might test such scenarios
-  });
-});

package/src/hooks/useDebounce.test.ts

@@ -1,375 +0,0 @@
-/**
- * @file useDebounce Hook Tests
- * @description Comprehensive tests for the useDebounce hook
- */
-
-import { renderHook, act } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { useDebounce } from './useDebounce';
-
-describe('useDebounce Hook', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  describe('Initialization', () => {
-    it('initializes with the provided value', () => {
-      const { result } = renderHook(() => useDebounce('initial', 100));
-      
-      expect(result.current).toBe('initial');
-    });
-
-    it('initializes with different types of values', () => {
-      const { result: stringResult } = renderHook(() => useDebounce('string', 100));
-      const { result: numberResult } = renderHook(() => useDebounce(42, 100));
-      const { result: booleanResult } = renderHook(() => useDebounce(true, 100));
-      const { result: objectResult } = renderHook(() => useDebounce({ key: 'value' }, 100));
-      const { result: arrayResult } = renderHook(() => useDebounce([1, 2, 3], 100));
-      
-      expect(stringResult.current).toBe('string');
-      expect(numberResult.current).toBe(42);
-      expect(booleanResult.current).toBe(true);
-      expect(objectResult.current).toEqual({ key: 'value' });
-      expect(arrayResult.current).toEqual([1, 2, 3]);
-    });
-
-    it('initializes with null and undefined values', () => {
-      const { result: nullResult } = renderHook(() => useDebounce(null, 100));
-      const { result: undefinedResult } = renderHook(() => useDebounce(undefined, 100));
-      
-      expect(nullResult.current).toBeNull();
-      expect(undefinedResult.current).toBeUndefined();
-    });
-  });
-
-  describe('Debouncing Behavior', () => {
-    it('does not update immediately when value changes', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 100),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      expect(result.current).toBe('initial');
-      
-      rerender({ value: 'updated' });
-      
-      // Value should not have changed yet
-      expect(result.current).toBe('initial');
-    });
-
-    it('updates after the delay period', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 100),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      rerender({ value: 'updated' });
-      
-      // Fast-forward time by 100ms
-      act(() => {
-        vi.advanceTimersByTime(100);
-      });
-      
-      expect(result.current).toBe('updated');
-    });
-
-    it('resets the timer when value changes before delay completes', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 100),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      // Change value
-      rerender({ value: 'first' });
-      
-      // Fast-forward 50ms (half the delay)
-      act(() => {
-        vi.advanceTimersByTime(50);
-      });
-      
-      // Value should still be initial
-      expect(result.current).toBe('initial');
-      
-      // Change value again
-      rerender({ value: 'second' });
-      
-      // Fast-forward another 50ms (total 100ms from first change)
-      act(() => {
-        vi.advanceTimersByTime(50);
-      });
-      
-      // Value should still be initial (timer was reset)
-      expect(result.current).toBe('initial');
-      
-      // Fast-forward another 100ms (total 150ms from second change)
-      act(() => {
-        vi.advanceTimersByTime(100);
-      });
-      
-      // Now it should be updated to 'second'
-      expect(result.current).toBe('second');
-    });
-
-    it('handles multiple rapid changes correctly', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 100),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      // Make multiple rapid changes
-      rerender({ value: 'first' });
-      rerender({ value: 'second' });
-      rerender({ value: 'third' });
-      rerender({ value: 'fourth' });
-      
-      // Fast-forward 50ms
-      act(() => {
-        vi.advanceTimersByTime(50);
-      });
-      
-      // Should still be initial
-      expect(result.current).toBe('initial');
-      
-      // Fast-forward another 100ms (total 150ms from last change)
-      act(() => {
-        vi.advanceTimersByTime(100);
-      });
-      
-      // Should be updated to the last value
-      expect(result.current).toBe('fourth');
-    });
-  });
-
-  describe('Delay Variations', () => {
-    it('works with zero delay', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 0),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      rerender({ value: 'updated' });
-      
-      // With zero delay, should update immediately
-      act(() => {
-        vi.advanceTimersByTime(0);
-      });
-      
-      expect(result.current).toBe('updated');
-    });
-
-    it('works with very short delay', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 1),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      rerender({ value: 'updated' });
-      
-      act(() => {
-        vi.advanceTimersByTime(1);
-      });
-      
-      expect(result.current).toBe('updated');
-    });
-
-    it('works with long delay', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 5000),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      rerender({ value: 'updated' });
-      
-      // Should not update before delay
-      act(() => {
-        vi.advanceTimersByTime(4999);
-      });
-      
-      expect(result.current).toBe('initial');
-      
-      // Should update after delay
-      act(() => {
-        vi.advanceTimersByTime(1);
-      });
-      
-      expect(result.current).toBe('updated');
-    });
-  });
-
-  describe('Cleanup', () => {
-    it('cleans up timer on unmount', () => {
-      const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout');
-      const { unmount } = renderHook(() => useDebounce('test', 100));
-      
-      unmount();
-      
-      expect(clearTimeoutSpy).toHaveBeenCalled();
-    });
-
-    it('cleans up previous timer when value changes', () => {
-      const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout');
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 100),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      // Change value multiple times
-      rerender({ value: 'first' });
-      rerender({ value: 'second' });
-      rerender({ value: 'third' });
-      
-      // Each change should clear the previous timer
-      expect(clearTimeoutSpy).toHaveBeenCalledTimes(3);
-    });
-
-    it('cleans up timer when delay changes', () => {
-      const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout');
-      const { rerender } = renderHook(
-        ({ value, delay }) => useDebounce(value, delay),
-        { initialProps: { value: 'test', delay: 100 } }
-      );
-      
-      // Change delay
-      rerender({ value: 'test', delay: 200 });
-      
-      expect(clearTimeoutSpy).toHaveBeenCalled();
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('handles negative delay gracefully', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, -100),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      rerender({ value: 'updated' });
-      
-      // Should update immediately with negative delay
-      act(() => {
-        vi.advanceTimersByTime(0);
-      });
-      
-      expect(result.current).toBe('updated');
-    });
-
-    it('handles very large delay values', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, Number.MAX_SAFE_INTEGER),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      rerender({ value: 'updated' });
-      
-      // Very large numbers are clamped by setTimeout, so it will update
-      // This test verifies the hook doesn't crash with large values
-      act(() => {
-        vi.advanceTimersByTime(1000000); // 1 million ms
-      });
-      
-      // The value should have updated due to setTimeout clamping
-      expect(result.current).toBe('updated');
-    });
-
-    it('handles NaN delay', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, NaN),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      rerender({ value: 'updated' });
-      
-      // Should update immediately with NaN delay
-      act(() => {
-        vi.advanceTimersByTime(0);
-      });
-      
-      expect(result.current).toBe('updated');
-    });
-
-    it('handles Infinity delay', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, Infinity),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      rerender({ value: 'updated' });
-      
-      // Infinity is clamped by setTimeout, so it will update
-      // This test verifies the hook doesn't crash with Infinity
-      act(() => {
-        vi.advanceTimersByTime(1000000); // 1 million ms
-      });
-      
-      // The value should have updated due to setTimeout clamping
-      expect(result.current).toBe('updated');
-    });
-  });
-
-  describe('Reference Equality', () => {
-    it('maintains reference equality for same values', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 100),
-        { initialProps: { value: { key: 'value' } } }
-      );
-      
-      const initialResult = result.current;
-      
-      // Change to same object reference
-      rerender({ value: { key: 'value' } });
-      
-      act(() => {
-        vi.advanceTimersByTime(100);
-      });
-      
-      // Should be different reference (new object)
-      expect(result.current).not.toBe(initialResult);
-      expect(result.current).toEqual(initialResult);
-    });
-
-    it('maintains reference equality for primitive values', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 100),
-        { initialProps: { value: 'same' } }
-      );
-      
-      const initialResult = result.current;
-      
-      // Change to same primitive value
-      rerender({ value: 'same' });
-      
-      act(() => {
-        vi.advanceTimersByTime(100);
-      });
-      
-      // Should be same reference for primitives
-      expect(result.current).toBe(initialResult);
-    });
-  });
-
-  describe('Concurrent Updates', () => {
-    it('handles concurrent value changes correctly', () => {
-      const { result, rerender } = renderHook(
-        ({ value }) => useDebounce(value, 100),
-        { initialProps: { value: 'initial' } }
-      );
-      
-      // Make multiple changes in quick succession
-      rerender({ value: 'first' });
-      rerender({ value: 'second' });
-      rerender({ value: 'third' });
-      
-      // Fast-forward time
-      act(() => {
-        vi.advanceTimersByTime(100);
-      });
-      
-      // Should only have the last value
-      expect(result.current).toBe('third');
-    });
-  });
-});

package/src/providers/AuthProvider.tsx

@@ -1,15 +0,0 @@
-/**
- * @file Re-export for AuthProvider
- * @package @jmruthers/pace-core
- * @module Providers
- * @since 0.1.0
- * 
- * Re-exports the service-based AuthProvider for backward compatibility.
- */
-
-export { AuthServiceProvider as AuthProvider } from './services/AuthServiceProvider';
-export type { AuthServiceProviderProps as AuthProviderProps, AuthServiceContextType as AuthContextType } from './services/AuthServiceProvider';
-
-// Re-export hook
-export { useAuthService as useAuth } from '../hooks/services/useAuthService';
-

package/src/providers/EventProvider.tsx

@@ -1,16 +0,0 @@
-/**
- * @file Re-export for EventProvider
- * @package @jmruthers/pace-core
- * @module Providers
- * @since 0.1.0
- * 
- * Re-exports the service-based EventProvider for backward compatibility.
- */
-
-export { EventServiceProvider as EventProvider } from './services/EventServiceProvider';
-export type { EventServiceProviderProps as EventProviderProps } from './services/EventServiceProvider';
-
-// Re-export context and hook  
-export { EventServiceContext, useEventService } from './services/EventServiceProvider';
-export type { EventServiceContextType, EventContextType } from './services/EventServiceProvider';
-

package/src/providers/InactivityProvider.tsx

@@ -1,15 +0,0 @@
-/**
- * @file Re-export for InactivityProvider
- * @package @jmruthers/pace-core
- * @module Providers
- * @since 0.1.0
- * 
- * Re-exports the service-based InactivityProvider for backward compatibility.
- */
-
-export { InactivityServiceProvider as InactivityProvider } from './services/InactivityServiceProvider';
-export type { InactivityServiceProviderProps as InactivityProviderProps, InactivityServiceContextType as InactivityContextType } from './services/InactivityServiceProvider';
-
-// Re-export hook
-export { useInactivityService as useInactivity } from '../hooks/services/useInactivityService';
-