@youversion/platform-react-hooks 1.22.0 → 1.22.1

package/dist/index.cjs

@@ -0,0 +1,946 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/context/YouVersionAuthContext.tsx
+function useYouVersionAuthContext() {
+  const context = (0, import_react2.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;
+}
+var import_react2, YouVersionAuthContext;
+var init_YouVersionAuthContext = __esm({
+  "src/context/YouVersionAuthContext.tsx"() {
+    "use strict";
+    "use client";
+    import_react2 = require("react");
+    YouVersionAuthContext = (0, import_react2.createContext)(null);
+  }
+});
+
+// src/context/YouVersionAuthProvider.tsx
+var YouVersionAuthProvider_exports = {};
+__export(YouVersionAuthProvider_exports, {
+  default: () => YouVersionAuthProvider
+});
+function YouVersionAuthProvider({
+  config,
+  children
+}) {
+  const [userInfo, setUserInfo] = (0, import_react3.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react3.useState)(true);
+  const [error, setError] = (0, import_react3.useState)(null);
+  (0, import_react3.useEffect)(() => {
+    let mounted = true;
+    const initAuth = async () => {
+      import_platform_core.YouVersionPlatformConfiguration.appKey = config.appKey;
+      import_platform_core.YouVersionPlatformConfiguration.apiHost = config.apiHost ?? "api.youversion.com";
+      if (typeof window !== "undefined") {
+        const urlParams = new URLSearchParams(window.location.search);
+        const isOAuthCallback = urlParams.has("state") || urlParams.has("error");
+        if (isOAuthCallback) {
+          try {
+            const result = await import_platform_core.YouVersionAPIUsers.handleAuthCallback();
+            if (result && import_platform_core.YouVersionPlatformConfiguration.idToken) {
+              const info = import_platform_core.YouVersionAPIUsers.userInfo(import_platform_core.YouVersionPlatformConfiguration.idToken);
+              if (!mounted) return;
+              setUserInfo(info);
+            }
+          } catch (err) {
+            if (!mounted) return;
+            setError(err);
+          }
+        } else {
+          const refreshToken = import_platform_core.YouVersionPlatformConfiguration.refreshToken;
+          if (refreshToken) {
+            try {
+              await import_platform_core.YouVersionAPIUsers.refreshTokenIfNeeded();
+              const idToken = import_platform_core.YouVersionPlatformConfiguration.idToken;
+              if (idToken) {
+                const info = import_platform_core.YouVersionAPIUsers.userInfo(idToken);
+                if (!mounted) return;
+                setUserInfo(info);
+              } else {
+                if (!mounted) return;
+                setUserInfo(null);
+              }
+            } catch {
+              if (!mounted) return;
+              setUserInfo(null);
+            }
+          }
+        }
+      }
+      if (!mounted) return;
+      setIsLoading(false);
+    };
+    void initAuth();
+    return () => {
+      mounted = false;
+    };
+  }, []);
+  const value = {
+    userInfo,
+    setUserInfo,
+    isLoading,
+    error,
+    redirectUri: config.redirectUri
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(YouVersionAuthContext.Provider, { value, children });
+}
+var import_react3, import_platform_core, import_jsx_runtime;
+var init_YouVersionAuthProvider = __esm({
+  "src/context/YouVersionAuthProvider.tsx"() {
+    "use strict";
+    "use client";
+    import_react3 = require("react");
+    import_platform_core = require("@youversion/platform-core");
+    init_YouVersionAuthContext();
+    import_jsx_runtime = require("react/jsx-runtime");
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT: () => DEFAULT,
+  ReaderContext: () => ReaderContext,
+  ReaderProvider: () => ReaderProvider,
+  VerseSelectionContext: () => VerseSelectionContext,
+  VerseSelectionProvider: () => VerseSelectionProvider,
+  YouVersionContext: () => YouVersionContext,
+  YouVersionProvider: () => YouVersionProvider,
+  extractTextFromHtml: () => extractTextFromHtml,
+  extractVersesFromHTML: () => extractVersesFromHTML,
+  getDayOfYear: () => getDayOfYear,
+  getISOFromVersion: () => getISOFromVersion,
+  useBibleClient: () => useBibleClient,
+  useBook: () => useBook,
+  useBooks: () => useBooks,
+  useChapter: () => useChapter,
+  useChapterNavigation: () => useChapterNavigation,
+  useChapters: () => useChapters,
+  useDebounce: () => useDebounce,
+  useFilteredVersions: () => useFilteredVersions,
+  useHighlights: () => useHighlights,
+  useInitData: () => useInitData,
+  useLanguage: () => useLanguage,
+  useLanguages: () => useLanguages,
+  usePassage: () => usePassage,
+  useReaderContext: () => useReaderContext,
+  useTheme: () => useTheme,
+  useVerse: () => useVerse,
+  useVerseOfTheDay: () => useVerseOfTheDay,
+  useVerseSelection: () => useVerseSelection,
+  useVerses: () => useVerses,
+  useVersion: () => useVersion,
+  useVersions: () => useVersions,
+  useYVAuth: () => useYVAuth
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/useBibleClient.ts
+var import_react9 = require("react");
+
+// src/context/YouVersionContext.tsx
+var import_react = require("react");
+var YouVersionContext = (0, import_react.createContext)(null);
+
+// src/context/YouVersionProvider.tsx
+var import_react4 = require("react");
+var import_platform_core2 = require("@youversion/platform-core");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var AuthProvider = (0, import_react4.lazy)(() => Promise.resolve().then(() => (init_YouVersionAuthProvider(), YouVersionAuthProvider_exports)));
+function useResolvedTheme(theme) {
+  const [resolved, setResolved] = (0, import_react4.useState)(() => {
+    if (theme !== "system") return theme;
+    if (typeof window === "undefined") return "light";
+    return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  });
+  (0, import_react4.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);
+  (0, import_react4.useEffect)(() => {
+    import_platform_core2.YouVersionPlatformConfiguration.appKey = appKey;
+    import_platform_core2.YouVersionPlatformConfiguration.apiHost = apiHost;
+  }, [appKey, apiHost]);
+  if (includeAuth) {
+    const { authRedirectUrl } = props;
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      YouVersionContext.Provider,
+      {
+        value: {
+          appKey,
+          apiHost,
+          installationId: import_platform_core2.YouVersionPlatformConfiguration.installationId,
+          theme: resolvedTheme,
+          authEnabled: !!includeAuth
+        },
+        children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react4.Suspense, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AuthProvider, { config: { appKey, apiHost, redirectUri: authRedirectUrl }, children }) })
+      }
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    YouVersionContext.Provider,
+    {
+      value: {
+        appKey,
+        apiHost,
+        installationId: import_platform_core2.YouVersionPlatformConfiguration.installationId,
+        theme: resolvedTheme,
+        authEnabled: !!includeAuth
+      },
+      children
+    }
+  );
+}
+
+// src/context/ReaderContext.tsx
+var import_react5 = require("react");
+var ReaderContext = (0, import_react5.createContext)(null);
+function useReaderContext() {
+  const context = (0, import_react5.useContext)(ReaderContext);
+  if (!context) {
+    throw new Error("useReaderContext() must be used within a ReaderProvider");
+  }
+  return context;
+}
+
+// src/context/ReaderProvider.tsx
+var import_react6 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function ReaderProvider(props) {
+  const [currentVersion, setCurrentVersion] = (0, import_react6.useState)(props.currentVersion);
+  const [currentBook, setCurrentBook] = (0, import_react6.useState)(props.currentBook);
+  const [currentChapter, setCurrentChapter] = (0, import_react6.useState)(props.currentChapter);
+  const [currentVerse, setCurrentVerse] = (0, import_react6.useState)(props.currentVerse);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    ReaderContext.Provider,
+    {
+      value: {
+        currentVersion,
+        currentBook,
+        currentChapter,
+        currentVerse,
+        setVersion: setCurrentVersion,
+        setChapter: setCurrentChapter,
+        setBook: setCurrentBook,
+        setVerse: setCurrentVerse
+      },
+      children: props.children
+    }
+  );
+}
+
+// src/context/VerseSelectionProvider.tsx
+var import_react8 = require("react");
+
+// src/context/VerseSelectionContext.tsx
+var import_react7 = require("react");
+var VerseSelectionContext = (0, import_react7.createContext)(null);
+
+// src/context/VerseSelectionProvider.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function VerseSelectionProvider({ children }) {
+  const [selectedVerseUsfms, setSelectedVerseUsfms] = (0, import_react8.useState)(/* @__PURE__ */ new Set());
+  const toggleVerse = (0, import_react8.useCallback)((usfm) => {
+    setSelectedVerseUsfms((prev) => {
+      const newSet = new Set(prev);
+      if (newSet.has(usfm)) {
+        newSet.delete(usfm);
+      } else {
+        newSet.add(usfm);
+      }
+      return newSet;
+    });
+  }, []);
+  const isSelected = (0, import_react8.useCallback)(
+    (usfm) => {
+      return selectedVerseUsfms.has(usfm);
+    },
+    [selectedVerseUsfms]
+  );
+  const clearSelection = (0, import_react8.useCallback)(() => {
+    setSelectedVerseUsfms(/* @__PURE__ */ new Set());
+  }, []);
+  const value = {
+    selectedVerseUsfms,
+    toggleVerse,
+    isSelected,
+    clearSelection,
+    selectedCount: selectedVerseUsfms.size
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(VerseSelectionContext.Provider, { value, children });
+}
+
+// src/useBibleClient.ts
+var import_platform_core3 = require("@youversion/platform-core");
+function useBibleClient() {
+  const context = (0, import_react9.useContext)(YouVersionContext);
+  return (0, import_react9.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 import_platform_core3.BibleClient(
+      new import_platform_core3.ApiClient({
+        appKey: context.appKey,
+        apiHost: context.apiHost,
+        installationId: context.installationId
+      })
+    );
+  }, [context?.apiHost, context?.appKey, context?.installationId]);
+}
+
+// src/useApiData.ts
+var import_react10 = require("react");
+function useApiData(fetchFn, deps, options = {}) {
+  const { enabled = true } = options;
+  const [data, setData] = (0, import_react10.useState)(null);
+  const [loading, setLoading] = (0, import_react10.useState)(true);
+  const [error, setError] = (0, import_react10.useState)(null);
+  const fetchData = (0, import_react10.useCallback)(() => {
+    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 = (0, import_react10.useCallback)(() => {
+    fetchData();
+  }, [fetchData]);
+  (0, import_react10.useEffect)(() => {
+    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
+var import_react11 = require("react");
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = (0, import_react11.useState)(value);
+  (0, import_react11.useEffect)(() => {
+    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
+var import_react12 = require("react");
+
+// src/utility/version.ts
+function getISOFromVersion(version) {
+  return version?.language_tag || "unknown";
+}
+
+// src/useFilteredVersions.ts
+function useFilteredVersions(versions, searchTerm, selectedLanguage, recentVersions) {
+  return (0, import_react12.useMemo)(() => {
+    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
+var import_react13 = require("react");
+function useVerseSelection() {
+  const context = (0, import_react13.useContext)(VerseSelectionContext);
+  if (!context) {
+    throw new Error("useVerseSelection must be used within a VerseSelectionProvider");
+  }
+  return context;
+}
+
+// src/useChapterNavigation.ts
+var import_platform_core4 = require("@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 = (0, import_platform_core4.getAdjacentChapter)(booksData, bookId, chapterId, "next");
+  const prevResult = (0, import_platform_core4.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
+var import_platform_core5 = require("@youversion/platform-core");
+var DEFAULT = {
+  VERSION: import_platform_core5.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
+var import_react14 = require("react");
+var import_react15 = require("react");
+var import_platform_core6 = require("@youversion/platform-core");
+var import_platform_core7 = require("@youversion/platform-core");
+function useHighlights(options, apiOptions) {
+  const context = (0, import_react15.useContext)(YouVersionContext);
+  const highlightsClient = (0, import_react14.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 import_platform_core6.HighlightsClient(
+      new import_platform_core6.ApiClient({
+        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 = (0, import_react14.useCallback)(
+    async (data2) => {
+      const result = await highlightsClient.createHighlight(data2);
+      refetch();
+      return result;
+    },
+    [highlightsClient, refetch]
+  );
+  const deleteHighlight = (0, import_react14.useCallback)(
+    async (passageId, deleteOptions) => {
+      await highlightsClient.deleteHighlight(passageId, deleteOptions);
+      refetch();
+    },
+    [highlightsClient, refetch]
+  );
+  return {
+    highlights: data,
+    loading,
+    error,
+    refetch,
+    createHighlight,
+    deleteHighlight
+  };
+}
+
+// src/useLanguages.ts
+var import_platform_core9 = require("@youversion/platform-core");
+
+// src/useLanguageClient.ts
+var import_react16 = require("react");
+var import_platform_core8 = require("@youversion/platform-core");
+function useLanguagesClient() {
+  const context = (0, import_react16.useContext)(YouVersionContext);
+  return (0, import_react16.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 import_platform_core8.LanguagesClient(
+      new import_platform_core8.ApiClient({
+        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
+var import_platform_core10 = require("@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
+var import_react17 = require("react");
+function useTheme() {
+  const context = (0, import_react17.useContext)(YouVersionContext);
+  return context?.theme || "light";
+}
+
+// src/useYVAuth.ts
+var import_react18 = require("react");
+var import_platform_core11 = require("@youversion/platform-core");
+init_YouVersionAuthContext();
+function useYVAuth() {
+  const { userInfo, setUserInfo, isLoading, error, redirectUri } = useYouVersionAuthContext();
+  const isAuthenticated = !!userInfo;
+  const authTokens = (0, import_react18.useMemo)(() => {
+    if (typeof window !== "undefined") {
+      return {
+        accessToken: import_platform_core11.YouVersionPlatformConfiguration.accessToken,
+        idToken: import_platform_core11.YouVersionPlatformConfiguration.idToken
+      };
+    }
+    return { accessToken: null, idToken: null };
+  }, []);
+  const signIn = (0, import_react18.useCallback)(
+    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 import_platform_core11.YouVersionAPIUsers.signIn(url, params.scopes);
+      } else {
+        await import_platform_core11.YouVersionAPIUsers.signIn(url);
+      }
+    },
+    [redirectUri]
+  );
+  const processCallback = (0, import_react18.useCallback)(async () => {
+    const result = await import_platform_core11.YouVersionAPIUsers.handleAuthCallback();
+    return result;
+  }, []);
+  const auth = (0, import_react18.useMemo)(
+    () => ({
+      isAuthenticated,
+      isLoading,
+      accessToken: authTokens.accessToken,
+      idToken: authTokens.idToken,
+      result: null,
+      error
+    }),
+    [isAuthenticated, isLoading, authTokens.accessToken, authTokens.idToken, error]
+  );
+  const signOut = (0, import_react18.useCallback)(() => {
+    import_platform_core11.YouVersionPlatformConfiguration.clearAuthTokens();
+    setUserInfo(null);
+  }, []);
+  return {
+    auth,
+    signIn,
+    signOut,
+    processCallback,
+    userInfo,
+    redirectUri
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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
+});