@moontra/moonui-pro 2.20.1 → 2.20.2

package/src/__tests__/use-intersection-observer.test.tsx

@@ -1,216 +0,0 @@
-import { renderHook, act } from '@testing-library/react';
-import { useIntersectionObserver } from '../use-intersection-observer';
-
-// Mock IntersectionObserver
-const mockIntersectionObserver = jest.fn();
-mockIntersectionObserver.mockImplementation((callback, options) => {
-  return {
-    observe: jest.fn(),
-    unobserve: jest.fn(),
-    disconnect: jest.fn(),
-  };
-});
-
-beforeAll(() => {
-  global.IntersectionObserver = mockIntersectionObserver;
-});
-
-describe('useIntersectionObserver', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should return ref and isIntersecting state', () => {
-    const { result } = renderHook(() => useIntersectionObserver());
-    
-    expect(result.current.ref).toBeDefined();
-    expect(result.current.isIntersecting).toBe(false);
-    expect(typeof result.current.ref).toBe('function');
-  });
-
-  it('should create IntersectionObserver with default options', () => {
-    renderHook(() => useIntersectionObserver());
-    
-    expect(mockIntersectionObserver).toHaveBeenCalledWith(
-      expect.any(Function),
-      {
-        threshold: 0,
-        root: null,
-        rootMargin: '0%',
-      }
-    );
-  });
-
-  it('should create IntersectionObserver with custom options', () => {
-    const options = {
-      threshold: 0.5,
-      root: document.body,
-      rootMargin: '10px',
-    };
-    
-    renderHook(() => useIntersectionObserver(options));
-    
-    expect(mockIntersectionObserver).toHaveBeenCalledWith(
-      expect.any(Function),
-      options
-    );
-  });
-
-  it('should observe element when ref is set', () => {
-    const mockObserve = jest.fn();
-    mockIntersectionObserver.mockImplementation(() => ({
-      observe: mockObserve,
-      unobserve: jest.fn(),
-      disconnect: jest.fn(),
-    }));
-
-    const { result } = renderHook(() => useIntersectionObserver());
-    
-    const mockElement = document.createElement('div');
-    
-    act(() => {
-      result.current.ref(mockElement);
-    });
-    
-    expect(mockObserve).toHaveBeenCalledWith(mockElement);
-  });
-
-  it('should call onChange when intersection state changes', () => {
-    const mockOnChange = jest.fn();
-    let observerCallback: any;
-    
-    mockIntersectionObserver.mockImplementation((callback) => {
-      observerCallback = callback;
-      return {
-        observe: jest.fn(),
-        unobserve: jest.fn(),
-        disconnect: jest.fn(),
-      };
-    });
-
-    const { result } = renderHook(() => 
-      useIntersectionObserver({ onChange: mockOnChange })
-    );
-    
-    const mockElement = document.createElement('div');
-    const mockEntry = {
-      isIntersecting: true,
-      target: mockElement,
-    };
-    
-    act(() => {
-      result.current.ref(mockElement);
-    });
-    
-    act(() => {
-      observerCallback([mockEntry]);
-    });
-    
-    expect(mockOnChange).toHaveBeenCalledWith(true, mockEntry);
-  });
-
-  it('should freeze state when freezeOnceVisible is true', () => {
-    let observerCallback: any;
-    
-    mockIntersectionObserver.mockImplementation((callback) => {
-      observerCallback = callback;
-      return {
-        observe: jest.fn(),
-        unobserve: jest.fn(),
-        disconnect: jest.fn(),
-      };
-    });
-
-    const { result } = renderHook(() => 
-      useIntersectionObserver({ freezeOnceVisible: true })
-    );
-    
-    const mockElement = document.createElement('div');
-    const mockEntry = {
-      isIntersecting: true,
-      target: mockElement,
-    };
-    
-    act(() => {
-      result.current.ref(mockElement);
-    });
-    
-    // First intersection - should update
-    act(() => {
-      observerCallback([mockEntry]);
-    });
-    
-    expect(result.current.isIntersecting).toBe(true);
-    
-    // Second intersection with false - should not update (frozen)
-    act(() => {
-      observerCallback([{ ...mockEntry, isIntersecting: false }]);
-    });
-    
-    expect(result.current.isIntersecting).toBe(true);
-  });
-
-  it('should disconnect observer on unmount', () => {
-    const mockDisconnect = jest.fn();
-    mockIntersectionObserver.mockImplementation(() => ({
-      observe: jest.fn(),
-      unobserve: jest.fn(),
-      disconnect: mockDisconnect,
-    }));
-
-    const { unmount } = renderHook(() => useIntersectionObserver());
-    
-    unmount();
-    
-    expect(mockDisconnect).toHaveBeenCalled();
-  });
-
-  it('should handle initialIsIntersecting option', () => {
-    const { result } = renderHook(() => 
-      useIntersectionObserver({ initialIsIntersecting: true })
-    );
-    
-    expect(result.current.isIntersecting).toBe(true);
-  });
-
-  it('should not create observer when IntersectionObserver is not supported', () => {
-    // Temporarily remove IntersectionObserver
-    const originalIntersectionObserver = global.IntersectionObserver;
-    (global as any).IntersectionObserver = undefined;
-    
-    const { result } = renderHook(() => useIntersectionObserver());
-    
-    expect(result.current.ref).toBeDefined();
-    expect(result.current.isIntersecting).toBe(false);
-    
-    // Restore IntersectionObserver
-    global.IntersectionObserver = originalIntersectionObserver;
-  });
-
-  it('should handle multiple elements with useMultipleIntersectionObserver', () => {
-    // This would be a separate hook, but we can test the concept
-    const mockObserve = jest.fn();
-    const mockUnobserve = jest.fn();
-    
-    mockIntersectionObserver.mockImplementation(() => ({
-      observe: mockObserve,
-      unobserve: mockUnobserve,
-      disconnect: jest.fn(),
-    }));
-
-    const { result } = renderHook(() => useIntersectionObserver());
-    
-    const element1 = document.createElement('div');
-    const element2 = document.createElement('div');
-    
-    act(() => {
-      result.current.ref(element1);
-    });
-    
-    act(() => {
-      result.current.ref(element2);
-    });
-    
-    expect(mockObserve).toHaveBeenCalledWith(element2);
-  });
-});

