@youversion/platform-react-hooks 1.21.0 → 1.22.1

package/dist/index.js

@@ -1,26 +1,788 @@
-export * from './useBook';
-export * from './useBooks';
-export * from './useChapter';
-export * from './useChapters';
-export * from './useVerse';
-export * from './useVerses';
-export * from './useVersion';
-export * from './utility/useDebounce';
-export * from './useVersions';
-export * from './useFilteredVersions';
-export * from './context';
-export * from './utility';
-export * from './useBibleClient';
-export * from './useVerseSelection';
-export * from './useChapterNavigation';
-export * from './useInitData';
-export * from './usePassage';
-export * from './useVOTD';
-export * from './useHighlights';
-export * from './useLanguages';
-export * from './useLanguage';
-export * from './useTheme';
-// Auth hooks
-export * from './useYVAuth';
-export * from './types/auth';
-//# sourceMappingURL=index.js.map
+import {
+  useYouVersionAuthContext
+} from "./chunk-ITHJF2FD.js";
+
+// src/useBibleClient.ts
+import { useContext as useContext2, useMemo } from "react";
+
+// src/context/YouVersionContext.tsx
+import { createContext } from "react";
+var YouVersionContext = createContext(null);
+
+// src/context/YouVersionProvider.tsx
+import { lazy, Suspense, useEffect, useState } from "react";
+import { YouVersionPlatformConfiguration } from "@youversion/platform-core";
+import { jsx } from "react/jsx-runtime";
+var AuthProvider = lazy(() => import("./YouVersionAuthProvider-VORD6KDZ.js"));
+function useResolvedTheme(theme) {
+  const [resolved, setResolved] = useState(() => {
+    if (theme !== "system") return theme;
+    if (typeof window === "undefined") return "light";
+    return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  });
+  useEffect(() => {
+    if (theme !== "system") {
+      setResolved(theme);
+      return;
+    }
+    if (typeof window === "undefined") return;
+    const mediaQueryList = window.matchMedia("(prefers-color-scheme: dark)");
+    setResolved(mediaQueryList.matches ? "dark" : "light");
+    const handler = (e) => {
+      setResolved(e.matches ? "dark" : "light");
+    };
+    mediaQueryList.addEventListener("change", handler);
+    return () => mediaQueryList.removeEventListener("change", handler);
+  }, [theme]);
+  return resolved;
+}
+function YouVersionProvider(props) {
+  const { appKey, apiHost = "api.youversion.com", includeAuth, theme = "light", children } = props;
+  const resolvedTheme = useResolvedTheme(theme);
+  useEffect(() => {
+    YouVersionPlatformConfiguration.appKey = appKey;
+    YouVersionPlatformConfiguration.apiHost = apiHost;
+  }, [appKey, apiHost]);
+  if (includeAuth) {
+    const { authRedirectUrl } = props;
+    return /* @__PURE__ */ jsx(
+      YouVersionContext.Provider,
+      {
+        value: {
+          appKey,
+          apiHost,
+          installationId: YouVersionPlatformConfiguration.installationId,
+          theme: resolvedTheme,
+          authEnabled: !!includeAuth
+        },
+        children: /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(AuthProvider, { config: { appKey, apiHost, redirectUri: authRedirectUrl }, children }) })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    YouVersionContext.Provider,
+    {
+      value: {
+        appKey,
+        apiHost,
+        installationId: YouVersionPlatformConfiguration.installationId,
+        theme: resolvedTheme,
+        authEnabled: !!includeAuth
+      },
+      children
+    }
+  );
+}
+
+// src/context/ReaderContext.tsx
+import { createContext as createContext2, useContext } from "react";
+var ReaderContext = createContext2(null);
+function useReaderContext() {
+  const context = useContext(ReaderContext);
+  if (!context) {
+    throw new Error("useReaderContext() must be used within a ReaderProvider");
+  }
+  return context;
+}
+
+// src/context/ReaderProvider.tsx
+import { useState as useState2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function ReaderProvider(props) {
+  const [currentVersion, setCurrentVersion] = useState2(props.currentVersion);
+  const [currentBook, setCurrentBook] = useState2(props.currentBook);
+  const [currentChapter, setCurrentChapter] = useState2(props.currentChapter);
+  const [currentVerse, setCurrentVerse] = useState2(props.currentVerse);
+  return /* @__PURE__ */ jsx2(
+    ReaderContext.Provider,
+    {
+      value: {
+        currentVersion,
+        currentBook,
+        currentChapter,
+        currentVerse,
+        setVersion: setCurrentVersion,
+        setChapter: setCurrentChapter,
+        setBook: setCurrentBook,
+        setVerse: setCurrentVerse
+      },
+      children: props.children
+    }
+  );
+}
+
+// src/context/VerseSelectionProvider.tsx
+import { useCallback, useState as useState3 } from "react";
+
+// src/context/VerseSelectionContext.tsx
+import { createContext as createContext3 } from "react";
+var VerseSelectionContext = createContext3(null);
+
+// src/context/VerseSelectionProvider.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function VerseSelectionProvider({ children }) {
+  const [selectedVerseUsfms, setSelectedVerseUsfms] = useState3(/* @__PURE__ */ new Set());
+  const toggleVerse = useCallback((usfm) => {
+    setSelectedVerseUsfms((prev) => {
+      const newSet = new Set(prev);
+      if (newSet.has(usfm)) {
+        newSet.delete(usfm);
+      } else {
+        newSet.add(usfm);
+      }
+      return newSet;
+    });
+  }, []);
+  const isSelected = useCallback(
+    (usfm) => {
+      return selectedVerseUsfms.has(usfm);
+    },
+    [selectedVerseUsfms]
+  );
+  const clearSelection = useCallback(() => {
+    setSelectedVerseUsfms(/* @__PURE__ */ new Set());
+  }, []);
+  const value = {
+    selectedVerseUsfms,
+    toggleVerse,
+    isSelected,
+    clearSelection,
+    selectedCount: selectedVerseUsfms.size
+  };
+  return /* @__PURE__ */ jsx3(VerseSelectionContext.Provider, { value, children });
+}
+
+// src/useBibleClient.ts
+import { BibleClient, ApiClient } from "@youversion/platform-core";
+function useBibleClient() {
+  const context = useContext2(YouVersionContext);
+  return useMemo(() => {
+    if (!context?.appKey) {
+      throw new Error(
+        "YouVersion context not found. Make sure your component is wrapped with YouVersionProvider and an API key is provided."
+      );
+    }
+    return new BibleClient(
+      new ApiClient({
+        appKey: context.appKey,
+        apiHost: context.apiHost,
+        installationId: context.installationId
+      })
+    );
+  }, [context?.apiHost, context?.appKey, context?.installationId]);
+}
+
+// src/useApiData.ts
+import { useState as useState4, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+function useApiData(fetchFn, deps, options = {}) {
+  const { enabled = true } = options;
+  const [data, setData] = useState4(null);
+  const [loading, setLoading] = useState4(true);
+  const [error, setError] = useState4(null);
+  const fetchData = useCallback2(() => {
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    let canceled = false;
+    setLoading(true);
+    setError(null);
+    fetchFn().then((result) => {
+      if (!canceled) {
+        setData(result);
+      }
+    }).catch((err) => {
+      if (!canceled) {
+        setError(err);
+      }
+    }).finally(() => {
+      if (!canceled) {
+        setLoading(false);
+      }
+    });
+    return () => {
+      canceled = true;
+    };
+  }, [fetchFn, enabled]);
+  const refetch = useCallback2(() => {
+    fetchData();
+  }, [fetchData]);
+  useEffect2(() => {
+    const cleanup = fetchData();
+    return cleanup;
+  }, deps);
+  return { data, loading, error, refetch };
+}
+
+// src/useBook.ts
+function useBook(versionId, book, options) {
+  const bibleClient = useBibleClient();
+  const { data, loading, error, refetch } = useApiData(
+    () => bibleClient.getBook(versionId, book),
+    [bibleClient, versionId, book],
+    {
+      enabled: options?.enabled !== false
+    }
+  );
+  return { book: data, loading, error, refetch };
+}
+
+// src/useBooks.ts
+function useBooks(versionId, options) {
+  const bibleClient = useBibleClient();
+  const {
+    data: books,
+    loading,
+    error,
+    refetch
+  } = useApiData(
+    () => bibleClient.getBooks(versionId),
+    [bibleClient, versionId],
+    {
+      enabled: options?.enabled !== false
+    }
+  );
+  return { books, loading, error, refetch };
+}
+
+// src/useChapter.ts
+function useChapter(versionId, book, chapter, options) {
+  const bibleClient = useBibleClient();
+  const {
+    data: chapterData,
+    loading,
+    error,
+    refetch
+  } = useApiData(
+    () => bibleClient.getChapter(versionId, book, chapter),
+    [bibleClient, versionId, book, chapter],
+    {
+      enabled: options?.enabled !== false
+    }
+  );
+  return { chapter: chapterData, loading, error, refetch };
+}
+
+// src/useChapters.ts
+function useChapters(versionId, book, options) {
+  const bibleClient = useBibleClient();
+  const isValidBook = Boolean(book) && book !== "undefined" && book !== "null";
+  const {
+    data: chapters,
+    loading,
+    error,
+    refetch
+  } = useApiData(
+    () => bibleClient.getChapters(versionId, book),
+    [bibleClient, versionId, book],
+    {
+      enabled: options?.enabled !== false && isValidBook
+    }
+  );
+  return { chapters, loading, error, refetch };
+}
+
+// src/useVerse.ts
+function useVerse(versionId, book, chapter, verse, options) {
+  const bibleClient = useBibleClient();
+  const {
+    data: verseData,
+    loading,
+    error,
+    refetch
+  } = useApiData(
+    () => bibleClient.getVerse(versionId, book, chapter, verse),
+    [bibleClient, versionId, book, chapter, verse],
+    {
+      enabled: options?.enabled !== false
+    }
+  );
+  return { verse: verseData, loading, error, refetch };
+}
+
+// src/useVerses.ts
+function useVerses(versionId, book, chapter, options) {
+  const bibleClient = useBibleClient();
+  const {
+    data: verses,
+    loading,
+    error,
+    refetch
+  } = useApiData(
+    () => bibleClient.getVerses(versionId, book, chapter),
+    [bibleClient, versionId, book, chapter],
+    {
+      enabled: options?.enabled !== false
+    }
+  );
+  return { verses, loading, error, refetch };
+}
+
+// src/useVersion.ts
+function useVersion(versionId, options) {
+  const bibleClient = useBibleClient();
+  const {
+    data: version,
+    loading,
+    error,
+    refetch
+  } = useApiData(() => bibleClient.getVersion(versionId), [bibleClient, versionId], {
+    enabled: options?.enabled !== false
+  });
+  return { version, loading, error, refetch };
+}
+
+// src/utility/useDebounce.ts
+import { useEffect as useEffect3, useState as useState5 } from "react";
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState5(value);
+  useEffect3(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => clearTimeout(handler);
+  }, [value, delay]);
+  return debouncedValue;
+}
+
+// src/useVersions.ts
+function useVersions(languageRanges = "en", licenseId, options) {
+  const bibleClient = useBibleClient();
+  const getVersionsOptions = options?.page_size !== void 0 || options?.page_token !== void 0 || options?.fields !== void 0 || options?.all_available !== void 0 ? {
+    page_size: options?.page_size,
+    page_token: options?.page_token,
+    fields: options?.fields,
+    all_available: options?.all_available
+  } : void 0;
+  const languageRangesKey = Array.isArray(languageRanges) ? languageRanges.join(",") : languageRanges;
+  const fieldsKey = options?.fields?.join(",");
+  const {
+    data: versions,
+    loading,
+    error,
+    refetch
+  } = useApiData(
+    () => bibleClient.getVersions(languageRanges, licenseId, getVersionsOptions),
+    [
+      bibleClient,
+      languageRangesKey,
+      licenseId,
+      options?.page_size,
+      options?.page_token,
+      fieldsKey,
+      options?.all_available
+    ],
+    {
+      enabled: options?.enabled !== false
+    }
+  );
+  return { versions, loading, error, refetch };
+}
+
+// src/useFilteredVersions.ts
+import { useMemo as useMemo2 } from "react";
+
+// src/utility/version.ts
+function getISOFromVersion(version) {
+  return version?.language_tag || "unknown";
+}
+
+// src/useFilteredVersions.ts
+function useFilteredVersions(versions, searchTerm, selectedLanguage, recentVersions) {
+  return useMemo2(() => {
+    let result = [...versions];
+    if (selectedLanguage && selectedLanguage !== "*") {
+      result = result.filter(
+        (version) => getISOFromVersion(version).toLowerCase() === selectedLanguage.toLowerCase()
+      );
+    }
+    if (searchTerm.trim()) {
+      const searchLower = searchTerm.toLowerCase();
+      result = result.filter(
+        (version) => version.title.toLowerCase().includes(searchLower) || version.abbreviation.toLowerCase().includes(searchLower) || getISOFromVersion(version).toLowerCase().includes(searchLower)
+      );
+    }
+    if (recentVersions) {
+      const recentVersionIds = recentVersions.map((version) => version.id);
+      result = result.filter((version) => !recentVersionIds.includes(version.id));
+    }
+    return result;
+  }, [versions, recentVersions, searchTerm, selectedLanguage]);
+}
+
+// src/utility/extractTextFromHTML.ts
+function extractTextFromHtml(html) {
+  if (!html) return "";
+  const container = document.createElement("div");
+  container.innerHTML = html;
+  const contentText = Array.from(container.querySelectorAll("span.content")).map((el) => (el.textContent || "").trim()).filter(Boolean).join(" ");
+  return contentText.replace(/\s+/g, " ").trim();
+}
+
+// src/utility/extractVersesFromHTML.ts
+function extractVersesFromHTML(html) {
+  if (!html) return [];
+  const results = [];
+  const pattern = /<span class="yv-v" v="(\d+)"><\/span><span class="yv-vlbl">\d+<\/span>/g;
+  let execResult;
+  const indices = [];
+  while ((execResult = pattern.exec(html)) !== null) {
+    const verseNumString = execResult[1];
+    indices.push({ verse: parseInt(verseNumString, 10), index: execResult.index });
+  }
+  for (let i = 0; i < indices.length; i++) {
+    const current = indices[i];
+    const next = indices[i + 1];
+    const start = current.index;
+    const end = next ? next.index : html.length;
+    const slice = html.slice(start, end).trim();
+    results.push({ verse: current.verse, html: slice });
+  }
+  return results;
+}
+
+// src/utility/getDayOfYear.ts
+function getDayOfYear(date) {
+  const dayOfYear = Math.floor(
+    (date.getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 864e5
+  );
+  return dayOfYear;
+}
+
+// src/useVerseSelection.ts
+import { useContext as useContext3 } from "react";
+function useVerseSelection() {
+  const context = useContext3(VerseSelectionContext);
+  if (!context) {
+    throw new Error("useVerseSelection must be used within a VerseSelectionProvider");
+  }
+  return context;
+}
+
+// src/useChapterNavigation.ts
+import { getAdjacentChapter } from "@youversion/platform-core";
+function useChapterNavigation() {
+  const { currentChapter, currentVersion, currentBook, setChapter, setBook } = useReaderContext();
+  const { books, loading: booksLoading } = useBooks(currentVersion?.id ?? 0, {
+    enabled: Boolean(currentVersion?.id)
+  });
+  const booksData = books?.data ?? [];
+  const bookId = currentBook?.id ?? "";
+  const chapterId = currentChapter?.id ?? "";
+  const nextResult = getAdjacentChapter(booksData, bookId, chapterId, "next");
+  const prevResult = getAdjacentChapter(booksData, bookId, chapterId, "previous");
+  const canNavigateNext = !booksLoading && nextResult !== null;
+  const canNavigatePrevious = !booksLoading && prevResult !== null;
+  const currentChapterIndex = currentBook?.chapters?.findIndex((c) => c.id === currentChapter?.id) ?? -1;
+  const navigate = (result) => {
+    if (!result || !booksData.length) return;
+    const targetBook = booksData.find((b) => b.id === result.bookId);
+    if (!targetBook) return;
+    const targetChapter = targetBook.chapters?.find((c) => c.id === result.chapterId) ?? (targetBook.intro?.id === result.chapterId ? {
+      id: targetBook.intro.id,
+      passage_id: targetBook.intro.passage_id,
+      title: targetBook.intro.title
+    } : void 0);
+    if (!targetChapter) return;
+    if (targetBook.id !== currentBook?.id) {
+      setBook(targetBook);
+    }
+    setChapter(targetChapter);
+  };
+  const navigateToNext = () => navigate(nextResult);
+  const navigateToPrevious = () => navigate(prevResult);
+  return {
+    canNavigatePrevious,
+    canNavigateNext,
+    navigateToPrevious,
+    navigateToNext,
+    currentChapterIndex,
+    isLoading: booksLoading
+  };
+}
+
+// src/useInitData.ts
+import { DEFAULT_LICENSE_FREE_BIBLE_VERSION } from "@youversion/platform-core";
+var DEFAULT = {
+  VERSION: DEFAULT_LICENSE_FREE_BIBLE_VERSION,
+  BOOK: "GEN",
+  CHAPTER: 1
+};
+function useInitData({ version, book, chapter } = {
+  version: DEFAULT.VERSION,
+  book: DEFAULT.BOOK,
+  chapter: DEFAULT.CHAPTER
+}) {
+  const {
+    version: versionData,
+    loading: versionLoading,
+    error: versionError
+  } = useVersion(version);
+  const { book: bookData, loading: bookLoading, error: bookError } = useBook(version, book);
+  const {
+    chapter: chapterData,
+    loading: chapterLoading,
+    error: chapterError
+  } = useChapter(version, book, chapter);
+  const allDataAvailable = versionData && bookData && chapterData;
+  return {
+    loading: versionLoading || bookLoading || chapterLoading,
+    error: [versionError, bookError, chapterError].filter(Boolean).join(" "),
+    data: allDataAvailable ? { version: versionData, book: bookData, chapter: chapterData } : null
+  };
+}
+
+// src/usePassage.ts
+function usePassage({
+  versionId,
+  usfm,
+  format = "html",
+  include_headings = false,
+  include_notes = false,
+  options
+}) {
+  const bibleClient = useBibleClient();
+  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 };
+}
+
+// src/useVOTD.ts
+function useVerseOfTheDay(day, options) {
+  const bibleClient = useBibleClient();
+  const { data, loading, error, refetch } = useApiData(
+    () => bibleClient.getVOTD(day),
+    [bibleClient, day],
+    { enabled: options?.enabled !== false }
+  );
+  return { data, loading, error, refetch };
+}
+
+// src/useHighlights.ts
+import { useMemo as useMemo3, useCallback as useCallback3 } from "react";
+import { useContext as useContext4 } from "react";
+import { HighlightsClient, ApiClient as ApiClient2 } from "@youversion/platform-core";
+import "@youversion/platform-core";
+function useHighlights(options, apiOptions) {
+  const context = useContext4(YouVersionContext);
+  const highlightsClient = useMemo3(() => {
+    if (!context?.appKey) {
+      throw new Error(
+        "YouVersion context not found. Make sure your component is wrapped with YouVersionProvider and an API key is provided."
+      );
+    }
+    return new HighlightsClient(
+      new ApiClient2({
+        appKey: context.appKey,
+        apiHost: context.apiHost,
+        installationId: context.installationId
+      })
+    );
+  }, [context?.apiHost, context?.appKey, context?.installationId]);
+  const { data, loading, error, refetch } = useApiData(
+    () => highlightsClient.getHighlights(options),
+    [highlightsClient, options?.version_id, options?.passage_id],
+    {
+      enabled: apiOptions?.enabled !== false
+    }
+  );
+  const createHighlight = useCallback3(
+    async (data2) => {
+      const result = await highlightsClient.createHighlight(data2);
+      refetch();
+      return result;
+    },
+    [highlightsClient, refetch]
+  );
+  const deleteHighlight = useCallback3(
+    async (passageId, deleteOptions) => {
+      await highlightsClient.deleteHighlight(passageId, deleteOptions);
+      refetch();
+    },
+    [highlightsClient, refetch]
+  );
+  return {
+    highlights: data,
+    loading,
+    error,
+    refetch,
+    createHighlight,
+    deleteHighlight
+  };
+}
+
+// src/useLanguages.ts
+import "@youversion/platform-core";
+
+// src/useLanguageClient.ts
+import { useContext as useContext5, useMemo as useMemo4 } from "react";
+import { ApiClient as ApiClient3, LanguagesClient } from "@youversion/platform-core";
+function useLanguagesClient() {
+  const context = useContext5(YouVersionContext);
+  return useMemo4(() => {
+    if (!context?.appKey) {
+      throw new Error(
+        "YouVersion context not found. Make sure your component is wrapped with YouVersionProvider and an API key is provided."
+      );
+    }
+    return new LanguagesClient(
+      new ApiClient3({
+        appKey: context.appKey,
+        apiHost: context.apiHost,
+        installationId: context.installationId
+      })
+    );
+  }, [context?.apiHost, context?.appKey, context?.installationId]);
+}
+
+// src/useLanguages.ts
+function useLanguages(options = {}, apiOptions) {
+  const languagesClient = useLanguagesClient();
+  const { data, loading, error, refetch } = useApiData(
+    () => languagesClient.getLanguages(options),
+    [
+      languagesClient,
+      JSON.stringify(options.fields),
+      options?.country,
+      options?.page_size,
+      options?.page_token
+    ],
+    {
+      enabled: apiOptions?.enabled !== false
+    }
+  );
+  return {
+    languages: data,
+    loading,
+    error,
+    refetch
+  };
+}
+
+// src/useLanguage.ts
+import "@youversion/platform-core";
+function useLanguage(languageId, apiOptions) {
+  const languagesClient = useLanguagesClient();
+  const { data, loading, error, refetch } = useApiData(
+    () => languagesClient.getLanguage(languageId),
+    [languagesClient, languageId],
+    {
+      enabled: apiOptions?.enabled !== false
+    }
+  );
+  return {
+    language: data,
+    loading,
+    error,
+    refetch
+  };
+}
+
+// src/useTheme.ts
+import { useContext as useContext6 } from "react";
+function useTheme() {
+  const context = useContext6(YouVersionContext);
+  return context?.theme || "light";
+}
+
+// src/useYVAuth.ts
+import { useMemo as useMemo5, useCallback as useCallback4 } from "react";
+import {
+  YouVersionAPIUsers,
+  YouVersionPlatformConfiguration as YouVersionPlatformConfiguration2
+} from "@youversion/platform-core";
+function useYVAuth() {
+  const { userInfo, setUserInfo, isLoading, error, redirectUri } = useYouVersionAuthContext();
+  const isAuthenticated = !!userInfo;
+  const authTokens = useMemo5(() => {
+    if (typeof window !== "undefined") {
+      return {
+        accessToken: YouVersionPlatformConfiguration2.accessToken,
+        idToken: YouVersionPlatformConfiguration2.idToken
+      };
+    }
+    return { accessToken: null, idToken: null };
+  }, []);
+  const signIn = useCallback4(
+    async (params) => {
+      const url = params?.redirectUrl ?? redirectUri;
+      if (!url) {
+        throw new Error(
+          "redirectUrl is required. Provide it via signIn params or configure redirectUri in the auth provider."
+        );
+      }
+      if (params?.scopes) {
+        await YouVersionAPIUsers.signIn(url, params.scopes);
+      } else {
+        await YouVersionAPIUsers.signIn(url);
+      }
+    },
+    [redirectUri]
+  );
+  const processCallback = useCallback4(async () => {
+    const result = await YouVersionAPIUsers.handleAuthCallback();
+    return result;
+  }, []);
+  const auth = useMemo5(
+    () => ({
+      isAuthenticated,
+      isLoading,
+      accessToken: authTokens.accessToken,
+      idToken: authTokens.idToken,
+      result: null,
+      error
+    }),
+    [isAuthenticated, isLoading, authTokens.accessToken, authTokens.idToken, error]
+  );
+  const signOut = useCallback4(() => {
+    YouVersionPlatformConfiguration2.clearAuthTokens();
+    setUserInfo(null);
+  }, []);
+  return {
+    auth,
+    signIn,
+    signOut,
+    processCallback,
+    userInfo,
+    redirectUri
+  };
+}
+export {
+  DEFAULT,
+  ReaderContext,
+  ReaderProvider,
+  VerseSelectionContext,
+  VerseSelectionProvider,
+  YouVersionContext,
+  YouVersionProvider,
+  extractTextFromHtml,
+  extractVersesFromHTML,
+  getDayOfYear,
+  getISOFromVersion,
+  useBibleClient,
+  useBook,
+  useBooks,
+  useChapter,
+  useChapterNavigation,
+  useChapters,
+  useDebounce,
+  useFilteredVersions,
+  useHighlights,
+  useInitData,
+  useLanguage,
+  useLanguages,
+  usePassage,
+  useReaderContext,
+  useTheme,
+  useVerse,
+  useVerseOfTheDay,
+  useVerseSelection,
+  useVerses,
+  useVersion,
+  useVersions,
+  useYVAuth
+};