@marcwelti/mw-core 0.2.0

package/dist/hooks/index.mjs

@@ -0,0 +1,611 @@
+import { useState, useEffect, useCallback } from 'react';
+import { getAuth, onAuthStateChanged, signInWithEmailAndPassword, createUserWithEmailAndPassword, updateProfile, signOut as signOut$1, GoogleAuthProvider, signInWithPopup, sendPasswordResetEmail, sendEmailVerification } from 'firebase/auth';
+import { getApps, getApp, initializeApp } from 'firebase/app';
+import { getFirestore, onSnapshot, getDoc, query, getDocs, addDoc, serverTimestamp, setDoc, updateDoc, deleteDoc, doc, collection } from 'firebase/firestore';
+import { getStorage, uploadBytes, getDownloadURL, uploadBytesResumable, deleteObject, ref } from 'firebase/storage';
+
+// src/hooks/useAuth.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 (getApps().length > 0) {
+    return getApp();
+  }
+  const firebaseConfig = getFirebaseConfig();
+  return 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 = getAuth(getFirebaseApp());
+  }
+  return _auth;
+}
+function getFirebaseFirestore() {
+  if (!_db) {
+    _db = getFirestore(getFirebaseApp());
+  }
+  return _db;
+}
+function getFirebaseStorage() {
+  if (!_storage) {
+    _storage = getStorage(getFirebaseApp());
+  }
+  return _storage;
+}
+typeof window !== "undefined" ? getFirebaseApp() : null;
+typeof window !== "undefined" ? getFirebaseAuth() : null;
+typeof window !== "undefined" ? getFirebaseFirestore() : null;
+typeof window !== "undefined" ? getFirebaseStorage() : null;
+
+// src/firebase/auth.ts
+async function signInWithEmail(email, password) {
+  const auth2 = getFirebaseAuth();
+  return signInWithEmailAndPassword(auth2, email, password);
+}
+async function signUpWithEmail(email, password, displayName) {
+  const auth2 = getFirebaseAuth();
+  const credential = await createUserWithEmailAndPassword(auth2, email, password);
+  if (displayName && credential.user) {
+    await updateProfile(credential.user, { displayName });
+  }
+  return credential;
+}
+async function signOut() {
+  const auth2 = getFirebaseAuth();
+  return signOut$1(auth2);
+}
+async function resetPassword(email) {
+  const auth2 = getFirebaseAuth();
+  return sendPasswordResetEmail(auth2, email);
+}
+async function sendVerificationEmail(user) {
+  return sendEmailVerification(user);
+}
+async function updateUserProfile(user, profile) {
+  return updateProfile(user, profile);
+}
+async function signInWithGoogle() {
+  const auth2 = getFirebaseAuth();
+  const provider = new GoogleAuthProvider();
+  provider.addScope("email");
+  provider.addScope("profile");
+  return signInWithPopup(auth2, provider);
+}
+function subscribeToAuthState(callback) {
+  const auth2 = getFirebaseAuth();
+  return onAuthStateChanged(auth2, callback);
+}
+
+// src/hooks/useAuth.ts
+function useAuth() {
+  const [user, setUser] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    const unsubscribe = subscribeToAuthState((user2) => {
+      setUser(user2);
+      setLoading(false);
+    });
+    return unsubscribe;
+  }, []);
+  const signIn = useCallback(async (email, password) => {
+    setError(null);
+    try {
+      return await signInWithEmail(email, password);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const signUp = 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 = useCallback(async () => {
+    setError(null);
+    try {
+      await signOut();
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const signInWithGoogle2 = useCallback(async () => {
+    setError(null);
+    try {
+      return await signInWithGoogle();
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const resetPassword2 = useCallback(async (email) => {
+    setError(null);
+    try {
+      await resetPassword(email);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const updateProfile2 = 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 = 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 = useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    user,
+    loading,
+    error,
+    signIn,
+    signUp,
+    signOut: signOut2,
+    signInWithGoogle: signInWithGoogle2,
+    resetPassword: resetPassword2,
+    updateProfile: updateProfile2,
+    sendEmailVerification: sendEmailVerificationFn,
+    clearError
+  };
+}
+function getDocRef(collectionPath, documentId) {
+  const db2 = getFirebaseFirestore();
+  return doc(db2, collectionPath, documentId);
+}
+function getCollectionRef(collectionPath) {
+  const db2 = getFirebaseFirestore();
+  return collection(db2, collectionPath);
+}
+async function getDocument(collectionPath, documentId) {
+  const docRef = getDocRef(collectionPath, documentId);
+  const docSnap = await getDoc(docRef);
+  if (docSnap.exists()) {
+    return { id: docSnap.id, ...docSnap.data() };
+  }
+  return null;
+}
+async function getCollection(collectionPath, constraints = []) {
+  const collectionRef = getCollectionRef(collectionPath);
+  const q = query(collectionRef, ...constraints);
+  const querySnapshot = await getDocs(q);
+  return querySnapshot.docs.map((doc2) => ({
+    id: doc2.id,
+    ...doc2.data()
+  }));
+}
+async function addDocument(collectionPath, data) {
+  const collectionRef = getCollectionRef(collectionPath);
+  const docRef = await addDoc(collectionRef, {
+    ...data,
+    createdAt: serverTimestamp(),
+    updatedAt: serverTimestamp()
+  });
+  return docRef.id;
+}
+async function setDocument(collectionPath, documentId, data, merge = false) {
+  const docRef = getDocRef(collectionPath, documentId);
+  await setDoc(
+    docRef,
+    {
+      ...data,
+      updatedAt: serverTimestamp(),
+      ...merge ? {} : { createdAt: serverTimestamp() }
+    },
+    { merge }
+  );
+}
+async function updateDocument(collectionPath, documentId, data) {
+  const docRef = getDocRef(collectionPath, documentId);
+  await updateDoc(docRef, {
+    ...data,
+    updatedAt: serverTimestamp()
+  });
+}
+async function deleteDocument(collectionPath, documentId) {
+  const docRef = getDocRef(collectionPath, documentId);
+  await deleteDoc(docRef);
+}
+function subscribeToDocument(collectionPath, documentId, callback) {
+  const docRef = getDocRef(collectionPath, documentId);
+  return 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 = query(collectionRef, ...constraints);
+  return onSnapshot(q, (querySnapshot) => {
+    const data = querySnapshot.docs.map((doc2) => ({
+      id: doc2.id,
+      ...doc2.data()
+    }));
+    callback(data);
+  });
+}
+
+// src/hooks/useFirestore.ts
+function useDocument(collectionPath, documentId, options = {}) {
+  const { subscribe = false } = options;
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  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 = 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] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const constraintsKey = JSON.stringify(
+    constraints.map((c) => c.type)
+  );
+  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 = 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] = useState(false);
+  const [error, setError] = useState(null);
+  const add = 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 = 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 = 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 = useCallback(
+    async (documentId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        await deleteDocument(collectionPath, documentId);
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [collectionPath]
+  );
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    add,
+    set,
+    update,
+    remove,
+    loading,
+    error,
+    clearError
+  };
+}
+function getStorageRef(path) {
+  const storage2 = getFirebaseStorage();
+  return ref(storage2, path);
+}
+async function uploadFile(path, file, metadata) {
+  const storageRef = getStorageRef(path);
+  await uploadBytes(storageRef, file, metadata);
+  return getDownloadURL(storageRef);
+}
+function uploadFileWithProgress(path, file, onProgress, metadata) {
+  const storageRef = getStorageRef(path);
+  const task = 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 getDownloadURL(task.snapshot.ref);
+        resolve(url);
+      }
+    );
+  });
+  return { task, promise };
+}
+async function getFileURL(path) {
+  const storageRef = getStorageRef(path);
+  return getDownloadURL(storageRef);
+}
+async function deleteFile(path) {
+  const storageRef = getStorageRef(path);
+  return deleteObject(storageRef);
+}
+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}`;
+}
+
+// src/hooks/useStorage.ts
+function useStorage() {
+  const [uploading, setUploading] = useState(false);
+  const [progress, setProgress] = useState(0);
+  const [error, setError] = useState(null);
+  const upload = 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 = 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 = useCallback(async (path) => {
+    setError(null);
+    try {
+      await deleteFile(path);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const getURL = useCallback(async (path) => {
+    setError(null);
+    try {
+      return await getFileURL(path);
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    }
+  }, []);
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+  return {
+    upload,
+    uploadWithProgress,
+    remove,
+    getURL,
+    uploading,
+    progress,
+    error,
+    clearError
+  };
+}
+
+export { generateFilePath, useAuth, useCollection, useDocument, useFirestoreMutation, useStorage };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map