@marcwelti/mw-core 0.2.0

package/dist/index.js

@@ -0,0 +1,922 @@
+'use strict';
+
+var app$1 = require('firebase/app');
+var auth$1 = require('firebase/auth');
+var firestore = require('firebase/firestore');
+var storage$1 = require('firebase/storage');
+var analytics = require('firebase/analytics');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/firebase/config.ts
+function getFirebaseConfig() {
+  const config = {
+    apiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY || "",
+    authDomain: process.env.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN || "",
+    projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID || "",
+    storageBucket: process.env.NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET || "",
+    messagingSenderId: process.env.NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID || "",
+    appId: process.env.NEXT_PUBLIC_FIREBASE_APP_ID || "",
+    measurementId: process.env.NEXT_PUBLIC_FIREBASE_MEASUREMENT_ID
+  };
+  const requiredFields = [
+    "apiKey",
+    "authDomain",
+    "projectId",
+    "storageBucket",
+    "messagingSenderId",
+    "appId"
+  ];
+  const missingFields = requiredFields.filter((field) => !config[field]);
+  if (missingFields.length > 0) {
+    console.warn(
+      `[mw-core] Missing Firebase config fields: ${missingFields.join(", ")}. Make sure to set NEXT_PUBLIC_FIREBASE_* environment variables.`
+    );
+  }
+  return config;
+}
+function initializeFirebase(config) {
+  if (app$1.getApps().length > 0) {
+    return app$1.getApp();
+  }
+  const firebaseConfig = config || getFirebaseConfig();
+  return app$1.initializeApp(firebaseConfig);
+}
+var _app = null;
+var _auth = null;
+var _db = null;
+var _storage = null;
+function getFirebaseApp() {
+  if (!_app) {
+    _app = initializeFirebase();
+  }
+  return _app;
+}
+function getFirebaseAuth() {
+  if (!_auth) {
+    _auth = auth$1.getAuth(getFirebaseApp());
+  }
+  return _auth;
+}
+function getFirebaseFirestore() {
+  if (!_db) {
+    _db = firestore.getFirestore(getFirebaseApp());
+  }
+  return _db;
+}
+function getFirebaseStorage() {
+  if (!_storage) {
+    _storage = storage$1.getStorage(getFirebaseApp());
+  }
+  return _storage;
+}
+var app = typeof window !== "undefined" ? getFirebaseApp() : null;
+var auth = typeof window !== "undefined" ? getFirebaseAuth() : null;
+var db = typeof window !== "undefined" ? getFirebaseFirestore() : null;
+var storage = typeof window !== "undefined" ? getFirebaseStorage() : null;
+async function signInWithEmail(email, password) {
+  const auth2 = getFirebaseAuth();
+  return auth$1.signInWithEmailAndPassword(auth2, email, password);
+}
+async function signUpWithEmail(email, password, displayName) {
+  const auth2 = getFirebaseAuth();
+  const credential = await auth$1.createUserWithEmailAndPassword(auth2, email, password);
+  if (displayName && credential.user) {
+    await auth$1.updateProfile(credential.user, { displayName });
+  }
+  return credential;
+}
+async function signOut() {
+  const auth2 = getFirebaseAuth();
+  return auth$1.signOut(auth2);
+}
+async function resetPassword(email) {
+  const auth2 = getFirebaseAuth();
+  return auth$1.sendPasswordResetEmail(auth2, email);
+}
+async function sendVerificationEmail(user) {
+  return auth$1.sendEmailVerification(user);
+}
+async function updateUserProfile(user, profile) {
+  return auth$1.updateProfile(user, profile);
+}
+async function signInWithGoogle() {
+  const auth2 = getFirebaseAuth();
+  const provider = new auth$1.GoogleAuthProvider();
+  provider.addScope("email");
+  provider.addScope("profile");
+  return auth$1.signInWithPopup(auth2, provider);
+}
+async function signInWithGoogleRedirect() {
+  const auth2 = getFirebaseAuth();
+  const provider = new auth$1.GoogleAuthProvider();
+  provider.addScope("email");
+  provider.addScope("profile");
+  return auth$1.signInWithRedirect(auth2, provider);
+}
+async function getGoogleRedirectResult() {
+  const auth2 = getFirebaseAuth();
+  return auth$1.getRedirectResult(auth2);
+}
+function subscribeToAuthState(callback) {
+  const auth2 = getFirebaseAuth();
+  return auth$1.onAuthStateChanged(auth2, callback);
+}
+function getCurrentUser() {
+  const auth2 = getFirebaseAuth();
+  return auth2.currentUser;
+}
+function waitForAuthState() {
+  return new Promise((resolve) => {
+    const auth2 = getFirebaseAuth();
+    const unsubscribe = auth$1.onAuthStateChanged(auth2, (user) => {
+      unsubscribe();
+      resolve(user);
+    });
+  });
+}
+function getDocRef(collectionPath, documentId) {
+  const db2 = getFirebaseFirestore();
+  return firestore.doc(db2, collectionPath, documentId);
+}
+function getCollectionRef(collectionPath) {
+  const db2 = getFirebaseFirestore();
+  return firestore.collection(db2, collectionPath);
+}
+async function getDocument(collectionPath, documentId) {
+  const docRef = getDocRef(collectionPath, documentId);
+  const docSnap = await firestore.getDoc(docRef);
+  if (docSnap.exists()) {
+    return { id: docSnap.id, ...docSnap.data() };
+  }
+  return null;
+}
+async function getCollection(collectionPath, constraints = []) {
+  const collectionRef = getCollectionRef(collectionPath);
+  const q = firestore.query(collectionRef, ...constraints);
+  const querySnapshot = await firestore.getDocs(q);
+  return querySnapshot.docs.map((doc2) => ({
+    id: doc2.id,
+    ...doc2.data()
+  }));
+}
+async function addDocument(collectionPath, data) {
+  const collectionRef = getCollectionRef(collectionPath);
+  const docRef = await firestore.addDoc(collectionRef, {
+    ...data,
+    createdAt: firestore.serverTimestamp(),
+    updatedAt: firestore.serverTimestamp()
+  });
+  return docRef.id;
+}
+async function setDocument(collectionPath, documentId, data, merge = false) {
+  const docRef = getDocRef(collectionPath, documentId);
+  await firestore.setDoc(
+    docRef,
+    {
+      ...data,
+      updatedAt: firestore.serverTimestamp(),
+      ...merge ? {} : { createdAt: firestore.serverTimestamp() }
+    },
+    { merge }
+  );
+}
+async function updateDocument(collectionPath, documentId, data) {
+  const docRef = getDocRef(collectionPath, documentId);
+  await firestore.updateDoc(docRef, {
+    ...data,
+    updatedAt: firestore.serverTimestamp()
+  });
+}
+async function deleteDocument(collectionPath, documentId) {
+  const docRef = getDocRef(collectionPath, documentId);
+  await firestore.deleteDoc(docRef);
+}
+function subscribeToDocument(collectionPath, documentId, callback) {
+  const docRef = getDocRef(collectionPath, documentId);
+  return firestore.onSnapshot(docRef, (docSnap) => {
+    if (docSnap.exists()) {
+      callback({ id: docSnap.id, ...docSnap.data() });
+    } else {
+      callback(null);
+    }
+  });
+}
+function subscribeToCollection(collectionPath, callback, constraints = []) {
+  const collectionRef = getCollectionRef(collectionPath);
+  const q = firestore.query(collectionRef, ...constraints);
+  return firestore.onSnapshot(q, (querySnapshot) => {
+    const data = querySnapshot.docs.map((doc2) => ({
+      id: doc2.id,
+      ...doc2.data()
+    }));
+    callback(data);
+  });
+}
+function getStorageRef(path) {
+  const storage2 = getFirebaseStorage();
+  return storage$1.ref(storage2, path);
+}
+async function uploadFile(path, file, metadata) {
+  const storageRef = getStorageRef(path);
+  await storage$1.uploadBytes(storageRef, file, metadata);
+  return storage$1.getDownloadURL(storageRef);
+}
+function uploadFileWithProgress(path, file, onProgress, metadata) {
+  const storageRef = getStorageRef(path);
+  const task = storage$1.uploadBytesResumable(storageRef, file, metadata);
+  if (onProgress) {
+    task.on("state_changed", (snapshot) => {
+      const progress = snapshot.bytesTransferred / snapshot.totalBytes * 100;
+      onProgress(progress);
+    });
+  }
+  const promise = new Promise((resolve, reject) => {
+    task.on(
+      "state_changed",
+      null,
+      (error) => reject(error),
+      async () => {
+        const url = await storage$1.getDownloadURL(task.snapshot.ref);
+        resolve(url);
+      }
+    );
+  });
+  return { task, promise };
+}
+async function getFileURL(path) {
+  const storageRef = getStorageRef(path);
+  return storage$1.getDownloadURL(storageRef);
+}
+async function deleteFile(path) {
+  const storageRef = getStorageRef(path);
+  return storage$1.deleteObject(storageRef);
+}
+async function listFiles(path) {
+  const storageRef = getStorageRef(path);
+  return storage$1.listAll(storageRef);
+}
+async function getFileMetadata(path) {
+  const storageRef = getStorageRef(path);
+  return storage$1.getMetadata(storageRef);
+}
+async function updateFileMetadata(path, metadata) {
+  const storageRef = getStorageRef(path);
+  return storage$1.updateMetadata(storageRef, metadata);
+}
+function generateFilePath(folder, filename, userId) {
+  const timestamp = Date.now();
+  const extension = filename.split(".").pop() || "";
+  const baseName = filename.replace(/\.[^/.]+$/, "");
+  const sanitizedName = baseName.replace(/[^a-zA-Z0-9]/g, "_");
+  if (userId) {
+    return `${folder}/${userId}/${timestamp}_${sanitizedName}.${extension}`;
+  }
+  return `${folder}/${timestamp}_${sanitizedName}.${extension}`;
+}
+var _analytics = null;
+async function getFirebaseAnalytics() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  if (_analytics) {
+    return _analytics;
+  }
+  const supported = await analytics.isSupported();
+  if (!supported) {
+    console.warn("[mw-core] Firebase Analytics is not supported in this environment");
+    return null;
+  }
+  _analytics = analytics.getAnalytics(getFirebaseApp());
+  return _analytics;
+}
+async function trackEvent(eventName, eventParams) {
+  const analytics$1 = await getFirebaseAnalytics();
+  if (analytics$1) {
+    analytics.logEvent(analytics$1, eventName, eventParams);
+  }
+}
+async function trackPageView(pagePath, pageTitle) {
+  await trackEvent("page_view", {
+    page_path: pagePath,
+    page_title: pageTitle
+  });
+}
+async function trackUserAction(action, category, label, value) {
+  await trackEvent(action, {
+    event_category: category,
+    event_label: label,
+    value
+  });
+}
+async function trackSignUp(method) {
+  await trackEvent("sign_up", { method });
+}
+async function trackLogin(method) {
+  await trackEvent("login", { method });
+}
+function useAuth() {
+  const [user, setUser] = react.useState(null);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    const unsubscribe = subscribeToAuthState((user2) => {
+      setUser(user2);
+      setLoading(false);
+    });
+    return unsubscribe;
+  }, []);
+  const signIn = react.useCallback(async (email, password) => {
+    setError(null);
+    try {
+      return await signInWithEmail(email, password);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const signUp = react.useCallback(
+    async (email, password, displayName) => {
+      setError(null);
+      try {
+        return await signUpWithEmail(email, password, displayName);
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        throw error2;
+      }
+    },
+    []
+  );
+  const signOut2 = react.useCallback(async () => {
+    setError(null);
+    try {
+      await signOut();
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const signInWithGoogle2 = react.useCallback(async () => {
+    setError(null);
+    try {
+      return await signInWithGoogle();
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const resetPassword2 = react.useCallback(async (email) => {
+    setError(null);
+    try {
+      await resetPassword(email);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const updateProfile2 = react.useCallback(
+    async (profile) => {
+      setError(null);
+      if (!user) {
+        const error2 = new Error("No authenticated user");
+        setError(error2);
+        throw error2;
+      }
+      try {
+        await updateUserProfile(user, profile);
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        throw error2;
+      }
+    },
+    [user]
+  );
+  const sendEmailVerificationFn = react.useCallback(async () => {
+    setError(null);
+    if (!user) {
+      const error2 = new Error("No authenticated user");
+      setError(error2);
+      throw error2;
+    }
+    try {
+      await sendVerificationEmail(user);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, [user]);
+  const clearError = react.useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    user,
+    loading,
+    error,
+    signIn,
+    signUp,
+    signOut: signOut2,
+    signInWithGoogle: signInWithGoogle2,
+    resetPassword: resetPassword2,
+    updateProfile: updateProfile2,
+    sendEmailVerification: sendEmailVerificationFn,
+    clearError
+  };
+}
+function useDocument(collectionPath, documentId, options = {}) {
+  const { subscribe = false } = options;
+  const [data, setData] = react.useState(null);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    if (!documentId) {
+      setData(null);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    if (subscribe) {
+      const unsubscribe = subscribeToDocument(
+        collectionPath,
+        documentId,
+        (doc2) => {
+          setData(doc2);
+          setLoading(false);
+        }
+      );
+      return unsubscribe;
+    } else {
+      getDocument(collectionPath, documentId).then((doc2) => {
+        setData(doc2);
+        setLoading(false);
+      }).catch((err) => {
+        setError(err);
+        setLoading(false);
+      });
+    }
+  }, [collectionPath, documentId, subscribe]);
+  const refresh = react.useCallback(async () => {
+    if (!documentId) return;
+    setLoading(true);
+    try {
+      const doc2 = await getDocument(collectionPath, documentId);
+      setData(doc2);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [collectionPath, documentId]);
+  return { data, loading, error, refresh };
+}
+function useCollection(collectionPath, constraints = [], options = {}) {
+  const { subscribe = false } = options;
+  const [data, setData] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const constraintsKey = JSON.stringify(
+    constraints.map((c) => c.type)
+  );
+  react.useEffect(() => {
+    setLoading(true);
+    setError(null);
+    if (subscribe) {
+      const unsubscribe = subscribeToCollection(
+        collectionPath,
+        (docs) => {
+          setData(docs);
+          setLoading(false);
+        },
+        constraints
+      );
+      return unsubscribe;
+    } else {
+      getCollection(collectionPath, constraints).then((docs) => {
+        setData(docs);
+        setLoading(false);
+      }).catch((err) => {
+        setError(err);
+        setLoading(false);
+      });
+    }
+  }, [collectionPath, constraintsKey, subscribe]);
+  const refresh = react.useCallback(async () => {
+    setLoading(true);
+    try {
+      const docs = await getCollection(collectionPath, constraints);
+      setData(docs);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [collectionPath, constraintsKey]);
+  return { data, loading, error, refresh };
+}
+function useFirestoreMutation(collectionPath) {
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const add = react.useCallback(
+    async (data) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const id = await addDocument(collectionPath, data);
+        return id;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [collectionPath]
+  );
+  const set = react.useCallback(
+    async (documentId, data, merge = false) => {
+      setLoading(true);
+      setError(null);
+      try {
+        await setDocument(collectionPath, documentId, data, merge);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [collectionPath]
+  );
+  const update = react.useCallback(
+    async (documentId, data) => {
+      setLoading(true);
+      setError(null);
+      try {
+        await updateDocument(collectionPath, documentId, data);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [collectionPath]
+  );
+  const remove = react.useCallback(
+    async (documentId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        await deleteDocument(collectionPath, documentId);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [collectionPath]
+  );
+  const clearError = react.useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    add,
+    set,
+    update,
+    remove,
+    loading,
+    error,
+    clearError
+  };
+}
+function useStorage() {
+  const [uploading, setUploading] = react.useState(false);
+  const [progress, setProgress] = react.useState(0);
+  const [error, setError] = react.useState(null);
+  const upload = react.useCallback(
+    async (path, file, metadata) => {
+      setError(null);
+      setUploading(true);
+      setProgress(0);
+      try {
+        const url = await uploadFile(path, file, metadata);
+        setProgress(100);
+        return url;
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        throw error2;
+      } finally {
+        setUploading(false);
+      }
+    },
+    []
+  );
+  const uploadWithProgress = react.useCallback(
+    async (path, file, metadata) => {
+      setError(null);
+      setUploading(true);
+      setProgress(0);
+      try {
+        const { promise } = uploadFileWithProgress(
+          path,
+          file,
+          (p) => setProgress(p),
+          metadata
+        );
+        const url = await promise;
+        return url;
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        throw error2;
+      } finally {
+        setUploading(false);
+      }
+    },
+    []
+  );
+  const remove = react.useCallback(async (path) => {
+    setError(null);
+    try {
+      await deleteFile(path);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const getURL = react.useCallback(async (path) => {
+    setError(null);
+    try {
+      return await getFileURL(path);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const clearError = react.useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    upload,
+    uploadWithProgress,
+    remove,
+    getURL,
+    uploading,
+    progress,
+    error,
+    clearError
+  };
+}
+var AuthContext = react.createContext(void 0);
+function AuthProvider({
+  children,
+  onAuthStateChange,
+  loadingComponent
+}) {
+  const [user, setUser] = react.useState(null);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    const unsubscribe = subscribeToAuthState((user2) => {
+      setUser(user2);
+      setLoading(false);
+      onAuthStateChange?.(user2);
+    });
+    return unsubscribe;
+  }, [onAuthStateChange]);
+  const signIn = react.useCallback(async (email, password) => {
+    setError(null);
+    try {
+      return await signInWithEmail(email, password);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const signUp = react.useCallback(
+    async (email, password, displayName) => {
+      setError(null);
+      try {
+        return await signUpWithEmail(email, password, displayName);
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        throw error2;
+      }
+    },
+    []
+  );
+  const signOut2 = react.useCallback(async () => {
+    setError(null);
+    try {
+      await signOut();
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const signInWithGoogle2 = react.useCallback(async () => {
+    setError(null);
+    try {
+      return await signInWithGoogle();
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const resetPassword2 = react.useCallback(async (email) => {
+    setError(null);
+    try {
+      await resetPassword(email);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const updateProfile2 = react.useCallback(
+    async (profile) => {
+      setError(null);
+      if (!user) {
+        const error2 = new Error("No authenticated user");
+        setError(error2);
+        throw error2;
+      }
+      try {
+        await updateUserProfile(user, profile);
+      } catch (err) {
+        const error2 = err;
+        setError(error2);
+        throw error2;
+      }
+    },
+    [user]
+  );
+  const sendEmailVerificationFn = react.useCallback(async () => {
+    setError(null);
+    if (!user) {
+      const error2 = new Error("No authenticated user");
+      setError(error2);
+      throw error2;
+    }
+    try {
+      await sendVerificationEmail(user);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, [user]);
+  const clearError = react.useCallback(() => {
+    setError(null);
+  }, []);
+  const value = react.useMemo(
+    () => ({
+      user,
+      loading,
+      isAuthenticated: !!user,
+      error,
+      signIn,
+      signUp,
+      signOut: signOut2,
+      signInWithGoogle: signInWithGoogle2,
+      resetPassword: resetPassword2,
+      updateProfile: updateProfile2,
+      sendEmailVerification: sendEmailVerificationFn,
+      clearError
+    }),
+    [
+      user,
+      loading,
+      error,
+      signIn,
+      signUp,
+      signOut2,
+      signInWithGoogle2,
+      resetPassword2,
+      updateProfile2,
+      sendEmailVerificationFn,
+      clearError
+    ]
+  );
+  if (loading && loadingComponent) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: loadingComponent });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(AuthContext.Provider, { value, children });
+}
+function useAuthContext() {
+  const context = react.useContext(AuthContext);
+  if (context === void 0) {
+    throw new Error("useAuthContext must be used within an AuthProvider");
+  }
+  return context;
+}
+function withAuth(WrappedComponent, options = {}) {
+  const { LoadingComponent, UnauthenticatedComponent } = options;
+  return function WithAuthComponent(props) {
+    const { user, loading, isAuthenticated } = useAuthContext();
+    if (loading) {
+      return LoadingComponent ? /* @__PURE__ */ jsxRuntime.jsx(LoadingComponent, {}) : /* @__PURE__ */ jsxRuntime.jsx("div", { children: "Loading..." });
+    }
+    if (!isAuthenticated) {
+      return UnauthenticatedComponent ? /* @__PURE__ */ jsxRuntime.jsx(UnauthenticatedComponent, {}) : /* @__PURE__ */ jsxRuntime.jsx("div", { children: "Please sign in to continue" });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(WrappedComponent, { ...props });
+  };
+}
+
+Object.defineProperty(exports, "limit", {
+  enumerable: true,
+  get: function () { return firestore.limit; }
+});
+Object.defineProperty(exports, "orderBy", {
+  enumerable: true,
+  get: function () { return firestore.orderBy; }
+});
+Object.defineProperty(exports, "query", {
+  enumerable: true,
+  get: function () { return firestore.query; }
+});
+Object.defineProperty(exports, "serverTimestamp", {
+  enumerable: true,
+  get: function () { return firestore.serverTimestamp; }
+});
+Object.defineProperty(exports, "startAfter", {
+  enumerable: true,
+  get: function () { return firestore.startAfter; }
+});
+Object.defineProperty(exports, "where", {
+  enumerable: true,
+  get: function () { return firestore.where; }
+});
+exports.AuthProvider = AuthProvider;
+exports.addDocument = addDocument;
+exports.app = app;
+exports.auth = auth;
+exports.db = db;
+exports.deleteDocument = deleteDocument;
+exports.deleteFile = deleteFile;
+exports.generateFilePath = generateFilePath;
+exports.getCollection = getCollection;
+exports.getCollectionRef = getCollectionRef;
+exports.getCurrentUser = getCurrentUser;
+exports.getDocRef = getDocRef;
+exports.getDocument = getDocument;
+exports.getFileMetadata = getFileMetadata;
+exports.getFileURL = getFileURL;
+exports.getFirebaseAnalytics = getFirebaseAnalytics;
+exports.getFirebaseApp = getFirebaseApp;
+exports.getFirebaseAuth = getFirebaseAuth;
+exports.getFirebaseConfig = getFirebaseConfig;
+exports.getFirebaseFirestore = getFirebaseFirestore;
+exports.getFirebaseStorage = getFirebaseStorage;
+exports.getGoogleRedirectResult = getGoogleRedirectResult;
+exports.getStorageRef = getStorageRef;
+exports.initializeFirebase = initializeFirebase;
+exports.listFiles = listFiles;
+exports.resetPassword = resetPassword;
+exports.sendVerificationEmail = sendVerificationEmail;
+exports.setDocument = setDocument;
+exports.signInWithEmail = signInWithEmail;
+exports.signInWithGoogle = signInWithGoogle;
+exports.signInWithGoogleRedirect = signInWithGoogleRedirect;
+exports.signOut = signOut;
+exports.signUpWithEmail = signUpWithEmail;
+exports.storage = storage;
+exports.subscribeToAuthState = subscribeToAuthState;
+exports.subscribeToCollection = subscribeToCollection;
+exports.subscribeToDocument = subscribeToDocument;
+exports.trackEvent = trackEvent;
+exports.trackLogin = trackLogin;
+exports.trackPageView = trackPageView;
+exports.trackSignUp = trackSignUp;
+exports.trackUserAction = trackUserAction;
+exports.updateDocument = updateDocument;
+exports.updateFileMetadata = updateFileMetadata;
+exports.updateUserProfile = updateUserProfile;
+exports.uploadFile = uploadFile;
+exports.uploadFileWithProgress = uploadFileWithProgress;
+exports.useAuth = useAuth;
+exports.useAuthContext = useAuthContext;
+exports.useCollection = useCollection;
+exports.useDocument = useDocument;
+exports.useFirestoreMutation = useFirestoreMutation;
+exports.useStorage = useStorage;
+exports.waitForAuthState = waitForAuthState;
+exports.withAuth = withAuth;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map