@fanapps/react-native 0.2.0

package/dist/index.mjs

@@ -0,0 +1,770 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/provider.tsx
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { useEffect, useMemo, useRef } from "react";
+
+// src/auth/errors.ts
+var FanappsAuthError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "FanappsAuthError";
+    this.code = code;
+  }
+};
+function peerLoadFailed(pkg, cause) {
+  const reason = cause instanceof Error ? cause.message : String(cause);
+  return new FanappsAuthError(
+    `@fanapps/react-native could not load ${pkg}: ${reason}. If the package is installed, Metro may be failing to resolve it from the SDK's location. See the README "Symlinked installs" section for a metro.config.js fix.`,
+    "peer/load-failed"
+  );
+}
+function peerUnexpectedShape(pkg, details) {
+  return new FanappsAuthError(
+    `@fanapps/react-native loaded ${pkg} but its shape was unexpected: ${details}. This usually indicates a bundler/interop mismatch or a duplicate copy of the package.`,
+    "peer/unexpected-shape"
+  );
+}
+
+// src/auth/firebaseApp.ts
+var cachedAuth = null;
+function firebaseAuth() {
+  if (cachedAuth) {
+    return cachedAuth;
+  }
+  let mod;
+  try {
+    mod = __require("@react-native-firebase/auth");
+  } catch (e) {
+    throw peerLoadFailed("@react-native-firebase/auth", e);
+  }
+  const factory = resolveFactory(mod);
+  if (!factory) {
+    throw peerUnexpectedShape(
+      "@react-native-firebase/auth",
+      `expected a factory function, got ${describeShape(mod)}`
+    );
+  }
+  cachedAuth = factory();
+  return cachedAuth;
+}
+function resolveFactory(mod) {
+  if (typeof mod === "function") {
+    return mod;
+  }
+  if (mod && typeof mod === "object" && "default" in mod) {
+    const def = mod.default;
+    if (typeof def === "function") {
+      return def;
+    }
+  }
+  return null;
+}
+function describeShape(mod) {
+  if (mod === null) return "null";
+  if (typeof mod !== "object") return typeof mod;
+  const keys = Object.keys(mod).slice(0, 5);
+  return `object with keys [${keys.join(", ")}]`;
+}
+
+// src/auth/authStore.ts
+function mapUser(fb) {
+  if (!fb) return null;
+  return {
+    uid: fb.uid,
+    email: fb.email,
+    displayName: fb.displayName,
+    photoURL: fb.photoURL,
+    phoneNumber: fb.phoneNumber,
+    isAnonymous: fb.isAnonymous,
+    providerId: fb.providerId ?? null
+  };
+}
+var AuthStore = class {
+  constructor() {
+    this.snapshot = {
+      user: null,
+      firebaseUser: null,
+      status: "loading"
+    };
+    this.listeners = /* @__PURE__ */ new Set();
+    this.unsubscribe = null;
+  }
+  start() {
+    if (this.unsubscribe) return;
+    this.unsubscribe = firebaseAuth().onAuthStateChanged((fb) => {
+      this.snapshot = {
+        user: mapUser(fb),
+        firebaseUser: fb,
+        status: fb ? "signed-in" : "signed-out"
+      };
+      this.emit();
+    });
+  }
+  stop() {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  async getCurrentIdToken() {
+    const user = firebaseAuth().currentUser;
+    if (!user) return null;
+    return user.getIdToken();
+  }
+  emit() {
+    for (const l of this.listeners) l(this.snapshot);
+  }
+};
+
+// src/errors.ts
+var FanappsError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.name = "FanappsError";
+    this.status = status;
+    this.body = body;
+  }
+};
+
+// src/client.ts
+var FanappsClient = class {
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.project = options.project;
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.getIdToken = options.getIdToken;
+  }
+  get(path, params, signal) {
+    return this.request("GET", path, { params, signal });
+  }
+  post(path, body, signal) {
+    return this.request("POST", path, { body, signal });
+  }
+  patch(path, body, signal) {
+    return this.request("PATCH", path, { body, signal });
+  }
+  delete(path, signal) {
+    return this.request("DELETE", path, { signal });
+  }
+  async createPushTarget(input) {
+    const response = await this.post(
+      "/api/account/targets/push",
+      input
+    );
+    return response.data;
+  }
+  async updatePushTarget(targetId, identifier) {
+    const response = await this.patch(
+      `/api/account/targets/push/${encodeURIComponent(targetId)}`,
+      { identifier }
+    );
+    return response.data;
+  }
+  async deletePushTarget(targetId) {
+    await this.delete(`/api/account/targets/push/${encodeURIComponent(targetId)}`);
+  }
+  async request(method, path, opts) {
+    const url = this.buildUrl(path, opts.params);
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "X-Tenant": this.project,
+      Accept: "application/json"
+    };
+    if (this.getIdToken) {
+      const idToken = await this.getIdToken();
+      if (idToken) {
+        headers["X-Firebase-Token"] = idToken;
+      }
+    }
+    const init = { method, headers, signal: opts.signal };
+    if (opts.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(opts.body);
+    }
+    const response = await fetch(url, init);
+    const raw = await response.text();
+    const payload = raw.length > 0 ? safeJson(raw) : null;
+    if (!response.ok) {
+      const message = (payload && typeof payload === "object" && "message" in payload ? String(payload.message) : null) ?? `Fanapps request failed with status ${response.status}`;
+      throw new FanappsError(message, response.status, payload);
+    }
+    return payload;
+  }
+  buildUrl(path, params) {
+    const base = path.startsWith("/") ? `${this.baseUrl}${path}` : `${this.baseUrl}/${path}`;
+    if (!params) return base;
+    const query = serializeParams(params);
+    return query.length > 0 ? `${base}?${query}` : base;
+  }
+};
+function serializeParams(params) {
+  const parts = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item === void 0 || item === null) continue;
+        parts.push(`${encodeURIComponent(key)}[]=${encodeURIComponent(String(item))}`);
+      }
+      continue;
+    }
+    parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  }
+  return parts.join("&");
+}
+function safeJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+// src/context.ts
+import { createContext, useContext } from "react";
+var FanappsContext = createContext(null);
+function useFanapps() {
+  const ctx = useContext(FanappsContext);
+  if (!ctx) {
+    throw new Error(
+      "@fanapps/react-native: useFanapps must be used inside <FanappsProvider>."
+    );
+  }
+  return ctx;
+}
+
+// src/push/storage.ts
+var memoryFallbackWarned = false;
+function resolveStorage(explicit) {
+  if (explicit) return explicit;
+  try {
+    const mod = __require("@react-native-async-storage/async-storage");
+    return mod.default;
+  } catch {
+    if (!memoryFallbackWarned && typeof __DEV__ !== "undefined" && __DEV__) {
+      console.warn(
+        "[@fanapps/react-native] No storage adapter provided and @react-native-async-storage/async-storage not installed. Push target IDs will be lost on app restart."
+      );
+      memoryFallbackWarned = true;
+    }
+    return createMemoryStorage();
+  }
+}
+function createMemoryStorage() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    async getItem(key) {
+      return store.get(key) ?? null;
+    },
+    async setItem(key, value) {
+      store.set(key, value);
+    },
+    async removeItem(key) {
+      store.delete(key);
+    }
+  };
+}
+
+// src/provider.tsx
+import { jsx } from "react/jsx-runtime";
+var DEFAULT_BASE_URL = "https://fanapps.app";
+function FanappsProvider({
+  apiKey,
+  project,
+  locale,
+  baseUrl = DEFAULT_BASE_URL,
+  queryClient,
+  storage,
+  children
+}) {
+  const authStoreRef = useRef(null);
+  if (!authStoreRef.current) {
+    authStoreRef.current = new AuthStore();
+  }
+  const authStore = authStoreRef.current;
+  useEffect(() => {
+    authStore.start();
+    return () => authStore.stop();
+  }, [authStore]);
+  const resolvedStorage = useMemo(() => resolveStorage(storage), [storage]);
+  const client = useMemo(
+    () => new FanappsClient({
+      apiKey,
+      project,
+      baseUrl,
+      getIdToken: () => authStore.getCurrentIdToken()
+    }),
+    [apiKey, project, baseUrl, authStore]
+  );
+  const resolvedQueryClient = useMemo(
+    () => queryClient ?? new QueryClient(),
+    [queryClient]
+  );
+  const value = useMemo(
+    () => ({ client, authStore, storage: resolvedStorage, locale }),
+    [client, authStore, resolvedStorage, locale]
+  );
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: resolvedQueryClient, children: /* @__PURE__ */ jsx(FanappsContext.Provider, { value, children }) });
+}
+
+// src/hooks/useFanappsClient.ts
+function useFanappsClient() {
+  return useFanapps().client;
+}
+
+// src/hooks/useAuth.ts
+import { useSyncExternalStore, useCallback } from "react";
+
+// src/auth/providers/google.ts
+async function signInWithGoogle() {
+  let mod;
+  try {
+    mod = __require("@react-native-google-signin/google-signin");
+  } catch (e) {
+    throw peerLoadFailed("@react-native-google-signin/google-signin", e);
+  }
+  let authMod;
+  try {
+    authMod = __require("@react-native-firebase/auth");
+  } catch (e) {
+    throw peerLoadFailed("@react-native-firebase/auth", e);
+  }
+  await mod.GoogleSignin.hasPlayServices({ showPlayServicesUpdateDialog: true });
+  const result = await mod.GoogleSignin.signIn();
+  const idToken = "data" in result ? result.data?.idToken ?? null : result.idToken;
+  if (!idToken) {
+    throw new Error("Google sign-in returned no ID token.");
+  }
+  const credential = authMod.GoogleAuthProvider.credential(idToken);
+  return firebaseAuth().signInWithCredential(
+    credential
+  );
+}
+
+// src/auth/providers/apple.ts
+import { Platform } from "react-native";
+async function signInWithApple() {
+  if (Platform.OS !== "ios") {
+    throw new FanappsAuthError(
+      "Apple sign-in is only supported on iOS in v1. Use web OAuth on Android.",
+      "auth/platform-not-supported"
+    );
+  }
+  let mod;
+  try {
+    mod = __require("@invertase/react-native-apple-authentication");
+  } catch (e) {
+    throw peerLoadFailed("@invertase/react-native-apple-authentication", e);
+  }
+  let authMod;
+  try {
+    authMod = __require("@react-native-firebase/auth");
+  } catch (e) {
+    throw peerLoadFailed("@react-native-firebase/auth", e);
+  }
+  if (!mod.appleAuth.isSupported) {
+    throw new FanappsAuthError("Apple sign-in not supported on this device.", "auth/not-supported");
+  }
+  const result = await mod.appleAuth.performRequest({
+    requestedOperation: mod.appleAuth.Operation.LOGIN,
+    requestedScopes: [mod.appleAuth.Scope.EMAIL, mod.appleAuth.Scope.FULL_NAME]
+  });
+  if (!result.identityToken) {
+    throw new FanappsAuthError("Apple did not return an identity token.", "auth/no-token");
+  }
+  const credential = authMod.AppleAuthProvider.credential(
+    result.identityToken,
+    result.nonce ?? void 0
+  );
+  return firebaseAuth().signInWithCredential(
+    credential
+  );
+}
+
+// src/hooks/useAuth.ts
+function useAuth() {
+  const { authStore } = useFanapps();
+  const snapshot = useSyncExternalStore(
+    (listener) => authStore.subscribe(listener),
+    () => authStore.getSnapshot(),
+    () => authStore.getSnapshot()
+  );
+  const signInWithEmail = useCallback(async (email, password) => {
+    const cred = await firebaseAuth().signInWithEmailAndPassword(email, password);
+    return authStore.getSnapshot().user ?? mapMinimal(cred.user);
+  }, [authStore]);
+  const signUpWithEmail = useCallback(async (email, password) => {
+    const cred = await firebaseAuth().createUserWithEmailAndPassword(email, password);
+    return authStore.getSnapshot().user ?? mapMinimal(cred.user);
+  }, [authStore]);
+  const sendPasswordResetEmail = useCallback(async (email) => {
+    await firebaseAuth().sendPasswordResetEmail(email);
+  }, []);
+  const sendEmailVerification = useCallback(async () => {
+    const current = firebaseAuth().currentUser;
+    if (!current) throw new Error("No signed-in user to verify.");
+    await current.sendEmailVerification();
+  }, []);
+  const signInWithGoogle2 = useCallback(async () => {
+    const cred = await signInWithGoogle();
+    return authStore.getSnapshot().user ?? mapMinimal(cred.user);
+  }, [authStore]);
+  const signInWithApple2 = useCallback(async () => {
+    const cred = await signInWithApple();
+    return authStore.getSnapshot().user ?? mapMinimal(cred.user);
+  }, [authStore]);
+  const signOut = useCallback(async () => {
+    await firebaseAuth().signOut();
+  }, []);
+  return {
+    user: snapshot.user,
+    status: snapshot.status,
+    signInWithEmail,
+    signUpWithEmail,
+    sendPasswordResetEmail,
+    sendEmailVerification,
+    signInWithGoogle: signInWithGoogle2,
+    signInWithApple: signInWithApple2,
+    signOut
+  };
+}
+function mapMinimal(fb) {
+  return {
+    uid: fb.uid,
+    email: fb.email,
+    displayName: fb.displayName,
+    photoURL: fb.photoURL,
+    phoneNumber: fb.phoneNumber,
+    isAnonymous: fb.isAnonymous,
+    providerId: fb.providerId ?? null
+  };
+}
+
+// src/hooks/useEntries.ts
+import { useQuery } from "@tanstack/react-query";
+function useEntries(filters = {}, options = {}) {
+  const { client, locale: providerLocale } = useFanapps();
+  const locale = options.locale ?? providerLocale;
+  return useQuery({
+    queryKey: ["fanapps", "entries", { locale, ...filters }],
+    queryFn: ({ signal }) => client.get("/api/entries", { ...filters, locale }, signal),
+    enabled: options.enabled ?? true
+  });
+}
+
+// src/hooks/useEntry.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+function useEntry(id, options = {}) {
+  const { client, locale: providerLocale } = useFanapps();
+  const locale = options.locale ?? providerLocale;
+  return useQuery2({
+    queryKey: ["fanapps", "entry", id, { locale }],
+    queryFn: async ({ signal }) => {
+      const response = await client.get(
+        `/api/entries/${id}`,
+        { locale },
+        signal
+      );
+      return response.data;
+    },
+    enabled: (options.enabled ?? true) && id != null && id !== ""
+  });
+}
+
+// src/hooks/useArticles.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+function useArticles(filters = {}, options = {}) {
+  const { client, locale: providerLocale } = useFanapps();
+  const locale = options.locale ?? providerLocale;
+  return useQuery3({
+    queryKey: ["fanapps", "articles", { locale, ...filters }],
+    queryFn: ({ signal }) => client.get("/api/articles", { ...filters, locale }, signal),
+    enabled: options.enabled ?? true
+  });
+}
+
+// src/hooks/useArticle.ts
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+function useArticle(id, options = {}) {
+  const { client, locale: providerLocale } = useFanapps();
+  const locale = options.locale ?? providerLocale;
+  return useQuery4({
+    queryKey: ["fanapps", "article", id, { locale }],
+    queryFn: async ({ signal }) => {
+      const response = await client.get(
+        `/api/articles/${id}`,
+        { locale },
+        signal
+      );
+      return response.data;
+    },
+    enabled: (options.enabled ?? true) && id != null && id !== ""
+  });
+}
+
+// src/hooks/useRegisterDevice.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useState } from "react";
+import { Platform as Platform2 } from "react-native";
+
+// src/push/messaging.ts
+var cached = null;
+function firebaseMessaging() {
+  if (cached) return cached;
+  let mod;
+  try {
+    mod = __require("@react-native-firebase/messaging");
+  } catch (e) {
+    throw peerLoadFailed("@react-native-firebase/messaging", e);
+  }
+  const factory = resolveFactory2(mod);
+  if (!factory) {
+    throw peerUnexpectedShape(
+      "@react-native-firebase/messaging",
+      `expected a factory function, got ${describeShape2(mod)}`
+    );
+  }
+  cached = factory();
+  return cached;
+}
+function resolveFactory2(mod) {
+  if (typeof mod === "function") {
+    return mod;
+  }
+  if (mod && typeof mod === "object" && "default" in mod) {
+    const def = mod.default;
+    if (typeof def === "function") {
+      return def;
+    }
+  }
+  return null;
+}
+function describeShape2(mod) {
+  if (mod === null) return "null";
+  if (typeof mod !== "object") return typeof mod;
+  const keys = Object.keys(mod).slice(0, 5);
+  return `object with keys [${keys.join(", ")}]`;
+}
+
+// src/push/targetIdStore.ts
+var KEY = "fanapps.pushTargetId";
+var TargetIdStore = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  get() {
+    return this.storage.getItem(KEY);
+  }
+  async set(id) {
+    await this.storage.setItem(KEY, id);
+  }
+  async clear() {
+    await this.storage.removeItem(KEY);
+  }
+};
+function generateTargetId() {
+  const bytes = new Uint8Array(16);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/hooks/useRegisterDevice.ts
+function useRegisterDevice() {
+  const { client, storage } = useFanapps();
+  const [targetId, setTargetId] = useState(null);
+  const [token, setToken] = useState(null);
+  const [target, setTarget] = useState(null);
+  const [isRegistering, setIsRegistering] = useState(false);
+  const [error, setError] = useState(null);
+  const targetStoreRef = useRef2(null);
+  if (!targetStoreRef.current) {
+    targetStoreRef.current = new TargetIdStore(storage);
+  }
+  const targetStore = targetStoreRef.current;
+  const tokenRefreshUnsubRef = useRef2(null);
+  useEffect2(() => {
+    return () => {
+      tokenRefreshUnsubRef.current?.();
+      tokenRefreshUnsubRef.current = null;
+    };
+  }, []);
+  const register = useCallback2(async () => {
+    setIsRegistering(true);
+    setError(null);
+    try {
+      const messaging = firebaseMessaging();
+      await messaging.requestPermission();
+      const fcmToken = await messaging.getToken();
+      setToken(fcmToken);
+      const existingId = await targetStore.get();
+      let result;
+      if (existingId) {
+        try {
+          result = await client.updatePushTarget(existingId, fcmToken);
+        } catch {
+          result = await client.createPushTarget({
+            targetId: existingId,
+            identifier: fcmToken,
+            osName: Platform2.OS === "ios" ? "iOS" : "Android"
+          });
+        }
+      } else {
+        const newId = generateTargetId();
+        result = await client.createPushTarget({
+          targetId: newId,
+          identifier: fcmToken,
+          osName: Platform2.OS === "ios" ? "iOS" : "Android"
+        });
+        await targetStore.set(result.id);
+      }
+      setTargetId(result.id);
+      setTarget(result);
+      if (!tokenRefreshUnsubRef.current) {
+        tokenRefreshUnsubRef.current = messaging.onTokenRefresh(async (newToken) => {
+          try {
+            const id = await targetStore.get();
+            if (!id) return;
+            const updated = await client.updatePushTarget(id, newToken);
+            setToken(newToken);
+            setTarget(updated);
+          } catch (e) {
+            setError(e instanceof Error ? e : new Error(String(e)));
+          }
+        });
+      }
+      return result;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      setError(err);
+      throw err;
+    } finally {
+      setIsRegistering(false);
+    }
+  }, [client, targetStore]);
+  const unregister = useCallback2(async () => {
+    const id = await targetStore.get();
+    if (id) {
+      try {
+        await client.deletePushTarget(id);
+      } catch {
+      }
+      await targetStore.clear();
+    }
+    tokenRefreshUnsubRef.current?.();
+    tokenRefreshUnsubRef.current = null;
+    setTargetId(null);
+    setToken(null);
+    setTarget(null);
+  }, [client, targetStore]);
+  return {
+    targetId,
+    token,
+    target,
+    isRegistering,
+    error,
+    register,
+    unregister
+  };
+}
+
+// src/hooks/useTrivias.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+function useTrivias(options = {}) {
+  const { client, locale: providerLocale } = useFanapps();
+  const locale = options.locale ?? providerLocale;
+  return useQuery5({
+    queryKey: ["fanapps", "trivias", { locale }],
+    queryFn: async ({ signal }) => {
+      const response = await client.get(
+        "/api/trivias",
+        { locale },
+        signal
+      );
+      return response.data;
+    },
+    enabled: options.enabled ?? true
+  });
+}
+
+// src/hooks/useTrivia.ts
+import { useQuery as useQuery6 } from "@tanstack/react-query";
+function useTrivia(id, options = {}) {
+  const { client, locale: providerLocale } = useFanapps();
+  const locale = options.locale ?? providerLocale;
+  return useQuery6({
+    queryKey: ["fanapps", "trivia", id, { locale }],
+    queryFn: async ({ signal }) => {
+      const response = await client.get(
+        `/api/trivias/${id}`,
+        { locale },
+        signal
+      );
+      return response.data;
+    },
+    enabled: (options.enabled ?? true) && id != null && id !== ""
+  });
+}
+
+// src/hooks/useSubmitTriviaResponse.ts
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+function useSubmitTriviaResponse() {
+  const { client } = useFanapps();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ triviaId, answerId }) => client.post(`/api/trivias/${triviaId}/respond`, {
+      answer_id: answerId
+    }),
+    onSuccess: (_result, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: ["fanapps", "trivia", variables.triviaId]
+      });
+      queryClient.invalidateQueries({ queryKey: ["fanapps", "trivias"] });
+    }
+  });
+}
+
+// src/hooks/useTopicSubscription.ts
+import { useCallback as useCallback3 } from "react";
+function useTopicSubscription() {
+  const subscribe = useCallback3(async (topic) => {
+    await firebaseMessaging().subscribeToTopic(topic);
+  }, []);
+  const unsubscribe = useCallback3(async (topic) => {
+    await firebaseMessaging().unsubscribeFromTopic(topic);
+  }, []);
+  return { subscribe, unsubscribe };
+}
+export {
+  FanappsAuthError,
+  FanappsClient,
+  FanappsError,
+  FanappsProvider,
+  useArticle,
+  useArticles,
+  useAuth,
+  useEntries,
+  useEntry,
+  useFanappsClient,
+  useRegisterDevice,
+  useSubmitTriviaResponse,
+  useTopicSubscription,
+  useTrivia,
+  useTrivias
+};
+//# sourceMappingURL=index.mjs.map