@umituz/web-firebase 1.0.5 → 2.0.1

package/dist/chunk-7TX3OU3O.mjs

@@ -0,0 +1,721 @@
+import {
+  createRepositoryError
+} from "./chunk-4FP2ELQ5.mjs";
+import {
+  createAuthError
+} from "./chunk-RZ4QR6TB.mjs";
+
+// src/infrastructure/firebase/client.ts
+import { initializeApp, getApps } from "firebase/app";
+import { initializeAuth, getAuth, browserLocalPersistence } from "firebase/auth";
+import { getFirestore } from "firebase/firestore";
+import { getStorage } from "firebase/storage";
+import { getAnalytics } from "firebase/analytics";
+import { getFunctions } from "firebase/functions";
+var firebaseConfig = {
+  apiKey: process.env.VITE_FIREBASE_API_KEY,
+  authDomain: process.env.VITE_FIREBASE_AUTH_DOMAIN,
+  projectId: process.env.VITE_FIREBASE_PROJECT_ID,
+  storageBucket: process.env.VITE_FIREBASE_STORAGE_BUCKET,
+  messagingSenderId: process.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
+  appId: process.env.VITE_FIREBASE_APP_ID,
+  measurementId: process.env.VITE_FIREBASE_MEASUREMENT_ID
+};
+var app;
+var auth;
+var db;
+var storage;
+var functions;
+var analytics = null;
+function initializeFirebase() {
+  if (!getApps().length) {
+    app = initializeApp(firebaseConfig);
+  } else {
+    app = getApps()[0];
+  }
+  return app;
+}
+function getFirebaseApp() {
+  return app || initializeFirebase();
+}
+function getFirebaseAuth() {
+  if (!auth) {
+    const firebaseApp = getFirebaseApp();
+    if (typeof window !== "undefined") {
+      try {
+        auth = getAuth(firebaseApp);
+      } catch (e) {
+        console.warn("getAuth failed, trying initializeAuth...", e);
+        auth = initializeAuth(firebaseApp, {
+          persistence: browserLocalPersistence
+        });
+      }
+    } else {
+      auth = getAuth(firebaseApp);
+    }
+  }
+  return auth;
+}
+function getFirebaseDB() {
+  if (!db) {
+    db = getFirestore(getFirebaseApp());
+  }
+  return db;
+}
+function getFirebaseStorage() {
+  if (!storage) {
+    storage = getStorage(getFirebaseApp());
+  }
+  return storage;
+}
+function getFirebaseFunctions() {
+  if (!functions) {
+    functions = getFunctions(getFirebaseApp());
+  }
+  return functions;
+}
+function getFirebaseAnalytics() {
+  if (!analytics && typeof window !== "undefined") {
+    analytics = getAnalytics(getFirebaseApp());
+  }
+  return analytics;
+}
+function getFirebaseInstances() {
+  return {
+    app: getFirebaseApp(),
+    auth: getFirebaseAuth(),
+    db: getFirebaseDB(),
+    storage: getFirebaseStorage(),
+    functions: getFirebaseFunctions(),
+    analytics: getFirebaseAnalytics()
+  };
+}
+
+// src/infrastructure/firebase/auth.adapter.ts
+import {
+  signInWithEmailAndPassword,
+  signInWithPopup,
+  createUserWithEmailAndPassword,
+  signOut as firebaseSignOut,
+  sendPasswordResetEmail,
+  sendEmailVerification,
+  updateProfile as updateAuthProfile,
+  updateEmail as updateAuthEmail,
+  updatePassword as updateAuthPassword,
+  reauthenticateWithCredential,
+  EmailAuthProvider
+} from "firebase/auth";
+import { GoogleAuthProvider } from "firebase/auth";
+var AuthAdapter = class {
+  get auth() {
+    return getFirebaseAuth();
+  }
+  // Authentication Methods
+  async signIn(email, password) {
+    try {
+      return await signInWithEmailAndPassword(this.auth, email, password);
+    } catch (error) {
+      throw this.handleAuthError(error);
+    }
+  }
+  async signUp(email, password, displayName) {
+    try {
+      const result = await createUserWithEmailAndPassword(this.auth, email, password);
+      await updateAuthProfile(result.user, { displayName });
+      await sendEmailVerification(result.user);
+      return result;
+    } catch (error) {
+      throw this.handleAuthError(error);
+    }
+  }
+  async signInWithGoogle() {
+    try {
+      const provider = new GoogleAuthProvider();
+      provider.addScope("profile");
+      provider.addScope("email");
+      return await signInWithPopup(this.auth, provider);
+    } catch (error) {
+      throw this.handleAuthError(error);
+    }
+  }
+  async signOut() {
+    try {
+      await firebaseSignOut(this.auth);
+    } catch (error) {
+      throw createAuthError("SIGN_OUT_FAILED" /* SIGN_OUT_FAILED */, "Sign out failed", error);
+    }
+  }
+  async sendPasswordReset(email) {
+    try {
+      await sendPasswordResetEmail(this.auth, email);
+    } catch (error) {
+      throw this.handleAuthError(error);
+    }
+  }
+  async resendEmailVerification() {
+    try {
+      const user = this.auth.currentUser;
+      if (!user) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      await sendEmailVerification(user);
+    } catch (error) {
+      throw createAuthError("EMAIL_VERIFICATION_FAILED" /* EMAIL_VERIFICATION_FAILED */, "Failed to resend verification", error);
+    }
+  }
+  // Profile Management
+  async updateProfile(updates) {
+    try {
+      const user = this.auth.currentUser;
+      if (!user) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      await updateAuthProfile(user, updates);
+    } catch (error) {
+      throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Profile update failed", error);
+    }
+  }
+  async updateEmail(newEmail, password) {
+    try {
+      const user = this.auth.currentUser;
+      if (!user || !user.email) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      const credential = EmailAuthProvider.credential(user.email, password);
+      await reauthenticateWithCredential(user, credential);
+      await updateAuthEmail(user, newEmail);
+    } catch (error) {
+      throw createAuthError("EMAIL_UPDATE_FAILED" /* EMAIL_UPDATE_FAILED */, "Email update failed", error);
+    }
+  }
+  async updatePassword(currentPassword, newPassword) {
+    try {
+      const user = this.auth.currentUser;
+      if (!user || !user.email) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      const credential = EmailAuthProvider.credential(user.email, currentPassword);
+      await reauthenticateWithCredential(user, credential);
+      await updateAuthPassword(user, newPassword);
+    } catch (error) {
+      throw createAuthError("PASSWORD_UPDATE_FAILED" /* PASSWORD_UPDATE_FAILED */, "Password update failed", error);
+    }
+  }
+  async deleteAccount(password) {
+    try {
+      const user = this.auth.currentUser;
+      if (!user || !user.email) {
+        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
+      }
+      const credential = EmailAuthProvider.credential(user.email, password);
+      await reauthenticateWithCredential(user, credential);
+      await user.delete();
+    } catch (error) {
+      throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Account deletion failed", error);
+    }
+  }
+  // State Management
+  getCurrentUser() {
+    return this.auth.currentUser;
+  }
+  onAuthStateChanged(callback) {
+    return this.auth.onAuthStateChanged(callback);
+  }
+  // Note: User document operations should be handled by UserAdapter
+  // These methods are part of IAuthRepository interface but should be implemented separately
+  async createUserDocument(_userId, _data) {
+    throw new Error("createUserDocument should be handled by UserAdapter");
+  }
+  async updateLastLogin(_userId) {
+    throw new Error("updateLastLogin should be handled by UserAdapter");
+  }
+  /**
+   * Handle Firebase Auth errors
+   */
+  handleAuthError(error) {
+    if (error instanceof Error && "code" in error) {
+      const code = error.code;
+      switch (code) {
+        case "auth/user-not-found":
+          return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "User not found", error);
+        case "auth/wrong-password":
+        case "auth/invalid-credential":
+          return createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid credentials", error);
+        case "auth/email-already-in-use":
+          return createAuthError("USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */, "Email already in use", error);
+        case "auth/weak-password":
+          return createAuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, "Password is too weak", error);
+        case "auth/invalid-email":
+          return createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid email", error);
+        case "auth/user-disabled":
+          return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "Account disabled", error);
+        case "auth/too-many-requests":
+          return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many requests", error);
+        case "auth/popup-closed-by-user":
+          return createAuthError("OAUTH_CANCELLED" /* OAUTH_CANCELLED */, "Sign in cancelled", error);
+        case "auth/account-exists-with-different-credential":
+          return createAuthError("OAUTH_ACCOUNT_EXISTS" /* OAUTH_ACCOUNT_EXISTS */, "Account exists with different provider", error);
+        case "auth/requires-recent-login":
+          return createAuthError("REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */, "Please reauthenticate", error);
+        default:
+          return createAuthError("UNKNOWN" /* UNKNOWN */, `Auth error: ${code}`, error);
+      }
+    }
+    return createAuthError("UNKNOWN" /* UNKNOWN */, "Unknown auth error", error);
+  }
+};
+
+// src/infrastructure/firebase/firestore.adapter.ts
+import {
+  doc,
+  getDoc,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  where,
+  onSnapshot,
+  collection,
+  getDocs
+} from "firebase/firestore";
+var FirestoreAdapter = class {
+  get db() {
+    return getFirebaseDB();
+  }
+  USERS_COLLECTION = "users";
+  async getUser(userId) {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId);
+      const snap = await getDoc(docRef);
+      if (!snap.exists()) {
+        return null;
+      }
+      return snap.data();
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "User not found", error);
+    }
+  }
+  async getUserByEmail(email) {
+    try {
+      const q = query(collection(this.db, this.USERS_COLLECTION), where("profile.email", "==", email));
+      const snap = await getDocs(q);
+      if (snap.empty) {
+        return null;
+      }
+      const doc2 = snap.docs[0];
+      return doc2.data();
+    } catch (error) {
+      throw createRepositoryError("QUERY_FAILED" /* QUERY_FAILED */, "Failed to query user", error);
+    }
+  }
+  async createUser(userId, data) {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId);
+      await setDoc(docRef, data, { merge: true });
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_INVALID" /* DOCUMENT_INVALID */, "Failed to create user", error);
+    }
+  }
+  async updateUser(userId, data) {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId);
+      await updateDoc(docRef, {
+        ...data,
+        "profile.updatedAt": Date.now()
+      });
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update user", error);
+    }
+  }
+  async deleteUser(userId) {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId);
+      await deleteDoc(docRef);
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to delete user", error);
+    }
+  }
+  async updateProfile(userId, updates) {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId);
+      const updateData = {
+        "profile.updatedAt": Date.now()
+      };
+      if (updates.displayName !== void 0) {
+        updateData["profile.displayName"] = updates.displayName;
+      }
+      if (updates.photoURL !== void 0) {
+        updateData["profile.photoURL"] = updates.photoURL;
+      }
+      if (updates.phoneNumber !== void 0) {
+        updateData["profile.phoneNumber"] = updates.phoneNumber;
+      }
+      await updateDoc(docRef, updateData);
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update profile", error);
+    }
+  }
+  async updateSettings(userId, settings) {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId);
+      await updateDoc(docRef, {
+        settings: {
+          ...settings,
+          updatedAt: Date.now()
+        }
+      });
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update settings", error);
+    }
+  }
+  async updateSubscription(userId, subscription) {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId);
+      await updateDoc(docRef, {
+        subscription: {
+          ...subscription,
+          updatedAt: Date.now()
+        }
+      });
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update subscription", error);
+    }
+  }
+  async updateLastLogin(userId) {
+    try {
+      const docRef = doc(this.db, this.USERS_COLLECTION, userId);
+      await updateDoc(docRef, {
+        "profile.lastLoginAt": Date.now()
+      });
+    } catch (error) {
+      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to update last login", error);
+    }
+  }
+  async queryUsers(constraints) {
+    try {
+      const q = query(collection(this.db, this.USERS_COLLECTION), ...constraints);
+      const snap = await getDocs(q);
+      return snap.docs.map((doc2) => doc2.data());
+    } catch (error) {
+      throw createRepositoryError("QUERY_FAILED" /* QUERY_FAILED */, "Failed to query users", error);
+    }
+  }
+  subscribeToUser(userId, callback, onError) {
+    const docRef = doc(this.db, this.USERS_COLLECTION, userId);
+    const unsubscribe = onSnapshot(
+      docRef,
+      (snap) => {
+        if (snap.exists()) {
+          callback(snap.data());
+        } else {
+          callback(null);
+        }
+      },
+      (error) => {
+        onError?.(error);
+      }
+    );
+    return unsubscribe;
+  }
+};
+
+// src/infrastructure/firebase/storage.adapter.ts
+import {
+  ref,
+  uploadBytes,
+  uploadBytesResumable,
+  getDownloadURL,
+  deleteObject,
+  listAll,
+  getMetadata
+} from "firebase/storage";
+var StorageAdapter = class {
+  get storage() {
+    return getFirebaseStorage();
+  }
+  // Upload Methods
+  async uploadFile(userId, path, file, options) {
+    const storageRef = ref(this.storage, `users/${userId}/${path}`);
+    const uploadTask = uploadBytesResumable(storageRef, file);
+    return new Promise((resolve, reject) => {
+      uploadTask.on(
+        "state_changed",
+        (snapshot) => {
+          if (options?.onProgress) {
+            const progress = {
+              bytesTransferred: snapshot.bytesTransferred,
+              totalBytes: snapshot.totalBytes,
+              progress: snapshot.bytesTransferred / snapshot.totalBytes * 100,
+              state: "running"
+            };
+            options.onProgress(progress);
+          }
+        },
+        (error) => reject(createRepositoryError("STORAGE_ERROR" /* STORAGE_ERROR */, "Upload failed", error)),
+        async () => {
+          const downloadURL = await getDownloadURL(uploadTask.snapshot.ref);
+          const metadata = await getMetadata(uploadTask.snapshot.ref);
+          resolve({
+            id: uploadTask.snapshot.ref.name,
+            name: metadata.name || uploadTask.snapshot.ref.name,
+            fullPath: metadata.fullPath || uploadTask.snapshot.ref.fullPath,
+            downloadURL,
+            contentType: metadata.contentType || "",
+            size: metadata.size || 0,
+            createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now()
+          });
+        }
+      );
+    });
+  }
+  async uploadImage(userId, file, filename) {
+    const name = filename || `${Date.now()}_${file.name}`;
+    return this.uploadFile(userId, `images/${name}`, file);
+  }
+  async uploadVideo(userId, file, filename) {
+    const name = filename || `${Date.now()}_${file.name}`;
+    return this.uploadFile(userId, `videos/${name}`, file);
+  }
+  async uploadDocument(userId, file, filename) {
+    const name = filename || `${Date.now()}_${file.name}`;
+    return this.uploadFile(userId, `documents/${name}`, file);
+  }
+  async uploadProfilePicture(userId, file) {
+    const storageRef = ref(this.storage, `users/${userId}/profile/${Date.now()}_${file.name}`);
+    await uploadBytes(storageRef, file);
+    const downloadURL = await getDownloadURL(storageRef);
+    return {
+      id: storageRef.name,
+      name: file.name,
+      fullPath: storageRef.fullPath,
+      downloadURL,
+      contentType: file.type,
+      size: file.size,
+      createdAt: Date.now()
+    };
+  }
+  // Download Methods
+  async getDownloadURL(path) {
+    try {
+      const storageRef = ref(this.storage, path);
+      return await getDownloadURL(storageRef);
+    } catch (error) {
+      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
+    }
+  }
+  // Delete Methods
+  async deleteFile(path) {
+    try {
+      const storageRef = ref(this.storage, path);
+      await deleteObject(storageRef);
+    } catch (error) {
+      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
+    }
+  }
+  async deleteUserFiles(userId) {
+    try {
+      const userRef = ref(this.storage, `users/${userId}`);
+      const result = await listAll(userRef);
+      for (const prefix of result.prefixes) {
+        const prefixResult = await listAll(prefix);
+        await Promise.all(prefixResult.items.map((item) => deleteObject(item)));
+      }
+      await Promise.all(result.items.map((item) => deleteObject(item)));
+    } catch (error) {
+      throw createRepositoryError("STORAGE_ERROR" /* STORAGE_ERROR */, "Failed to delete user files", error);
+    }
+  }
+  async deleteImage(userId, filename) {
+    await this.deleteFile(`users/${userId}/images/${filename}`);
+  }
+  async deleteVideo(userId, filename) {
+    await this.deleteFile(`users/${userId}/videos/${filename}`);
+  }
+  async deleteProfilePicture(userId, filename) {
+    await this.deleteFile(`users/${userId}/profile/${filename}`);
+  }
+  // List Methods
+  async listUserFiles(userId, path) {
+    const userRef = ref(this.storage, path ? `users/${userId}/${path}` : `users/${userId}`);
+    const result = await listAll(userRef);
+    const urls = await Promise.all(result.items.map((item) => getDownloadURL(item)));
+    return urls;
+  }
+  async listUserImages(userId) {
+    return this.listUserFiles(userId, "images");
+  }
+  async listUserVideos(userId) {
+    return this.listUserFiles(userId, "videos");
+  }
+  // Metadata
+  async getFileMetadata(path) {
+    try {
+      const storageRef = ref(this.storage, path);
+      const metadata = await getMetadata(storageRef);
+      return {
+        id: storageRef.name,
+        name: metadata.name,
+        fullPath: metadata.fullPath,
+        contentType: metadata.contentType || "application/octet-stream",
+        size: metadata.size,
+        createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now(),
+        updatedAt: metadata.updated ? new Date(metadata.updated).getTime() : Date.now(),
+        userId: this.extractUserId(path) || "unknown",
+        type: this.extractFileType(metadata.contentType || "")
+      };
+    } catch (error) {
+      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
+    }
+  }
+  async queryFiles(userId, _filters) {
+    const userRef = ref(this.storage, `users/${userId}`);
+    const result = await listAll(userRef);
+    const files = await Promise.all(
+      result.items.map(async (item) => {
+        const metadata = await getMetadata(item);
+        return {
+          id: item.name,
+          name: metadata.name,
+          fullPath: metadata.fullPath,
+          contentType: metadata.contentType || "application/octet-stream",
+          size: metadata.size,
+          createdAt: metadata.timeCreated ? new Date(metadata.timeCreated).getTime() : Date.now(),
+          updatedAt: metadata.updated ? new Date(metadata.updated).getTime() : Date.now(),
+          userId,
+          type: this.extractFileType(metadata.contentType || "")
+        };
+      })
+    );
+    return {
+      files,
+      totalCount: files.length,
+      hasMore: false
+    };
+  }
+  async getStorageStats(userId) {
+    const { files, totalCount } = await this.queryFiles(userId);
+    const stats = {
+      totalFiles: totalCount,
+      totalSize: files.reduce((sum, file) => sum + file.size, 0),
+      filesByType: {
+        image: 0,
+        video: 0,
+        audio: 0,
+        document: 0,
+        other: 0
+      },
+      filesByCategory: {
+        profile: 0,
+        content: 0,
+        document: 0,
+        attachment: 0,
+        backup: 0
+      }
+    };
+    files.forEach((file) => {
+      stats.filesByType[file.type]++;
+      stats.lastUploadAt = Math.max(stats.lastUploadAt || 0, file.createdAt);
+    });
+    return stats;
+  }
+  // Validation
+  validateFile(file, options) {
+    const maxSizeBytes = options?.maxSizeBytes || (options?.maxSizeMB ? options.maxSizeMB * 1024 * 1024 : 10 * 1024 * 1024);
+    if (file.size > maxSizeBytes) {
+      return false;
+    }
+    if (options?.allowedTypes && !options.allowedTypes.includes(file.type)) {
+      return false;
+    }
+    return true;
+  }
+  isImageFile(file) {
+    return file.type.startsWith("image/");
+  }
+  isVideoFile(file) {
+    return file.type.startsWith("video/");
+  }
+  isDocumentFile(file) {
+    const docTypes = [
+      "application/pdf",
+      "application/msword",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      "application/vnd.ms-excel",
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      "text/plain"
+    ];
+    return docTypes.includes(file.type);
+  }
+  // Utility Methods
+  generateUniqueFilename(originalName) {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 8);
+    const extension = this.getFileExtension(originalName);
+    return `${timestamp}_${random}.${extension}`;
+  }
+  getFileExtension(filename) {
+    return filename.slice((filename.lastIndexOf(".") - 1 >>> 0) + 2);
+  }
+  // Helper Methods
+  extractUserId(path) {
+    const match = path.match(/users\/([^\/]+)/);
+    return match ? match[1] : "";
+  }
+  extractFileType(contentType) {
+    if (contentType.startsWith("image/")) return "image";
+    if (contentType.startsWith("video/")) return "video";
+    if (contentType.startsWith("audio/")) return "audio";
+    if (contentType.includes("pdf") || contentType.includes("document") || contentType.includes("text")) {
+      return "document";
+    }
+    return "other";
+  }
+};
+
+// src/infrastructure/utils/storage.util.ts
+import {
+  ref as ref2,
+  uploadBytes as uploadBytes2,
+  uploadString,
+  getDownloadURL as getDownloadURL2,
+  deleteObject as deleteObject2
+} from "firebase/storage";
+async function uploadFile(storage2, path, file) {
+  const storageRef = ref2(storage2, path);
+  await uploadBytes2(storageRef, file);
+  const url = await getDownloadURL2(storageRef);
+  return { url, path };
+}
+async function uploadBase64(storage2, path, base64, mimeType = "image/jpeg") {
+  const storageRef = ref2(storage2, path);
+  const dataUrl = base64.startsWith("data:") ? base64 : `data:${mimeType};base64,${base64}`;
+  await uploadString(storageRef, dataUrl, "data_url");
+  const url = await getDownloadURL2(storageRef);
+  return { url, path };
+}
+async function deleteFile(storage2, path) {
+  await deleteObject2(ref2(storage2, path));
+}
+
+export {
+  app,
+  auth,
+  db,
+  storage,
+  functions,
+  analytics,
+  initializeFirebase,
+  getFirebaseApp,
+  getFirebaseAuth,
+  getFirebaseDB,
+  getFirebaseStorage,
+  getFirebaseFunctions,
+  getFirebaseAnalytics,
+  getFirebaseInstances,
+  AuthAdapter,
+  FirestoreAdapter,
+  StorageAdapter,
+  uploadFile,
+  uploadBase64,
+  deleteFile
+};