@umituz/web-firebase 2.1.0 → 3.0.0

package/dist/application/index.js

@@ -1,490 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/application/index.ts
-var application_exports = {};
-__export(application_exports, {
-  DeleteAccountUseCase: () => DeleteAccountUseCase,
-  ResetPasswordUseCase: () => ResetPasswordUseCase,
-  SignInUseCase: () => SignInUseCase,
-  SignInWithGoogleUseCase: () => SignInWithGoogleUseCase,
-  SignOutUseCase: () => SignOutUseCase,
-  SignUpUseCase: () => SignUpUseCase,
-  UpdateProfileUseCase: () => UpdateProfileUseCase
-});
-module.exports = __toCommonJS(application_exports);
-
-// src/domain/errors/auth.errors.ts
-var AuthError = class extends Error {
-  constructor(message, code, originalError) {
-    super(message);
-    this.code = code;
-    this.originalError = originalError;
-    this.name = "AuthError";
-  }
-};
-function createAuthError(code, message, originalError) {
-  const defaultMessage = getAuthErrorMessage(code);
-  return new AuthError(message || defaultMessage, code, originalError);
-}
-function getAuthErrorMessage(code) {
-  switch (code) {
-    case "USER_NOT_FOUND" /* USER_NOT_FOUND */:
-      return "User not found";
-    case "USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */:
-      return "User already exists";
-    case "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */:
-      return "Invalid credentials";
-    case "WEAK_PASSWORD" /* WEAK_PASSWORD */:
-      return "Password is too weak";
-    case "EMAIL_NOT_VERIFIED" /* EMAIL_NOT_VERIFIED */:
-      return "Email not verified";
-    case "SESSION_EXPIRED" /* SESSION_EXPIRED */:
-      return "Session expired";
-    case "UNAUTHENTICATED" /* UNAUTHENTICATED */:
-      return "User not authenticated";
-    case "TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */:
-      return "Too many requests";
-    case "OAUTH_ERROR" /* OAUTH_ERROR */:
-      return "OAuth error occurred";
-    case "OAUTH_CANCELLED" /* OAUTH_CANCELLED */:
-      return "OAuth cancelled by user";
-    case "OAUTH_ACCOUNT_EXISTS" /* OAUTH_ACCOUNT_EXISTS */:
-      return "Account already exists with this provider";
-    case "SIGN_IN_FAILED" /* SIGN_IN_FAILED */:
-      return "Sign in failed";
-    case "SIGN_UP_FAILED" /* SIGN_UP_FAILED */:
-      return "Sign up failed";
-    case "SIGN_OUT_FAILED" /* SIGN_OUT_FAILED */:
-      return "Sign out failed";
-    case "PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */:
-      return "Password reset failed";
-    case "EMAIL_VERIFICATION_FAILED" /* EMAIL_VERIFICATION_FAILED */:
-      return "Email verification failed";
-    case "PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */:
-      return "Profile update failed";
-    case "EMAIL_UPDATE_FAILED" /* EMAIL_UPDATE_FAILED */:
-      return "Email update failed";
-    case "PASSWORD_UPDATE_FAILED" /* PASSWORD_UPDATE_FAILED */:
-      return "Password update failed";
-    case "ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */:
-      return "Account deletion failed";
-    case "REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */:
-      return "Reauthentication required";
-    case "REAUTHENTICATION_FAILED" /* REAUTHENTICATION_FAILED */:
-      return "Reauthentication failed";
-    case "UNKNOWN" /* UNKNOWN */:
-    default:
-      return "An unknown error occurred";
-  }
-}
-
-// src/application/use-cases/auth/sign-in.use-case.ts
-var SignInUseCase = class {
-  constructor(authRepository) {
-    this.authRepository = authRepository;
-  }
-  /**
-   * Execute sign in use case
-   */
-  async execute(dto) {
-    try {
-      this.validateDTO(dto);
-      const result = await this.authRepository.signIn(dto.email, dto.password);
-      return result;
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-  /**
-   * Validate DTO
-   */
-  validateDTO(dto) {
-    if (!dto.email) {
-      throw createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Email is required");
-    }
-    if (!dto.password) {
-      throw createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Password is required");
-    }
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    if (!emailRegex.test(dto.email)) {
-      throw createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid email format");
-    }
-  }
-  /**
-   * Handle errors
-   */
-  handleError(error) {
-    if (error instanceof Error) {
-      const message = error.message.toLowerCase();
-      if (message.includes("user-not-found") || message.includes("invalid-email")) {
-        return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "User not found", error);
-      }
-      if (message.includes("wrong-password") || message.includes("invalid-credential")) {
-        return createAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "Invalid credentials", error);
-      }
-      if (message.includes("too-many-requests")) {
-        return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many attempts", error);
-      }
-      if (message.includes("user-disabled")) {
-        return createAuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, "Account disabled", error);
-      }
-    }
-    return createAuthError("SIGN_IN_FAILED" /* SIGN_IN_FAILED */, "Sign in failed", error);
-  }
-};
-
-// src/application/use-cases/auth/sign-up.use-case.ts
-var SignUpUseCase = class {
-  constructor(authRepository, userRepository) {
-    this.authRepository = authRepository;
-    this.userRepository = userRepository;
-  }
-  /**
-   * Execute sign up use case
-   */
-  async execute(dto) {
-    try {
-      this.validateDTO(dto);
-      const existingUser = await this.userRepository.getUserByEmail(dto.email);
-      if (existingUser) {
-        throw createAuthError("USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */, "User already exists");
-      }
-      const result = await this.authRepository.signUp(dto.email, dto.password, dto.displayName);
-      return {
-        ...result,
-        userId: result.user.uid,
-        emailVerified: result.user.emailVerified
-      };
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-  /**
-   * Validate DTO
-   */
-  validateDTO(dto) {
-    if (!dto.email) {
-      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Email is required");
-    }
-    if (!dto.password) {
-      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Password is required");
-    }
-    if (!dto.displayName || dto.displayName.trim().length === 0) {
-      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Display name is required");
-    }
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    if (!emailRegex.test(dto.email)) {
-      throw createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Invalid email format");
-    }
-    if (dto.password.length < 6) {
-      throw createAuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, "Password must be at least 6 characters");
-    }
-  }
-  /**
-   * Handle errors
-   */
-  handleError(error) {
-    if (error instanceof Error && "code" in error) {
-      const code = error.code;
-      if (code === "auth/email-already-in-use") {
-        return createAuthError("USER_ALREADY_EXISTS" /* USER_ALREADY_EXISTS */, "Email already in use", error);
-      }
-      if (code === "auth/invalid-email") {
-        return createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Invalid email", error);
-      }
-      if (code === "auth/weak-password") {
-        return createAuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, "Password is too weak", error);
-      }
-      if (code === "auth/operation-not-allowed") {
-        return createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Email/password accounts not enabled", error);
-      }
-    }
-    return createAuthError("SIGN_UP_FAILED" /* SIGN_UP_FAILED */, "Sign up failed", error);
-  }
-};
-
-// src/application/use-cases/auth/sign-in-with-google.use-case.ts
-var SignInWithGoogleUseCase = class {
-  constructor(authRepository, userRepository) {
-    this.authRepository = authRepository;
-    this.userRepository = userRepository;
-  }
-  /**
-   * Execute Google sign in use case
-   */
-  async execute() {
-    try {
-      const result = await this.authRepository.signInWithGoogle();
-      const existingUser = await this.userRepository.getUser(result.user.uid);
-      if (!existingUser) {
-        const createUserDTO = {
-          id: result.user.uid,
-          email: result.user.email || "",
-          displayName: result.user.displayName || "",
-          photoURL: result.user.photoURL || void 0,
-          phoneNumber: result.user.phoneNumber || void 0,
-          emailVerified: result.user.emailVerified
-        };
-        await this.authRepository.createUserDocument(result.user.uid, createUserDTO);
-      }
-      return result;
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-  /**
-   * Handle errors
-   */
-  handleError(error) {
-    if (error instanceof Error && "code" in error) {
-      const code = error.code;
-      if (code === "auth/popup-closed-by-user") {
-        return createAuthError("OAUTH_CANCELLED" /* OAUTH_CANCELLED */, "Google sign in cancelled", error);
-      }
-      if (code === "auth/popup-blocked") {
-        return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Popup blocked by browser", error);
-      }
-      if (code === "auth/account-exists-with-different-credential") {
-        return createAuthError(
-          "OAUTH_ACCOUNT_EXISTS" /* OAUTH_ACCOUNT_EXISTS */,
-          "Account already exists with different credential",
-          error
-        );
-      }
-      if (code === "auth/auth-domain-policy-required") {
-        return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Auth domain not configured", error);
-      }
-      if (code === "auth/unauthorized-domain") {
-        return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Unauthorized domain", error);
-      }
-      if (code === "auth/cancelled-popup-request") {
-        return createAuthError("OAUTH_CANCELLED" /* OAUTH_CANCELLED */, "Sign in cancelled", error);
-      }
-    }
-    return createAuthError("OAUTH_ERROR" /* OAUTH_ERROR */, "Google sign in failed", error);
-  }
-};
-
-// src/application/use-cases/auth/reset-password.use-case.ts
-var ResetPasswordUseCase = class {
-  constructor(authRepository) {
-    this.authRepository = authRepository;
-  }
-  /**
-   * Execute password reset use case
-   */
-  async execute(dto) {
-    try {
-      this.validateDTO(dto);
-      await this.authRepository.sendPasswordReset(dto.email);
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-  /**
-   * Validate DTO
-   */
-  validateDTO(dto) {
-    if (!dto.email) {
-      throw createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Email is required");
-    }
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    if (!emailRegex.test(dto.email)) {
-      throw createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Invalid email format");
-    }
-  }
-  /**
-   * Handle errors
-   */
-  handleError(error) {
-    if (error instanceof Error && "code" in error) {
-      const code = error.code;
-      if (code === "auth/invalid-email") {
-        return createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Invalid email", error);
-      }
-      if (code === "auth/user-not-found") {
-        return createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Password reset email sent if account exists");
-      }
-      if (code === "auth/too-many-requests") {
-        return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many requests", error);
-      }
-    }
-    return createAuthError("PASSWORD_RESET_FAILED" /* PASSWORD_RESET_FAILED */, "Password reset failed", error);
-  }
-};
-
-// src/application/use-cases/auth/sign-out.use-case.ts
-var SignOutUseCase = class {
-  constructor(authRepository) {
-    this.authRepository = authRepository;
-  }
-  /**
-   * Execute sign out use case
-   */
-  async execute() {
-    try {
-      await this.authRepository.signOut();
-    } catch (error) {
-      throw createAuthError("SIGN_OUT_FAILED" /* SIGN_OUT_FAILED */, "Sign out failed", error);
-    }
-  }
-};
-
-// src/application/use-cases/user/update-profile.use-case.ts
-var UpdateProfileUseCase = class {
-  constructor(authRepository) {
-    this.authRepository = authRepository;
-  }
-  /**
-   * Execute profile update use case
-   */
-  async execute(dto) {
-    try {
-      this.validateDTO(dto);
-      const currentUser = this.authRepository.getCurrentUser();
-      if (!currentUser) {
-        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
-      }
-      await this.authRepository.updateProfile(dto);
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-  /**
-   * Validate DTO
-   */
-  validateDTO(dto) {
-    if (!dto.displayName && !dto.photoURL) {
-      throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "At least one field must be provided");
-    }
-    if (dto.displayName !== void 0) {
-      if (typeof dto.displayName !== "string") {
-        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Display name must be a string");
-      }
-      if (dto.displayName.trim().length === 0) {
-        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Display name cannot be empty");
-      }
-      if (dto.displayName.length > 100) {
-        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Display name too long (max 100 characters)");
-      }
-    }
-    if (dto.photoURL !== void 0 && dto.photoURL !== null) {
-      if (typeof dto.photoURL !== "string") {
-        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Photo URL must be a string");
-      }
-      if (dto.photoURL && !this.isValidURL(dto.photoURL)) {
-        throw createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Invalid photo URL");
-      }
-    }
-  }
-  /**
-   * Validate URL format
-   */
-  isValidURL(url) {
-    try {
-      new URL(url);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Handle errors
-   */
-  handleError(error) {
-    if (error instanceof Error && "code" in error) {
-      const code = error.code;
-      if (code === "auth/requires-recent-login") {
-        return createAuthError("REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */, "Please reauthenticate first", error);
-      }
-      if (code === "auth/invalid-photo-url") {
-        return createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Invalid photo URL", error);
-      }
-    }
-    return createAuthError("PROFILE_UPDATE_FAILED" /* PROFILE_UPDATE_FAILED */, "Profile update failed", error);
-  }
-};
-
-// src/application/use-cases/user/delete-account.use-case.ts
-var DeleteAccountUseCase = class {
-  constructor(authRepository) {
-    this.authRepository = authRepository;
-  }
-  /**
-   * Execute account deletion use case
-   */
-  async execute(dto) {
-    try {
-      this.validateDTO(dto);
-      const currentUser = this.authRepository.getCurrentUser();
-      if (!currentUser) {
-        throw createAuthError("UNAUTHENTICATED" /* UNAUTHENTICATED */, "No user logged in");
-      }
-      if (!currentUser.email) {
-        throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "User email not available");
-      }
-      await this.authRepository.deleteAccount(dto.password);
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-  /**
-   * Validate DTO
-   */
-  validateDTO(dto) {
-    if (!dto.password) {
-      throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Password is required");
-    }
-    if (dto.password.length < 1) {
-      throw createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Password cannot be empty");
-    }
-  }
-  /**
-   * Handle errors
-   */
-  handleError(error) {
-    if (error instanceof Error && "code" in error) {
-      const code = error.code;
-      if (code === "auth/requires-recent-login") {
-        return createAuthError("REAUTHENTICATION_REQUIRED" /* REAUTHENTICATION_REQUIRED */, "Please reauthenticate first", error);
-      }
-      if (code === "auth/wrong-password") {
-        return createAuthError("REAUTHENTICATION_FAILED" /* REAUTHENTICATION_FAILED */, "Invalid password", error);
-      }
-      if (code === "auth/too-many-requests") {
-        return createAuthError("TOO_MANY_REQUESTS" /* TOO_MANY_REQUESTS */, "Too many requests", error);
-      }
-      if (code === "auth/user-not-found") {
-        return createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "User not found", error);
-      }
-    }
-    return createAuthError("ACCOUNT_DELETE_FAILED" /* ACCOUNT_DELETE_FAILED */, "Account deletion failed", error);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DeleteAccountUseCase,
-  ResetPasswordUseCase,
-  SignInUseCase,
-  SignInWithGoogleUseCase,
-  SignOutUseCase,
-  SignUpUseCase,
-  UpdateProfileUseCase
-});

package/dist/application/index.mjs

@@ -1,19 +0,0 @@
-import {
-  DeleteAccountUseCase,
-  ResetPasswordUseCase,
-  SignInUseCase,
-  SignInWithGoogleUseCase,
-  SignOutUseCase,
-  SignUpUseCase,
-  UpdateProfileUseCase
-} from "../chunk-U2XI4MGO.mjs";
-import "../chunk-RZ4QR6TB.mjs";
-export {
-  DeleteAccountUseCase,
-  ResetPasswordUseCase,
-  SignInUseCase,
-  SignInWithGoogleUseCase,
-  SignOutUseCase,
-  SignUpUseCase,
-  UpdateProfileUseCase
-};

package/dist/chunk-34DL2QWQ.mjs

@@ -1,87 +0,0 @@
-// src/presentation/hooks/useFirebaseAuth.ts
-import { useState, useEffect, useCallback } from "react";
-import {
-  onAuthStateChanged,
-  signInWithEmailAndPassword,
-  createUserWithEmailAndPassword,
-  signOut as firebaseSignOut,
-  updateProfile,
-  updatePassword,
-  sendPasswordResetEmail
-} from "firebase/auth";
-function mapUser(u) {
-  return {
-    uid: u.uid,
-    email: u.email,
-    displayName: u.displayName,
-    photoURL: u.photoURL,
-    emailVerified: u.emailVerified
-  };
-}
-function useFirebaseAuth(auth, options) {
-  const [user, setUser] = useState(null);
-  const [loading, setLoading] = useState(true);
-  useEffect(() => {
-    const unsub = onAuthStateChanged(auth, (firebaseUser) => {
-      const mapped = firebaseUser ? mapUser(firebaseUser) : null;
-      setUser(mapped);
-      setLoading(false);
-      options?.onUserChange?.(mapped);
-    });
-    return unsub;
-  }, [auth, options]);
-  const signIn = useCallback(
-    (email, password) => signInWithEmailAndPassword(auth, email, password),
-    [auth]
-  );
-  const signUp = useCallback(
-    async (email, password, name) => {
-      const cred = await createUserWithEmailAndPassword(auth, email, password);
-      if (name && cred.user) await updateProfile(cred.user, { displayName: name });
-      return cred;
-    },
-    [auth]
-  );
-  const signOut = useCallback(() => firebaseSignOut(auth), [auth]);
-  const updateUserProfile = useCallback(
-    async (name, photoURL) => {
-      if (!auth.currentUser) throw new Error("No authenticated user");
-      await updateProfile(auth.currentUser, {
-        displayName: name,
-        ...photoURL !== void 0 && { photoURL }
-      });
-    },
-    [auth]
-  );
-  const updateUserPassword = useCallback(
-    async (newPassword) => {
-      if (!auth.currentUser) throw new Error("No authenticated user");
-      await updatePassword(auth.currentUser, newPassword);
-    },
-    [auth]
-  );
-  const resetPassword = useCallback(
-    (email) => sendPasswordResetEmail(auth, email),
-    [auth]
-  );
-  const getIdToken = useCallback(async () => {
-    if (!auth.currentUser) throw new Error("No authenticated user");
-    return auth.currentUser.getIdToken();
-  }, [auth]);
-  return {
-    user,
-    loading,
-    isAuthenticated: !!user,
-    signIn,
-    signUp,
-    signOut,
-    updateUserProfile,
-    updateUserPassword,
-    resetPassword,
-    getIdToken
-  };
-}
-
-export {
-  useFirebaseAuth
-};

package/dist/chunk-4FP2ELQ5.mjs

@@ -1,96 +0,0 @@
-// src/domain/errors/repository.errors.ts
-var RepositoryError = class extends Error {
-  constructor(message, code, originalError) {
-    super(message);
-    this.code = code;
-    this.originalError = originalError;
-    this.name = "RepositoryError";
-  }
-};
-var RepositoryErrorCode = /* @__PURE__ */ ((RepositoryErrorCode2) => {
-  RepositoryErrorCode2["DOCUMENT_NOT_FOUND"] = "DOCUMENT_NOT_FOUND";
-  RepositoryErrorCode2["DOCUMENT_ALREADY_EXISTS"] = "DOCUMENT_ALREADY_EXISTS";
-  RepositoryErrorCode2["DOCUMENT_INVALID"] = "DOCUMENT_INVALID";
-  RepositoryErrorCode2["COLLECTION_NOT_FOUND"] = "COLLECTION_NOT_FOUND";
-  RepositoryErrorCode2["COLLECTION_INVALID"] = "COLLECTION_INVALID";
-  RepositoryErrorCode2["QUERY_INVALID"] = "QUERY_INVALID";
-  RepositoryErrorCode2["QUERY_FAILED"] = "QUERY_FAILED";
-  RepositoryErrorCode2["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
-  RepositoryErrorCode2["TRANSACTION_ABORTED"] = "TRANSACTION_ABORTED";
-  RepositoryErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
-  RepositoryErrorCode2["TIMEOUT"] = "TIMEOUT";
-  RepositoryErrorCode2["OFFLINE"] = "OFFLINE";
-  RepositoryErrorCode2["PERMISSION_DENIED"] = "PERMISSION_DENIED";
-  RepositoryErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
-  RepositoryErrorCode2["VALIDATION_FAILED"] = "VALIDATION_FAILED";
-  RepositoryErrorCode2["INVALID_DATA"] = "INVALID_DATA";
-  RepositoryErrorCode2["CONFLICT"] = "CONFLICT";
-  RepositoryErrorCode2["VERSION_MISMATCH"] = "VERSION_MISMATCH";
-  RepositoryErrorCode2["STORAGE_ERROR"] = "STORAGE_ERROR";
-  RepositoryErrorCode2["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
-  RepositoryErrorCode2["FILE_TOO_LARGE"] = "FILE_TOO_LARGE";
-  RepositoryErrorCode2["INVALID_FILE_TYPE"] = "INVALID_FILE_TYPE";
-  RepositoryErrorCode2["UNKNOWN"] = "UNKNOWN";
-  return RepositoryErrorCode2;
-})(RepositoryErrorCode || {});
-function createRepositoryError(code, message, originalError) {
-  const defaultMessage = getRepositoryErrorMessage(code);
-  return new RepositoryError(message || defaultMessage, code, originalError);
-}
-function getRepositoryErrorMessage(code) {
-  switch (code) {
-    case "DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */:
-      return "Document not found";
-    case "DOCUMENT_ALREADY_EXISTS" /* DOCUMENT_ALREADY_EXISTS */:
-      return "Document already exists";
-    case "DOCUMENT_INVALID" /* DOCUMENT_INVALID */:
-      return "Document is invalid";
-    case "COLLECTION_NOT_FOUND" /* COLLECTION_NOT_FOUND */:
-      return "Collection not found";
-    case "COLLECTION_INVALID" /* COLLECTION_INVALID */:
-      return "Collection is invalid";
-    case "QUERY_INVALID" /* QUERY_INVALID */:
-      return "Query is invalid";
-    case "QUERY_FAILED" /* QUERY_FAILED */:
-      return "Query failed";
-    case "TRANSACTION_FAILED" /* TRANSACTION_FAILED */:
-      return "Transaction failed";
-    case "TRANSACTION_ABORTED" /* TRANSACTION_ABORTED */:
-      return "Transaction aborted";
-    case "NETWORK_ERROR" /* NETWORK_ERROR */:
-      return "Network error";
-    case "TIMEOUT" /* TIMEOUT */:
-      return "Request timeout";
-    case "OFFLINE" /* OFFLINE */:
-      return "Client is offline";
-    case "PERMISSION_DENIED" /* PERMISSION_DENIED */:
-      return "Permission denied";
-    case "UNAUTHORIZED" /* UNAUTHORIZED */:
-      return "Unauthorized";
-    case "VALIDATION_FAILED" /* VALIDATION_FAILED */:
-      return "Validation failed";
-    case "INVALID_DATA" /* INVALID_DATA */:
-      return "Invalid data";
-    case "CONFLICT" /* CONFLICT */:
-      return "Conflict occurred";
-    case "VERSION_MISMATCH" /* VERSION_MISMATCH */:
-      return "Version mismatch";
-    case "STORAGE_ERROR" /* STORAGE_ERROR */:
-      return "Storage error";
-    case "FILE_NOT_FOUND" /* FILE_NOT_FOUND */:
-      return "File not found";
-    case "FILE_TOO_LARGE" /* FILE_TOO_LARGE */:
-      return "File is too large";
-    case "INVALID_FILE_TYPE" /* INVALID_FILE_TYPE */:
-      return "Invalid file type";
-    case "UNKNOWN" /* UNKNOWN */:
-    default:
-      return "An unknown error occurred";
-  }
-}
-
-export {
-  RepositoryError,
-  RepositoryErrorCode,
-  createRepositoryError
-};