package/src/__tests__/use-local-storage.test.tsx

@@ -1,174 +0,0 @@
-import { renderHook, act } from '@testing-library/react'
-import { useLocalStorage } from '../use-local-storage'
-
-// Mock localStorage
-const mockLocalStorage = (() => {
-  let store: Record<string, string> = {}
-
-  return {
-    getItem: jest.fn((key: string) => store[key] || null),
-    setItem: jest.fn((key: string, value: string) => {
-      store[key] = value
-    }),
-    removeItem: jest.fn((key: string) => {
-      delete store[key]
-    }),
-    clear: jest.fn(() => {
-      store = {}
-    }),
-    get length() {
-      return Object.keys(store).length
-    },
-    key: jest.fn((index: number) => Object.keys(store)[index] || null),
-  }
-})()
-
-Object.defineProperty(window, 'localStorage', {
-  value: mockLocalStorage,
-})
-
-describe('useLocalStorage', () => {
-  beforeEach(() => {
-    mockLocalStorage.clear()
-    jest.clearAllMocks()
-  })
-
-  it('returns initial value when localStorage is empty', () => {
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    expect(result.current[0]).toBe('initial')
-    expect(mockLocalStorage.getItem).toHaveBeenCalledWith('test-key')
-  })
-
-  it('returns stored value from localStorage', () => {
-    mockLocalStorage.setItem('test-key', JSON.stringify('stored-value'))
-    
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    expect(result.current[0]).toBe('stored-value')
-  })
-
-  it('stores value in localStorage when setValue is called', () => {
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    act(() => {
-      result.current[1]('new-value')
-    })
-    
-    expect(result.current[0]).toBe('new-value')
-    expect(mockLocalStorage.setItem).toHaveBeenCalledWith('test-key', JSON.stringify('new-value'))
-  })
-
-  it('handles function updates', () => {
-    const { result } = renderHook(() => useLocalStorage('test-key', 10))
-    
-    act(() => {
-      result.current[1]((prev) => (prev ?? 0) + 5)
-    })
-    
-    expect(result.current[0]).toBe(15)
-    expect(mockLocalStorage.setItem).toHaveBeenCalledWith('test-key', JSON.stringify(15))
-  })
-
-  it('handles complex objects', () => {
-    const initialObject = { name: 'test', count: 0 }
-    const { result } = renderHook(() => useLocalStorage('object-key', initialObject))
-    
-    const newObject = { name: 'updated', count: 5 }
-    
-    act(() => {
-      result.current[1](newObject)
-    })
-    
-    expect(result.current[0]).toEqual(newObject)
-    expect(mockLocalStorage.setItem).toHaveBeenCalledWith('object-key', JSON.stringify(newObject))
-  })
-
-  it('handles localStorage errors gracefully', () => {
-    mockLocalStorage.setItem.mockImplementation(() => {
-      throw new Error('Storage quota exceeded')
-    })
-    
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
-    
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    act(() => {
-      result.current[1]('new-value')
-    })
-    
-    // Should still update the state even if localStorage fails
-    expect(result.current[0]).toBe('new-value')
-    expect(consoleSpy).toHaveBeenCalled()
-    
-    consoleSpy.mockRestore()
-  })
-
-  it('handles malformed JSON in localStorage', () => {
-    mockLocalStorage.getItem.mockReturnValue('invalid-json{')
-    
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
-    
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    // Should fall back to initial value when JSON parsing fails
-    expect(result.current[0]).toBe('initial')
-    expect(consoleSpy).toHaveBeenCalled()
-    
-    consoleSpy.mockRestore()
-  })
-
-  it('removes item from localStorage when value is undefined', () => {
-    mockLocalStorage.setItem('test-key', JSON.stringify('stored-value'))
-    
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    act(() => {
-      result.current[1](undefined)
-    })
-    
-    expect(result.current[0]).toBeUndefined()
-    expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('test-key')
-  })
-
-  it('handles boolean values correctly', () => {
-    const { result } = renderHook(() => useLocalStorage('bool-key', false))
-    
-    act(() => {
-      result.current[1](true)
-    })
-    
-    expect(result.current[0]).toBe(true)
-    expect(mockLocalStorage.setItem).toHaveBeenCalledWith('bool-key', JSON.stringify(true))
-  })
-
-  it('handles null values correctly', () => {
-    const { result } = renderHook(() => useLocalStorage<string | null>('null-key', null))
-    
-    act(() => {
-      result.current[1]('not-null')
-    })
-    
-    expect(result.current[0]).toBe('not-null')
-    
-    act(() => {
-      result.current[1](null)
-    })
-    
-    expect(result.current[0]).toBe(null)
-    expect(mockLocalStorage.setItem).toHaveBeenCalledWith('null-key', JSON.stringify(null))
-  })
-
-  it('maintains state consistency across multiple hook instances with same key', () => {
-    const { result: result1 } = renderHook(() => useLocalStorage('shared-key', 'initial'))
-    const { result: result2 } = renderHook(() => useLocalStorage('shared-key', 'initial'))
-    
-    act(() => {
-      result1.current[1]('updated')
-    })
-    
-    // Both instances should have the same value
-    expect(result1.current[0]).toBe('updated')
-    expect(result2.current[0]).toBe('updated')
-  })
-})

