@umituz/web-firebase 1.0.5 → 2.0.1

package/dist/application/index.js

@@ -0,0 +1,490 @@
+"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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,87 @@
+// 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

@@ -0,0 +1,96 @@
+// 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
+};