@youversion/platform-react-hooks 1.18.1 → 1.20.0

package/src/useBook.test.tsx

@@ -0,0 +1,158 @@
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { describe, expect, vi, beforeEach, it } from 'vitest';
+import { useBook } from './useBook';
+import { type BibleClient } from '@youversion/platform-core';
+import { useBibleClient } from './useBibleClient';
+import { createYVWrapper } from './test/utils';
+import { createMockBook } from './__tests__/mocks/bibles';
+
+vi.mock('./useBibleClient');
+
+describe('useBook', () => {
+  const mockGetBook = vi.fn();
+  const mockBook = createMockBook();
+
+  beforeEach(() => {
+    mockGetBook.mockResolvedValue(mockBook);
+
+    const mockClient: Partial<BibleClient> = { getBook: mockGetBook };
+    vi.mocked(useBibleClient).mockReturnValue(mockClient as BibleClient);
+  });
+
+  describe('fetching book', () => {
+    it('should fetch book with versionId and book params', async () => {
+      const wrapper = createYVWrapper();
+      const { result } = renderHook(() => useBook(111, 'GEN'), { wrapper });
+
+      expect(result.current.loading).toBe(true);
+      expect(result.current.book).toBe(null);
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(mockGetBook).toHaveBeenCalledWith(111, 'GEN');
+      expect.soft(result.current.book).toEqual(mockBook);
+    });
+
+    it.each([
+      {
+        param: 'versionId',
+        HookFn: ({ val }: { val: number | string }) => useBook(val as number, 'GEN'),
+        initial: { val: 1 },
+        updated: { val: 111 },
+        expectedInitial: [1, 'GEN'],
+        expectedUpdated: [111, 'GEN'],
+      },
+      {
+        param: 'book',
+        HookFn: ({ val }: { val: number | string }) => useBook(1, val as string),
+        initial: { val: 'GEN' },
+        updated: { val: 'EXO' },
+        expectedInitial: [1, 'GEN'],
+        expectedUpdated: [1, 'EXO'],
+      },
+    ])(
+      'should refetch when $param changes',
+      async ({ HookFn, initial, updated, expectedInitial, expectedUpdated }) => {
+        const wrapper = createYVWrapper();
+        const { result, rerender } = renderHook(HookFn, {
+          wrapper,
+          initialProps: initial,
+        });
+
+        await waitFor(() => {
+          expect(result.current.loading).toBe(false);
+        });
+
+        expect.soft(mockGetBook).toHaveBeenCalledTimes(1);
+        expect.soft(mockGetBook).toHaveBeenLastCalledWith(...expectedInitial);
+
+        act(() => {
+          rerender(updated);
+        });
+
+        await waitFor(() => {
+          expect(result.current.loading).toBe(false);
+        });
+
+        expect.soft(mockGetBook).toHaveBeenCalledTimes(2);
+        expect.soft(mockGetBook).toHaveBeenLastCalledWith(...expectedUpdated);
+      },
+    );
+
+    it('should not fetch when enabled is false', async () => {
+      const wrapper = createYVWrapper();
+      const { result } = renderHook(() => useBook(1, 'GEN', { enabled: false }), {
+        wrapper,
+      });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(mockGetBook).not.toHaveBeenCalled();
+      expect.soft(result.current.book).toBe(null);
+    });
+
+    it('should handle fetch errors', async () => {
+      const wrapper = createYVWrapper();
+      const error = new Error('Failed to fetch book');
+      mockGetBook.mockRejectedValueOnce(error);
+
+      const { result } = renderHook(() => useBook(1, 'GEN'), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(result.current.error).toEqual(error);
+      expect.soft(result.current.book).toBe(null);
+    });
+
+    it('should clear error on successful refetch', async () => {
+      const wrapper = createYVWrapper();
+      const error = new Error('Failed to fetch book');
+      mockGetBook.mockRejectedValueOnce(error).mockResolvedValueOnce(mockBook);
+
+      const { result } = renderHook(() => useBook(1, 'GEN'), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(result.current.error).toEqual(error);
+      expect.soft(result.current.book).toBe(null);
+
+      act(() => {
+        result.current.refetch();
+      });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(result.current.error).toBe(null);
+      expect.soft(result.current.book).toEqual(mockBook);
+    });
+
+    it('should support manual refetch', async () => {
+      const wrapper = createYVWrapper();
+      const { result } = renderHook(() => useBook(1, 'GEN'), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect(mockGetBook).toHaveBeenCalledTimes(1);
+
+      act(() => {
+        result.current.refetch();
+      });
+
+      await waitFor(() => {
+        expect(mockGetBook).toHaveBeenCalledTimes(2);
+      });
+    });
+  });
+});

package/src/useBooks.test.tsx

@@ -0,0 +1,148 @@
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { describe, expect, vi, beforeEach, it } from 'vitest';
+import { useBooks } from './useBooks';
+import { type BibleClient, type BibleBook, type Collection } from '@youversion/platform-core';
+import { useBibleClient } from './useBibleClient';
+import { createYVWrapper } from './test/utils';
+import { createMockBook } from './__tests__/mocks/bibles';
+
+vi.mock('./useBibleClient');
+
+describe('useBooks', () => {
+  const mockGetBooks = vi.fn();
+
+  const mockBooks: Collection<BibleBook> = {
+    data: [
+      createMockBook(),
+      createMockBook({
+        id: 'EXO',
+        title: 'Exodus',
+        full_title: 'The Second Book of Moses, Commonly Called Exodus',
+        abbreviation: 'Exod',
+      }),
+    ],
+    next_page_token: null,
+  };
+
+  beforeEach(() => {
+    mockGetBooks.mockResolvedValue(mockBooks);
+
+    const mockClient: Partial<BibleClient> = { getBooks: mockGetBooks };
+    vi.mocked(useBibleClient).mockReturnValue(mockClient as BibleClient);
+  });
+
+  describe('fetching books', () => {
+    it('should fetch all books for a version', async () => {
+      const wrapper = createYVWrapper();
+      const { result } = renderHook(() => useBooks(111), { wrapper });
+
+      expect(result.current.loading).toBe(true);
+      expect(result.current.books).toBe(null);
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(mockGetBooks).toHaveBeenCalledWith(111);
+      expect.soft(result.current.books).toEqual(mockBooks);
+    });
+
+    it('should refetch when versionId changes', async () => {
+      const wrapper = createYVWrapper();
+      const { result, rerender } = renderHook(({ versionId }) => useBooks(versionId), {
+        wrapper,
+        initialProps: { versionId: 111 },
+      });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(mockGetBooks).toHaveBeenCalledTimes(1);
+      expect.soft(mockGetBooks).toHaveBeenLastCalledWith(111);
+
+      rerender({ versionId: 1 });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(mockGetBooks).toHaveBeenCalledTimes(2);
+      expect.soft(mockGetBooks).toHaveBeenLastCalledWith(1);
+    });
+
+    it('should not fetch when enabled is false', async () => {
+      const wrapper = createYVWrapper();
+      const { result } = renderHook(() => useBooks(111, { enabled: false }), {
+        wrapper,
+      });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(mockGetBooks).not.toHaveBeenCalled();
+      expect.soft(result.current.books).toBe(null);
+    });
+
+    it('should handle fetch errors', async () => {
+      const wrapper = createYVWrapper();
+      const error = new Error('Failed to fetch books');
+      mockGetBooks.mockRejectedValueOnce(error);
+
+      const { result } = renderHook(() => useBooks(111), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(result.current.error).toEqual(error);
+      expect.soft(result.current.books).toBe(null);
+    });
+
+    it('should clear error on successful refetch', async () => {
+      const wrapper = createYVWrapper();
+      const error = new Error('Failed to fetch books');
+      mockGetBooks.mockRejectedValueOnce(error).mockResolvedValueOnce(mockBooks);
+
+      const { result } = renderHook(() => useBooks(111), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(result.current.error).toEqual(error);
+      expect.soft(result.current.books).toBe(null);
+
+      act(() => {
+        result.current.refetch();
+      });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect.soft(result.current.error).toBe(null);
+      expect.soft(result.current.books).toEqual(mockBooks);
+    });
+
+    it('should support manual refetch', async () => {
+      const wrapper = createYVWrapper();
+      const { result } = renderHook(() => useBooks(111), { wrapper });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect(mockGetBooks).toHaveBeenCalledTimes(1);
+
+      act(() => {
+        result.current.refetch();
+      });
+
+      await waitFor(() => {
+        expect(mockGetBooks).toHaveBeenCalledTimes(2);
+      });
+    });
+  });
+});

package/src/useChapter.test.tsx

@@ -1,15 +1,13 @@
 import { renderHook, waitFor, act } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { ReactNode } from 'react';
+import { describe, expect, vi, beforeEach, it } from 'vitest';
 import { useChapter } from './useChapter';
-import { YouVersionContext } from './context';
 import { type BibleClient, type BibleChapter } from '@youversion/platform-core';
 import { useBibleClient } from './useBibleClient';
+import { createYVWrapper } from './test/utils';
 
 vi.mock('./useBibleClient');
 
 describe('useChapter', () => {
-  const mockAppKey = 'test-app-key';
   const mockGetChapter = vi.fn();
 
   const mockChapter: BibleChapter = {
@@ -18,15 +16,7 @@ describe('useChapter', () => {
     title: 'Matthew 1',
   };
 
-  const createWrapper = (contextValue: { appKey: string }) => {
-    return ({ children }: { children: ReactNode }) => (
-      <YouVersionContext.Provider value={contextValue}>{children}</YouVersionContext.Provider>
-    );
-  };
-
   beforeEach(() => {
-    vi.resetAllMocks();
-
     mockGetChapter.mockResolvedValue(mockChapter);
 
     const mockClient: Partial<BibleClient> = { getChapter: mockGetChapter };
@@ -35,10 +25,7 @@ describe('useChapter', () => {
 
   describe('fetching chapter', () => {
     it('should fetch chapter with versionId, book, chapter params', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useChapter(111, 'MAT', 1), { wrapper });
 
       expect(result.current.loading).toBe(true);
@@ -48,102 +35,66 @@ describe('useChapter', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetChapter).toHaveBeenCalledWith(111, 'MAT', 1);
-      expect(result.current.chapter).toEqual(mockChapter);
+      expect.soft(mockGetChapter).toHaveBeenCalledWith(111, 'MAT', 1);
+      expect.soft(result.current.chapter).toEqual(mockChapter);
     });
 
-    it('should refetch when versionId changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
-      const { result, rerender } = renderHook(({ versionId }) => useChapter(versionId, 'MAT', 1), {
-        wrapper,
-        initialProps: { versionId: 1 },
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetChapter).toHaveBeenCalledTimes(1);
-      expect(mockGetChapter).toHaveBeenLastCalledWith(1, 'MAT', 1);
-
-      act(() => {
-        rerender({ versionId: 111 });
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetChapter).toHaveBeenCalledTimes(2);
-      expect(mockGetChapter).toHaveBeenLastCalledWith(111, 'MAT', 1);
-    });
-
-    it('should refetch when book changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
-      const { result, rerender } = renderHook(({ book }) => useChapter(1, book, 1), {
-        wrapper,
-        initialProps: { book: 'MAT' },
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetChapter).toHaveBeenCalledTimes(1);
-      expect(mockGetChapter).toHaveBeenLastCalledWith(1, 'MAT', 1);
-
-      act(() => {
-        rerender({ book: 'GEN' });
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetChapter).toHaveBeenCalledTimes(2);
-      expect(mockGetChapter).toHaveBeenLastCalledWith(1, 'GEN', 1);
-    });
-
-    it('should refetch when chapter changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
-      const { result, rerender } = renderHook(({ chapter }) => useChapter(1, 'MAT', chapter), {
-        wrapper,
-        initialProps: { chapter: 1 },
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetChapter).toHaveBeenCalledTimes(1);
-      expect(mockGetChapter).toHaveBeenLastCalledWith(1, 'MAT', 1);
-
-      act(() => {
-        rerender({ chapter: 5 });
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetChapter).toHaveBeenCalledTimes(2);
-      expect(mockGetChapter).toHaveBeenLastCalledWith(1, 'MAT', 5);
-    });
+    it.each([
+      {
+        param: 'versionId',
+        HookFn: ({ val }: { val: number | string }) => useChapter(val as number, 'MAT', 1),
+        initial: { val: 1 },
+        updated: { val: 111 },
+        expectedInitial: [1, 'MAT', 1],
+        expectedUpdated: [111, 'MAT', 1],
+      },
+      {
+        param: 'book',
+        HookFn: ({ val }: { val: number | string }) => useChapter(1, val as string, 1),
+        initial: { val: 'MAT' },
+        updated: { val: 'GEN' },
+        expectedInitial: [1, 'MAT', 1],
+        expectedUpdated: [1, 'GEN', 1],
+      },
+      {
+        param: 'chapter',
+        HookFn: ({ val }: { val: number | string }) => useChapter(1, 'MAT', val as number),
+        initial: { val: 1 },
+        updated: { val: 5 },
+        expectedInitial: [1, 'MAT', 1],
+        expectedUpdated: [1, 'MAT', 5],
+      },
+    ])(
+      'should refetch when $param changes',
+      async ({ HookFn, initial, updated, expectedInitial, expectedUpdated }) => {
+        const wrapper = createYVWrapper();
+        const { result, rerender } = renderHook(HookFn, {
+          wrapper,
+          initialProps: initial,
+        });
+
+        await waitFor(() => {
+          expect(result.current.loading).toBe(false);
+        });
+
+        expect.soft(mockGetChapter).toHaveBeenCalledTimes(1);
+        expect.soft(mockGetChapter).toHaveBeenLastCalledWith(...expectedInitial);
+
+        act(() => {
+          rerender(updated);
+        });
+
+        await waitFor(() => {
+          expect(result.current.loading).toBe(false);
+        });
+
+        expect.soft(mockGetChapter).toHaveBeenCalledTimes(2);
+        expect.soft(mockGetChapter).toHaveBeenLastCalledWith(...expectedUpdated);
+      },
+    );
 
     it('should not fetch when enabled is false', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useChapter(1, 'MAT', 1, { enabled: false }), {
         wrapper,
       });
@@ -152,44 +103,38 @@ describe('useChapter', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetChapter).not.toHaveBeenCalled();
-      expect(result.current.chapter).toBe(null);
+      expect.soft(mockGetChapter).not.toHaveBeenCalled();
+      expect.soft(result.current.chapter).toBe(null);
     });
 
     it('should handle fetch errors', async () => {
+      const wrapper = createYVWrapper();
       const error = new Error('Failed to fetch chapter');
       mockGetChapter.mockRejectedValueOnce(error);
 
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
       const { result } = renderHook(() => useChapter(1, 'MAT', 1), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(result.current.error).toEqual(error);
-      expect(result.current.chapter).toBe(null);
+      expect.soft(result.current.error).toEqual(error);
+      expect.soft(result.current.chapter).toBe(null);
     });
 
     it('should clear error on successful refetch', async () => {
+      const wrapper = createYVWrapper();
       const error = new Error('Failed to fetch chapter');
       mockGetChapter.mockRejectedValueOnce(error).mockResolvedValueOnce(mockChapter);
 
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
       const { result } = renderHook(() => useChapter(1, 'MAT', 1), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(result.current.error).toEqual(error);
-      expect(result.current.chapter).toBe(null);
+      expect.soft(result.current.error).toEqual(error);
+      expect.soft(result.current.chapter).toBe(null);
 
       act(() => {
         result.current.refetch();
@@ -199,15 +144,12 @@ describe('useChapter', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(result.current.error).toBe(null);
-      expect(result.current.chapter).toEqual(mockChapter);
+      expect.soft(result.current.error).toBe(null);
+      expect.soft(result.current.chapter).toEqual(mockChapter);
     });
 
     it('should support manual refetch', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useChapter(1, 'MAT', 1), { wrapper });
 
       await waitFor(() => {

package/src/useChapterNavigation.ts

@@ -16,6 +16,9 @@ interface UseChapterNavigationResult {
 /**
  * Provides navigation functionality for chapters across book boundaries,
  * including intro chapter support.
+ *
+ * @deprecated This hook will be removed in the next major version.
+ * Use `getAdjacentChapter` from `@youversion/platform-core` directly instead.
  */
 export function useChapterNavigation(): UseChapterNavigationResult {
   const { currentChapter, currentVersion, currentBook, setChapter, setBook } = useReaderContext();