package/src/__tests__/use-pro-access.test.tsx

@@ -1,183 +0,0 @@
-import { renderHook } from '@testing-library/react'
-import { useSession } from 'next-auth/react'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { useProAccess } from '../use-pro-access'
-import React from 'react'
-
-// Mock next-auth
-jest.mock('next-auth/react')
-const mockUseSession = useSession as jest.MockedFunction<typeof useSession>
-
-// Mock fetch
-global.fetch = jest.fn()
-
-// Test wrapper with QueryClient
-const createWrapper = () => {
-  const queryClient = new QueryClient({
-    defaultOptions: {
-      queries: {
-        retry: false,
-      },
-    },
-  })
-  const TestWrapper = ({ children }: { children: React.ReactNode }) => (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-  )
-  TestWrapper.displayName = 'TestWrapper'
-  return TestWrapper
-}
-
-describe('useProAccess Hook', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('returns false for unauthenticated users', () => {
-    mockUseSession.mockReturnValue({
-      data: null,
-      status: 'unauthenticated',
-      update: jest.fn(),
-    })
-
-    const { result } = renderHook(() => useProAccess(), {
-      wrapper: createWrapper()
-    })
-    expect(result.current.hasProAccess).toBe(false)
-    expect(result.current.isLoading).toBe(false)
-  })
-
-  it('returns false for authenticated users without pro subscription', () => {
-    mockUseSession.mockReturnValue({
-      data: {
-        user: {
-          id: '1',
-          email: 'user@example.com',
-          name: 'Test User',
-        },
-        expires: '2024-12-31',
-      },
-      status: 'authenticated',
-      update: jest.fn(),
-    })
-
-    const { result } = renderHook(() => useProAccess(), {
-      wrapper: createWrapper()
-    })
-    expect(result.current.hasProAccess).toBe(false)
-    expect(result.current.isLoading).toBe(false)
-  })
-
-  it('returns true for authenticated users with active pro subscription', () => {
-    mockUseSession.mockReturnValue({
-      data: {
-        user: {
-          id: '1',
-          email: 'pro@example.com',
-          name: 'Pro User',
-          subscription: {
-            plan: 'pro',
-            status: 'active',
-            expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(), // 30 days from now
-          },
-        },
-        expires: '2024-12-31',
-      },
-      status: 'authenticated',
-      update: jest.fn(),
-    })
-
-    const { result } = renderHook(() => useProAccess(), {
-      wrapper: createWrapper()
-    })
-    expect(result.current.hasProAccess).toBe(true)
-    expect(result.current.isLoading).toBe(false)
-  })
-
-  it('returns false for users with expired pro subscription', () => {
-    mockUseSession.mockReturnValue({
-      data: {
-        user: {
-          id: '1',
-          email: 'expired@example.com',
-          name: 'Expired User',
-          subscription: {
-            plan: 'pro',
-            status: 'active',
-            expiresAt: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(), // 1 day ago
-          },
-        },
-        expires: '2024-12-31',
-      },
-      status: 'authenticated',
-      update: jest.fn(),
-    })
-
-    const { result } = renderHook(() => useProAccess(), {
-      wrapper: createWrapper()
-    })
-    expect(result.current.hasProAccess).toBe(false)
-    expect(result.current.isLoading).toBe(false)
-  })
-
-  it('returns false for users with cancelled pro subscription', () => {
-    mockUseSession.mockReturnValue({
-      data: {
-        user: {
-          id: '1',
-          email: 'cancelled@example.com',
-          name: 'Cancelled User',
-          subscription: {
-            plan: 'pro',
-            status: 'cancelled',
-            expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
-          },
-        },
-        expires: '2024-12-31',
-      },
-      status: 'authenticated',
-      update: jest.fn(),
-    })
-
-    const { result } = renderHook(() => useProAccess(), {
-      wrapper: createWrapper()
-    })
-    expect(result.current.hasProAccess).toBe(false)
-    expect(result.current.isLoading).toBe(false)
-  })
-
-  it('returns loading state when session is loading', () => {
-    mockUseSession.mockReturnValue({
-      data: null,
-      status: 'loading',
-      update: jest.fn(),
-    })
-
-    const { result } = renderHook(() => useProAccess(), {
-      wrapper: createWrapper()
-    })
-    expect(result.current.hasProAccess).toBe(false)
-    expect(result.current.isLoading).toBe(true)
-  })
-
-  it('handles edge cases with missing subscription data', () => {
-    mockUseSession.mockReturnValue({
-      data: {
-        user: {
-          id: '1',
-          email: 'user@example.com',
-          name: 'Test User',
-          subscription: undefined,
-        },
-        expires: '2024-12-31',
-      },
-      status: 'authenticated',
-      update: jest.fn(),
-    })
-
-    const { result } = renderHook(() => useProAccess(), {
-      wrapper: createWrapper()
-    })
-    expect(result.current.hasProAccess).toBe(false)
-    expect(result.current.isLoading).toBe(false)
-  })
-})