@youversion/platform-react-hooks 0.6.0 → 0.7.0

package/dist/usePassage.js

@@ -1,10 +1,10 @@
-"use client";
-import { useBibleClient } from "./useBibleClient";
-import { useApiData } from "./useApiData";
-export function usePassage({ versionId, usfm, format = "html", include_headings = false, include_notes = false, options, }) {
+'use client';
+import { useBibleClient } from './useBibleClient';
+import { useApiData } from './useApiData';
+export function usePassage({ versionId, usfm, format = 'html', include_headings = false, include_notes = false, options, }) {
     const bibleClient = useBibleClient();
     // Don't attempt to fetch if usfm is invalid
-    const isValidUsfm = Boolean(usfm) && usfm !== "undefined" && usfm !== "null";
+    const isValidUsfm = Boolean(usfm) && usfm !== 'undefined' && usfm !== 'null';
     const { data, loading, error, refetch } = useApiData(() => bibleClient.getPassage(versionId, usfm, format, include_headings, include_notes), [bibleClient, versionId, usfm, format, include_headings, include_notes], { enabled: options?.enabled !== false && isValidUsfm });
     return { passage: data, loading, error, refetch };
 }

package/dist/usePassage.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePassage.js","sourceRoot":"","sources":["../src/usePassage.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,UAAU,EAA0B,MAAM,cAAc,CAAC;AAYlE,MAAM,UAAU,UAAU,CAAC,EACzB,SAAS,EACT,IAAI,EACJ,MAAM,GAAG,MAAM,EACf,gBAAgB,GAAG,KAAK,EACxB,aAAa,GAAG,KAAK,EACrB,OAAO,GACS;IAMhB,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IAErC,4CAA4C;IAC5C,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,WAAW,IAAI,IAAI,KAAK,MAAM,CAAC;IAE7E,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,UAAU,CAClD,GAAG,EAAE,CACH,WAAW,CAAC,UAAU,CACpB,SAAS,EACT,IAAI,EACJ,MAAM,EACN,gBAAgB,EAChB,aAAa,CACd,EACH,CAAC,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,aAAa,CAAC,EACvE,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,KAAK,IAAI,WAAW,EAAE,CACvD,CAAC;IAEF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AACpD,CAAC"}
+{"version":3,"file":"usePassage.js","sourceRoot":"","sources":["../src/usePassage.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,UAAU,EAA0B,MAAM,cAAc,CAAC;AAYlE,MAAM,UAAU,UAAU,CAAC,EACzB,SAAS,EACT,IAAI,EACJ,MAAM,GAAG,MAAM,EACf,gBAAgB,GAAG,KAAK,EACxB,aAAa,GAAG,KAAK,EACrB,OAAO,GACS;IAMhB,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IAErC,4CAA4C;IAC5C,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,WAAW,IAAI,IAAI,KAAK,MAAM,CAAC;IAE7E,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,UAAU,CAClD,GAAG,EAAE,CAAC,WAAW,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,aAAa,CAAC,EACtF,CAAC,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,aAAa,CAAC,EACvE,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,KAAK,IAAI,WAAW,EAAE,CACvD,CAAC;IAEF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AACpD,CAAC"}

package/dist/useYVAuth.d.ts

@@ -0,0 +1,97 @@
+import { type AuthenticationState, type SignInWithYouVersionPermissionValues, type SignInWithYouVersionResult, type YouVersionUserInfo } from '@youversion/platform-core';
+export interface UseYVAuthReturn {
+    auth: AuthenticationState;
+    signIn: (params: {
+        redirectUrl: string;
+        permissions?: SignInWithYouVersionPermissionValues[];
+    }) => Promise<void>;
+    signOut: () => void;
+    processCallback: () => Promise<SignInWithYouVersionResult | null>;
+    userInfo: YouVersionUserInfo | null;
+}
+/**
+ * Comprehensive YouVersion authentication hook using vanilla React.
+ *
+ * Provides complete auth functionality without external dependencies.
+ * Sign-in redirects to YouVersion, callback processing caches user info.
+ *
+ * @returns Complete auth state and functionality
+ *
+ * @example
+ * ```tsx
+ * // Sign-in page
+ * import { useYVAuth, SignInWithYouVersionPermission } from '@youversion/platform-react-hooks';
+ *
+ * function SignInPage() {
+ *   const { auth, signIn } = useYVAuth();
+ *
+ *   const handleSignIn = async () => {
+ *     try {
+ *       await signIn({
+ *         redirectUrl: 'https://myapp.com/callback',
+ *         permissions: [SignInWithYouVersionPermission.bibles]
+ *       });
+ *     } catch (error) {
+ *       console.error('Sign in failed:', error);
+ *     }
+ *   };
+ *
+ *   if (auth.isAuthenticated) {
+ *     return <div>Already signed in!</div>;
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleSignIn} disabled={auth.isLoading}>
+ *       {auth.isLoading ? 'Signing in...' : 'Sign In'}
+ *     </button>
+ *   );
+ * }
+ *
+ * // Callback page
+ * function CallbackPage() {
+ *   const { processCallback } = useYVAuth();
+ *   const [isProcessing, setIsProcessing] = useState(true);
+ *
+ *   useEffect(() => {
+ *     processCallback()
+ *       .then(result => {
+ *         if (result) {
+ *           console.log('Auth success:', result.name);
+ *           // User info is now cached
+ *           // Redirect to app
+ *         }
+ *       })
+ *       .catch(error => {
+ *         console.error('Auth failed:', error);
+ *       })
+ *       .finally(() => {
+ *         setIsProcessing(false);
+ *       });
+ *   }, [processCallback]);
+ *
+ *   return (
+ *     <div>
+ *       {isProcessing ? 'Processing authentication...' : 'Authentication complete'}
+ *     </div>
+ *   );
+ * }
+ *
+ * // App with cached user info
+ * function App() {
+ *   const { auth, userInfo, signOut } = useYVAuth();
+ *
+ *   if (!auth.isAuthenticated) {
+ *     return <SignInPage />;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Welcome, {userInfo?.name || 'User'}!</p>
+ *       <button onClick={signOut}>Sign Out</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useYVAuth(): UseYVAuthReturn;
+//# sourceMappingURL=useYVAuth.d.ts.map

package/dist/useYVAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useYVAuth.d.ts","sourceRoot":"","sources":["../src/useYVAuth.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,oCAAoC,EACzC,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,EACxB,MAAM,2BAA2B,CAAC;AAGnC,MAAM,WAAW,eAAe;IAE9B,IAAI,EAAE,mBAAmB,CAAC;IAG1B,MAAM,EAAE,CAAC,MAAM,EAAE;QACf,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,CAAC,EAAE,oCAAoC,EAAE,CAAC;KACtD,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpB,OAAO,EAAE,MAAM,IAAI,CAAC;IAGpB,eAAe,EAAE,MAAM,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CAAC;IAGlE,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,wBAAgB,SAAS,IAAI,eAAe,CAiE3C"}

package/dist/useYVAuth.js

@@ -0,0 +1,135 @@
+import { useMemo, useCallback } from 'react';
+import { YouVersionAPIUsers, YouVersionPlatformConfiguration, } from '@youversion/platform-core';
+import { useYouVersionAuthContext } from './context/YouVersionAuthContext';
+/**
+ * Comprehensive YouVersion authentication hook using vanilla React.
+ *
+ * Provides complete auth functionality without external dependencies.
+ * Sign-in redirects to YouVersion, callback processing caches user info.
+ *
+ * @returns Complete auth state and functionality
+ *
+ * @example
+ * ```tsx
+ * // Sign-in page
+ * import { useYVAuth, SignInWithYouVersionPermission } from '@youversion/platform-react-hooks';
+ *
+ * function SignInPage() {
+ *   const { auth, signIn } = useYVAuth();
+ *
+ *   const handleSignIn = async () => {
+ *     try {
+ *       await signIn({
+ *         redirectUrl: 'https://myapp.com/callback',
+ *         permissions: [SignInWithYouVersionPermission.bibles]
+ *       });
+ *     } catch (error) {
+ *       console.error('Sign in failed:', error);
+ *     }
+ *   };
+ *
+ *   if (auth.isAuthenticated) {
+ *     return <div>Already signed in!</div>;
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleSignIn} disabled={auth.isLoading}>
+ *       {auth.isLoading ? 'Signing in...' : 'Sign In'}
+ *     </button>
+ *   );
+ * }
+ *
+ * // Callback page
+ * function CallbackPage() {
+ *   const { processCallback } = useYVAuth();
+ *   const [isProcessing, setIsProcessing] = useState(true);
+ *
+ *   useEffect(() => {
+ *     processCallback()
+ *       .then(result => {
+ *         if (result) {
+ *           console.log('Auth success:', result.name);
+ *           // User info is now cached
+ *           // Redirect to app
+ *         }
+ *       })
+ *       .catch(error => {
+ *         console.error('Auth failed:', error);
+ *       })
+ *       .finally(() => {
+ *         setIsProcessing(false);
+ *       });
+ *   }, [processCallback]);
+ *
+ *   return (
+ *     <div>
+ *       {isProcessing ? 'Processing authentication...' : 'Authentication complete'}
+ *     </div>
+ *   );
+ * }
+ *
+ * // App with cached user info
+ * function App() {
+ *   const { auth, userInfo, signOut } = useYVAuth();
+ *
+ *   if (!auth.isAuthenticated) {
+ *     return <SignInPage />;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Welcome, {userInfo?.name || 'User'}!</p>
+ *       <button onClick={signOut}>Sign Out</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useYVAuth() {
+    // Get auth state from provider context
+    const { userInfo, setUserInfo, isLoading, error } = useYouVersionAuthContext();
+    // Derive authentication state
+    const isAuthenticated = !!userInfo;
+    // Get current tokens for actions
+    const authTokens = useMemo(() => {
+        if (typeof window !== 'undefined') {
+            return {
+                accessToken: YouVersionPlatformConfiguration.accessToken,
+                idToken: YouVersionPlatformConfiguration.idToken,
+            };
+        }
+        return { accessToken: null, idToken: null };
+    }, []);
+    // Sign in function
+    const signIn = useCallback(async ({ redirectUrl, permissions = [], }) => {
+        await YouVersionAPIUsers.signIn(new Set(permissions), redirectUrl);
+        // Note: This will redirect, so code after this won't execute
+    }, []);
+    // Process callback function
+    const processCallback = useCallback(async () => {
+        const result = await YouVersionAPIUsers.handleAuthCallback();
+        return result;
+    }, []);
+    // Derive auth state
+    const auth = useMemo(() => ({
+        isAuthenticated,
+        isLoading,
+        accessToken: authTokens.accessToken,
+        idToken: authTokens.idToken,
+        result: null,
+        error,
+    }), [isAuthenticated, isLoading, authTokens.accessToken, authTokens.idToken, error]);
+    // Sign out function
+    const signOut = useCallback(() => {
+        YouVersionPlatformConfiguration.clearAuthTokens();
+        setUserInfo(null);
+    }, []);
+    return {
+        auth,
+        signIn,
+        signOut,
+        processCallback,
+        userInfo,
+    };
+}
+//# sourceMappingURL=useYVAuth.js.map

package/dist/useYVAuth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useYVAuth.js","sourceRoot":"","sources":["../src/useYVAuth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EACL,kBAAkB,EAClB,+BAA+B,GAKhC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAoB3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,MAAM,UAAU,SAAS;IACvB,uCAAuC;IACvC,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,wBAAwB,EAAE,CAAC;IAE/E,8BAA8B;IAC9B,MAAM,eAAe,GAAG,CAAC,CAAC,QAAQ,CAAC;IAEnC,iCAAiC;IACjC,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,EAAE;QAC9B,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;YAClC,OAAO;gBACL,WAAW,EAAE,+BAA+B,CAAC,WAAW;gBACxD,OAAO,EAAE,+BAA+B,CAAC,OAAO;aACjD,CAAC;QACJ,CAAC;QACD,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAC9C,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,mBAAmB;IACnB,MAAM,MAAM,GAAG,WAAW,CACxB,KAAK,EAAE,EACL,WAAW,EACX,WAAW,GAAG,EAAE,GAIjB,EAAE,EAAE;QACH,MAAM,kBAAkB,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC;QACnE,6DAA6D;IAC/D,CAAC,EACD,EAAE,CACH,CAAC;IAEF,4BAA4B;IAC5B,MAAM,eAAe,GAAG,WAAW,CAAC,KAAK,IAAgD,EAAE;QACzF,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,kBAAkB,EAAE,CAAC;QAC7D,OAAO,MAAM,CAAC;IAChB,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,oBAAoB;IACpB,MAAM,IAAI,GAAwB,OAAO,CACvC,GAAG,EAAE,CAAC,CAAC;QACL,eAAe;QACf,SAAS;QACT,WAAW,EAAE,UAAU,CAAC,WAAW;QACnC,OAAO,EAAE,UAAU,CAAC,OAAO;QAC3B,MAAM,EAAE,IAAI;QACZ,KAAK;KACN,CAAC,EACF,CAAC,eAAe,EAAE,SAAS,EAAE,UAAU,CAAC,WAAW,EAAE,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAChF,CAAC;IAEF,oBAAoB;IACpB,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE;QAC/B,+BAA+B,CAAC,eAAe,EAAE,CAAC;QAClD,WAAW,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,OAAO;QACL,IAAI;QACJ,MAAM;QACN,OAAO;QACP,eAAe;QACf,QAAQ;KACT,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youversion/platform-react-hooks",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "publishConfig": {
     "access": "public",
@@ -22,7 +22,7 @@
     }
   },
   "dependencies": {
-    "@youversion/platform-core": "0.6.0"
+    "@youversion/platform-core": "0.7.0"
   },
   "peerDependencies": {
     "react": ">=19.1.0 <20.0.0"
@@ -36,14 +36,14 @@
     "eslint": "9.38.0",
     "typescript": "5.9.3",
     "vitest": "4.0.4",
-    "@internal/eslint-config": "0.0.0",
-    "@internal/tsconfig": "0.0.0"
+    "@internal/tsconfig": "0.0.0",
+    "@internal/eslint-config": "0.0.0"
   },
   "scripts": {
     "dev": "tsc --watch",
     "build": "tsc -p tsconfig.build.json",
     "lint": "eslint . --max-warnings 0",
-    "check-types": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage"

package/src/__tests__/mocks/auth.ts

@@ -0,0 +1,48 @@
+import { vi } from 'vitest';
+import { SignInWithYouVersionResult, YouVersionUserInfo } from '@youversion/platform-core';
+
+/**
+ * Creates a mock user info object for testing
+ * @param overrides Optional properties to override the default values
+ */
+export const createMockUserInfo = (overrides: Record<string, any> = {}): YouVersionUserInfo => {
+  const mockUserInfo = new YouVersionUserInfo({
+    id: '123',
+    name: 'John Doe',
+    email: 'john@example.com',
+    avatar_url: 'https://example.com/avatar.jpg?w={width}&h={height}',
+    ...overrides,
+  });
+
+  // Mock the getAvatarUrl method for testing
+  vi.spyOn(mockUserInfo, 'getAvatarUrl').mockImplementation((width = 200, height = 200) => {
+    try {
+      return new URL(`https://example.com/avatar.jpg?w=${width}&h=${height}`);
+    } catch {
+      return null;
+    }
+  });
+
+  return mockUserInfo;
+};
+
+/**
+ * Creates a mock auth result for testing
+ * @param overrides Optional properties to override the default values
+ */
+export const createMockAuthResult = (
+  overrides: Record<string, unknown> = {},
+): SignInWithYouVersionResult => {
+  const mockUserInfo = createMockUserInfo();
+  return new SignInWithYouVersionResult({
+    ...mockUserInfo,
+    accessToken: 'access-token',
+    idToken: 'id-token',
+    refreshToken: 'refresh-token',
+    expiresIn: 3600,
+    permissions: ['bibles', 'highlights'],
+    yvpUserId: 'test-yvp-user-id',
+    profilePicture: 'https://example.com/profile.jpg',
+    ...overrides,
+  });
+};

package/src/__tests__/utils/test-utils.tsx

@@ -0,0 +1,43 @@
+import React from 'react';
+import { YouVersionProvider } from '../../context/YouVersionProvider';
+import { useYouVersionAuthContext } from '../../context/YouVersionAuthContext';
+
+/**
+ * Creates a test wrapper component with YouVersionAuthProvider
+ * @param config Optional auth configuration
+ */
+export const createAuthProviderWrapper = (): React.ComponentType<{ children: React.ReactNode }> => {
+  return ({ children }: { children: React.ReactNode }) => (
+    <YouVersionProvider
+      appKey="test-app-key"
+      apiHost="test-api.example.com"
+      includeAuth={true}
+      authRedirectUrl="http://test.example.com"
+    >
+      {children}
+    </YouVersionProvider>
+  );
+};
+
+/**
+ * Test component to access auth context for testing
+ */
+export function TestAuthChild({ onRender }: { onRender?: (data: any) => void }): React.JSX.Element {
+  const context = useYouVersionAuthContext();
+
+  React.useEffect(() => {
+    if (onRender) {
+      onRender(context);
+    }
+  }, [context, onRender]);
+
+  return (
+    <div>
+      <div data-testid="user-info">
+        {context.userInfo ? JSON.stringify(context.userInfo) : 'null'}
+      </div>
+      <div data-testid="is-loading">{context.isLoading.toString()}</div>
+      <div data-testid="error">{context.error ? context.error.message : 'null'}</div>
+    </div>
+  );
+}

package/src/context/YouVersionAuthContext.test.tsx

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { type ReactNode } from 'react';
+import { YouVersionAuthContext, useYouVersionAuthContext } from './YouVersionAuthContext';
+import type { AuthContextValue } from '../types/auth';
+
+const mockContextValue: AuthContextValue = {
+  userInfo: {
+    userId: '123',
+    name: 'John Doe',
+    email: 'john@example.com',
+    avatarUrlFormat: 'https://example.com/avatar.jpg',
+    getAvatarUrl: () => new URL('https://example.com/avatar.jpg'),
+    avatarUrl: new URL('https://example.com/avatar.jpg'),
+  },
+  setUserInfo: () => {
+    // Mock function for testing
+  },
+  isLoading: false,
+  error: null,
+};
+
+function TestWrapper({
+  children,
+  value = mockContextValue,
+}: {
+  children: ReactNode;
+  value?: AuthContextValue | null;
+}) {
+  return <YouVersionAuthContext.Provider value={value}>{children}</YouVersionAuthContext.Provider>;
+}
+
+describe('YouVersionAuthContext', () => {
+  describe('useYouVersionAuthContext', () => {
+    it('should return context value when used within provider', () => {
+      const { result } = renderHook(() => useYouVersionAuthContext(), {
+        wrapper: ({ children }) => <TestWrapper>{children}</TestWrapper>,
+      });
+
+      expect(result.current).toEqual(mockContextValue);
+      expect(result.current.userInfo).toEqual(mockContextValue.userInfo);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBe(null);
+      expect(typeof result.current.setUserInfo).toBe('function');
+    });
+
+    it('should throw error when used outside provider', () => {
+      expect(() => {
+        renderHook(() => useYouVersionAuthContext());
+      }).toThrow(
+        'useYouVersionAuthContext must be used within an auth provider. ' +
+          'Make sure your app is wrapped with <YouVersionAuthProvider> from @youversion/platform-react-hooks ' +
+          'or create your own provider using YouVersionAuthContext from @youversion/platform-react-hooks.',
+      );
+    });
+
+    it('should throw error when context value is null', () => {
+      expect(() => {
+        renderHook(() => useYouVersionAuthContext(), {
+          wrapper: ({ children }) => <TestWrapper value={null}>{children}</TestWrapper>,
+        });
+      }).toThrow(
+        'useYouVersionAuthContext must be used within an auth provider. ' +
+          'Make sure your app is wrapped with <YouVersionAuthProvider> from @youversion/platform-react-hooks ' +
+          'or create your own provider using YouVersionAuthContext from @youversion/platform-react-hooks.',
+      );
+    });
+
+    it('should work with different context values', () => {
+      const customContextValue: AuthContextValue = {
+        userInfo: null,
+        setUserInfo: () => {
+          // Mock function for testing
+        },
+        isLoading: true,
+        error: new Error('Test error'),
+      };
+
+      const { result } = renderHook(() => useYouVersionAuthContext(), {
+        wrapper: ({ children }) => <TestWrapper value={customContextValue}>{children}</TestWrapper>,
+      });
+
+      expect(result.current.userInfo).toBe(null);
+      expect(result.current.isLoading).toBe(true);
+      expect(result.current.error?.message).toBe('Test error');
+    });
+  });
+});

package/src/context/YouVersionAuthContext.tsx

@@ -0,0 +1,20 @@
+'use client';
+
+import { createContext, useContext } from 'react';
+import type { AuthContextValue } from '../types/auth';
+
+export const YouVersionAuthContext = createContext<AuthContextValue | null>(null);
+
+export function useYouVersionAuthContext(): AuthContextValue {
+  const context = useContext(YouVersionAuthContext);
+
+  if (!context) {
+    throw new Error(
+      'useYouVersionAuthContext must be used within an auth provider. ' +
+        'Make sure your app is wrapped with <YouVersionAuthProvider> from @youversion/platform-react-hooks ' +
+        'or create your own provider using YouVersionAuthContext from @youversion/platform-react-hooks.',
+    );
+  }
+
+  return context;
+}