@umituz/web-firebase 2.1.0 → 3.0.0

package/dist/index.js

@@ -1,1833 +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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AuthAdapter: () => AuthAdapter,
-  AuthError: () => AuthError,
-  AuthErrorCode: () => AuthErrorCode,
-  DeleteAccountUseCase: () => DeleteAccountUseCase,
-  Email: () => Email,
-  FileErrorCode: () => FileErrorCode,
-  FilePath: () => FilePath,
-  FirestoreAdapter: () => FirestoreAdapter,
-  RepositoryError: () => RepositoryError,
-  RepositoryErrorCode: () => RepositoryErrorCode,
-  ResetPasswordUseCase: () => ResetPasswordUseCase,
-  SignInUseCase: () => SignInUseCase,
-  SignInWithGoogleUseCase: () => SignInWithGoogleUseCase,
-  SignOutUseCase: () => SignOutUseCase,
-  SignUpUseCase: () => SignUpUseCase,
-  StorageAdapter: () => StorageAdapter,
-  Timestamp: () => Timestamp,
-  USER_COLLECTIONS: () => USER_COLLECTIONS,
-  USER_SUBCOLLECTIONS: () => USER_SUBCOLLECTIONS,
-  UpdateProfileUseCase: () => UpdateProfileUseCase,
-  UserId: () => UserId,
-  analytics: () => analytics,
-  app: () => app,
-  auth: () => auth,
-  createAuthError: () => createAuthError,
-  createRepositoryError: () => createRepositoryError,
-  db: () => db,
-  deleteFile: () => deleteFile,
-  functions: () => functions,
-  getFirebaseAnalytics: () => getFirebaseAnalytics,
-  getFirebaseApp: () => getFirebaseApp,
-  getFirebaseAuth: () => getFirebaseAuth,
-  getFirebaseDB: () => getFirebaseDB,
-  getFirebaseFunctions: () => getFirebaseFunctions,
-  getFirebaseInstances: () => getFirebaseInstances,
-  getFirebaseStorage: () => getFirebaseStorage,
-  initializeFirebase: () => initializeFirebase,
-  serverTimestamp: () => serverTimestamp,
-  storage: () => storage,
-  uploadBase64: () => uploadBase64,
-  uploadFile: () => uploadFile,
-  useFirebaseAuth: () => useFirebaseAuth
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/domain/entities/user.entity.ts
-var USER_COLLECTIONS = {
-  USERS: "users",
-  CONTENT: "content",
-  ANALYTICS: "analytics",
-  CONNECTED_ACCOUNTS: "connectedAccounts"
-};
-var USER_SUBCOLLECTIONS = {
-  CONTENT: "content",
-  ANALYTICS: "analytics",
-  SCHEDULED: "scheduled",
-  PUBLISHED: "published",
-  DRAFTS: "drafts"
-};
-
-// src/domain/entities/file.entity.ts
-var FileErrorCode = /* @__PURE__ */ ((FileErrorCode2) => {
-  FileErrorCode2["FILE_TOO_LARGE"] = "FILE_TOO_LARGE";
-  FileErrorCode2["INVALID_TYPE"] = "INVALID_TYPE";
-  FileErrorCode2["INVALID_EXTENSION"] = "INVALID_EXTENSION";
-  FileErrorCode2["UPLOAD_FAILED"] = "UPLOAD_FAILED";
-  FileErrorCode2["DOWNLOAD_FAILED"] = "DOWNLOAD_FAILED";
-  FileErrorCode2["DELETE_FAILED"] = "DELETE_FAILED";
-  FileErrorCode2["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
-  FileErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
-  FileErrorCode2["CANCELLED"] = "CANCELLED";
-  return FileErrorCode2;
-})(FileErrorCode || {});
-
-// src/domain/entities/timestamp.entity.ts
-var Timestamp = class _Timestamp {
-  constructor(seconds, nanoseconds) {
-    this.seconds = seconds;
-    this.nanoseconds = nanoseconds;
-  }
-  /**
-   * Create Timestamp from JavaScript Date
-   */
-  static fromDate(date) {
-    const milliseconds = date.getTime();
-    const seconds = Math.floor(milliseconds / 1e3);
-    const nanoseconds = milliseconds % 1e3 * 1e6;
-    return new _Timestamp(seconds, nanoseconds);
-  }
-  /**
-   * Create Timestamp from milliseconds
-   */
-  static fromMillis(milliseconds) {
-    const seconds = Math.floor(milliseconds / 1e3);
-    const nanoseconds = milliseconds % 1e3 * 1e6;
-    return new _Timestamp(seconds, nanoseconds);
-  }
-  /**
-   * Create Timestamp from Firestore Timestamp
-   */
-  static fromFirestoreTimestamp(timestamp) {
-    return new _Timestamp(timestamp.seconds, timestamp.nanoseconds);
-  }
-  /**
-   * Get current timestamp
-   */
-  static now() {
-    return _Timestamp.fromDate(/* @__PURE__ */ new Date());
-  }
-  /**
-   * Convert to JavaScript Date
-   */
-  toDate() {
-    return new Date(this.seconds * 1e3 + this.nanoseconds / 1e6);
-  }
-  /**
-   * Convert to milliseconds
-   */
-  toMillis() {
-    return this.seconds * 1e3 + this.nanoseconds / 1e6;
-  }
-  /**
-   * Convert to Firestore Timestamp
-   */
-  toFirestoreTimestamp() {
-    return {
-      seconds: this.seconds,
-      nanoseconds: this.nanoseconds
-    };
-  }
-  /**
-   * Convert to ISO string
-   */
-  toISOString() {
-    return this.toDate().toISOString();
-  }
-  /**
-   * Check if timestamp is in the past
-   */
-  isPast() {
-    return this.toMillis() < Date.now();
-  }
-  /**
-   * Check if timestamp is in the future
-   */
-  isFuture() {
-    return this.toMillis() > Date.now();
-  }
-  /**
-   * Get difference in milliseconds with another timestamp
-   */
-  diff(other) {
-    return this.toMillis() - other.toMillis();
-  }
-};
-var serverTimestamp = {
-  __type__: "serverTimestamp"
-};
-
-// src/domain/value-objects/email.vo.ts
-var Email = class _Email {
-  value;
-  validated;
-  constructor(email) {
-    this.value = email.trim().toLowerCase();
-    this.validated = this.isValid();
-    if (!this.validated) {
-      throw new Error(`Invalid email address: ${email}`);
-    }
-  }
-  /**
-   * Validate email format
-   */
-  isValid() {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return emailRegex.test(this.value);
-  }
-  /**
-   * Get email value
-   */
-  getValue() {
-    return this.value;
-  }
-  /**
-   * Get local part (before @)
-   */
-  getLocalPart() {
-    return this.value.split("@")[0];
-  }
-  /**
-   * Get domain part (after @)
-   */
-  getDomain() {
-    return this.value.split("@")[1] || "";
-  }
-  /**
-   * Check if email is from a specific domain
-   */
-  isFromDomain(domain) {
-    return this.getDomain() === domain.toLowerCase();
-  }
-  /**
-   * Check if email is from a corporate domain (not gmail, yahoo, etc.)
-   */
-  isCorporate() {
-    const freeDomains = [
-      "gmail.com",
-      "yahoo.com",
-      "hotmail.com",
-      "outlook.com",
-      "aol.com",
-      "icloud.com",
-      "protonmail.com"
-    ];
-    return !freeDomains.includes(this.getDomain());
-  }
-  /**
-   * Mask email for display (e.g., u***@gmail.com)
-   */
-  mask() {
-    const [local, domain] = this.value.split("@");
-    if (local.length <= 2) {
-      return `${local[0]}***@${domain}`;
-    }
-    return `${local[0]}${"*".repeat(local.length - 2)}${local[local.length - 1]}@${domain}`;
-  }
-  /**
-   * Convert to string
-   */
-  toString() {
-    return this.value;
-  }
-  /**
-   * Check equality with another email
-   */
-  equals(other) {
-    return this.value === other.value;
-  }
-  /**
-   * Create Email from string (returns null if invalid)
-   */
-  static create(email) {
-    try {
-      return new _Email(email);
-    } catch {
-      return null;
-    }
-  }
-};
-
-// 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";
-  }
-}
-
-// src/domain/value-objects/user-id.vo.ts
-var UserId = class _UserId {
-  value;
-  constructor(id) {
-    this.value = id;
-    this.validate();
-  }
-  /**
-   * Validate user ID
-   */
-  validate() {
-    if (!this.value) {
-      throw createRepositoryError("INVALID_DATA" /* INVALID_DATA */, "User ID cannot be empty");
-    }
-    if (this.value.length < 20) {
-      throw createRepositoryError(
-        "INVALID_DATA" /* INVALID_DATA */,
-        "User ID is too short (must be at least 20 characters)"
-      );
-    }
-    const validPattern = /^[a-zA-Z0-9_-]+$/;
-    if (!validPattern.test(this.value)) {
-      throw createRepositoryError(
-        "INVALID_DATA" /* INVALID_DATA */,
-        "User ID contains invalid characters"
-      );
-    }
-  }
-  /**
-   * Get user ID value
-   */
-  getValue() {
-    return this.value;
-  }
-  /**
-   * Check if this is a temporary ID (not yet persisted)
-   */
-  isTemporary() {
-    return this.value.startsWith("temp_");
-  }
-  /**
-   * Convert to string
-   */
-  toString() {
-    return this.value;
-  }
-  /**
-   * Check equality with another user ID
-   */
-  equals(other) {
-    return this.value === other.value;
-  }
-  /**
-   * Generate a temporary user ID
-   */
-  static generateTemp() {
-    return new _UserId(`temp_${Date.now()}_${Math.random().toString(36).substring(7)}`);
-  }
-  /**
-   * Create UserId from string (returns null if invalid)
-   */
-  static create(id) {
-    try {
-      return new _UserId(id);
-    } catch {
-      return null;
-    }
-  }
-};
-
-// src/domain/value-objects/file-path.vo.ts
-var FilePath = class _FilePath {
-  value;
-  parts;
-  constructor(path) {
-    this.value = path.trim();
-    this.parts = this.value.split("/").filter((p) => p.length > 0);
-    this.validate();
-  }
-  /**
-   * Validate file path
-   */
-  validate() {
-    if (!this.value) {
-      throw createRepositoryError("INVALID_DATA" /* INVALID_DATA */, "File path cannot be empty");
-    }
-    if (this.value.startsWith("/") || this.value.endsWith("/")) {
-      throw createRepositoryError(
-        "INVALID_DATA" /* INVALID_DATA */,
-        "File path should not start or end with /"
-      );
-    }
-    if (this.value.includes("//")) {
-      throw createRepositoryError("INVALID_DATA" /* INVALID_DATA */, "File path should not contain //");
-    }
-    if (this.parts.length === 0) {
-      throw createRepositoryError("INVALID_DATA" /* INVALID_DATA */, "File path must have at least one segment");
-    }
-    for (const part of this.parts) {
-      if (/[<>:"|?*]/.test(part)) {
-        throw createRepositoryError(
-          "INVALID_DATA" /* INVALID_DATA */,
-          `Invalid characters in path segment: ${part}`
-        );
-      }
-      if (part === "." || part === "..") {
-        throw createRepositoryError(
-          "INVALID_DATA" /* INVALID_DATA */,
-          `Invalid path segment: ${part}`
-        );
-      }
-    }
-  }
-  /**
-   * Get file path value
-   */
-  getValue() {
-    return this.value;
-  }
-  /**
-   * Get path parts
-   */
-  getParts() {
-    return [...this.parts];
-  }
-  /**
-   * Get filename (last part of path)
-   */
-  getFileName() {
-    return this.parts[this.parts.length - 1] || "";
-  }
-  /**
-   * Get directory path (all parts except last)
-   */
-  getDirectory() {
-    return this.parts.slice(0, -1).join("/");
-  }
-  /**
-   * Get file extension
-   */
-  getExtension() {
-    const fileName = this.getFileName();
-    const lastDot = fileName.lastIndexOf(".");
-    return lastDot > 0 ? fileName.substring(lastDot + 1) : "";
-  }
-  /**
-   * Get file name without extension
-   */
-  getFileNameWithoutExtension() {
-    const fileName = this.getFileName();
-    const lastDot = fileName.lastIndexOf(".");
-    return lastDot > 0 ? fileName.substring(0, lastDot) : fileName;
-  }
-  /**
-   * Check if path is in a specific directory
-   */
-  isInDirectory(directory) {
-    return this.value.startsWith(directory + "/");
-  }
-  /**
-   * Check if file has a specific extension
-   */
-  hasExtension(extension) {
-    return this.getExtension().toLowerCase() === extension.toLowerCase();
-  }
-  /**
-   * Create a new path by appending segments
-   */
-  append(...segments) {
-    return new _FilePath([...this.parts, ...segments].join("/"));
-  }
-  /**
-   * Create a new path in a parent directory
-   */
-  withParent(parent) {
-    return new _FilePath([parent, ...this.parts].join("/"));
-  }
-  /**
-   * Create a new path with a different filename
-   */
-  withFileName(fileName) {
-    const dir = this.getDirectory();
-    return dir ? new _FilePath(`${dir}/${fileName}`) : new _FilePath(fileName);
-  }
-  /**
-   * Convert to string
-   */
-  toString() {
-    return this.value;
-  }
-  /**
-   * Check equality with another file path
-   */
-  equals(other) {
-    return this.value === other.value;
-  }
-  /**
-   * Create user path (users/{userId}/...)
-   */
-  static userPath(userId, ...segments) {
-    return new _FilePath(["users", userId, ...segments].join("/"));
-  }
-  /**
-   * Create public path (public/...)
-   */
-  static publicPath(...segments) {
-    return new _FilePath(["public", ...segments].join("/"));
-  }
-  /**
-   * Create FilePath from string (returns null if invalid)
-   */
-  static create(path) {
-    try {
-      return new _FilePath(path);
-    } catch {
-      return null;
-    }
-  }
-};
-
-// 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";
-  }
-};
-var AuthErrorCode = /* @__PURE__ */ ((AuthErrorCode2) => {
-  AuthErrorCode2["USER_NOT_FOUND"] = "USER_NOT_FOUND";
-  AuthErrorCode2["USER_ALREADY_EXISTS"] = "USER_ALREADY_EXISTS";
-  AuthErrorCode2["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
-  AuthErrorCode2["WEAK_PASSWORD"] = "WEAK_PASSWORD";
-  AuthErrorCode2["EMAIL_NOT_VERIFIED"] = "EMAIL_NOT_VERIFIED";
-  AuthErrorCode2["SESSION_EXPIRED"] = "SESSION_EXPIRED";
-  AuthErrorCode2["UNAUTHENTICATED"] = "UNAUTHENTICATED";
-  AuthErrorCode2["TOO_MANY_REQUESTS"] = "TOO_MANY_REQUESTS";
-  AuthErrorCode2["OAUTH_ERROR"] = "OAUTH_ERROR";
-  AuthErrorCode2["OAUTH_CANCELLED"] = "OAUTH_CANCELLED";
-  AuthErrorCode2["OAUTH_ACCOUNT_EXISTS"] = "OAUTH_ACCOUNT_EXISTS";
-  AuthErrorCode2["SIGN_IN_FAILED"] = "SIGN_IN_FAILED";
-  AuthErrorCode2["SIGN_UP_FAILED"] = "SIGN_UP_FAILED";
-  AuthErrorCode2["SIGN_OUT_FAILED"] = "SIGN_OUT_FAILED";
-  AuthErrorCode2["PASSWORD_RESET_FAILED"] = "PASSWORD_RESET_FAILED";
-  AuthErrorCode2["EMAIL_VERIFICATION_FAILED"] = "EMAIL_VERIFICATION_FAILED";
-  AuthErrorCode2["PROFILE_UPDATE_FAILED"] = "PROFILE_UPDATE_FAILED";
-  AuthErrorCode2["EMAIL_UPDATE_FAILED"] = "EMAIL_UPDATE_FAILED";
-  AuthErrorCode2["PASSWORD_UPDATE_FAILED"] = "PASSWORD_UPDATE_FAILED";
-  AuthErrorCode2["ACCOUNT_DELETE_FAILED"] = "ACCOUNT_DELETE_FAILED";
-  AuthErrorCode2["REAUTHENTICATION_REQUIRED"] = "REAUTHENTICATION_REQUIRED";
-  AuthErrorCode2["REAUTHENTICATION_FAILED"] = "REAUTHENTICATION_FAILED";
-  AuthErrorCode2["UNKNOWN"] = "UNKNOWN";
-  return AuthErrorCode2;
-})(AuthErrorCode || {});
-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);
-  }
-};
-
-// src/infrastructure/firebase/client.ts
-var import_app = require("firebase/app");
-var import_auth8 = require("firebase/auth");
-var import_firestore = require("firebase/firestore");
-var import_storage = require("firebase/storage");
-var import_analytics = require("firebase/analytics");
-var import_functions = require("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 (!(0, import_app.getApps)().length) {
-    app = (0, import_app.initializeApp)(firebaseConfig);
-  } else {
-    app = (0, import_app.getApps)()[0];
-  }
-  return app;
-}
-function getFirebaseApp() {
-  return app || initializeFirebase();
-}
-function getFirebaseAuth() {
-  if (!auth) {
-    const firebaseApp = getFirebaseApp();
-    if (typeof window !== "undefined") {
-      try {
-        auth = (0, import_auth8.getAuth)(firebaseApp);
-      } catch (e) {
-        console.warn("getAuth failed, trying initializeAuth...", e);
-        auth = (0, import_auth8.initializeAuth)(firebaseApp, {
-          persistence: import_auth8.browserLocalPersistence
-        });
-      }
-    } else {
-      auth = (0, import_auth8.getAuth)(firebaseApp);
-    }
-  }
-  return auth;
-}
-function getFirebaseDB() {
-  if (!db) {
-    db = (0, import_firestore.getFirestore)(getFirebaseApp());
-  }
-  return db;
-}
-function getFirebaseStorage() {
-  if (!storage) {
-    storage = (0, import_storage.getStorage)(getFirebaseApp());
-  }
-  return storage;
-}
-function getFirebaseFunctions() {
-  if (!functions) {
-    functions = (0, import_functions.getFunctions)(getFirebaseApp());
-  }
-  return functions;
-}
-function getFirebaseAnalytics() {
-  if (!analytics && typeof window !== "undefined") {
-    analytics = (0, import_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
-var import_auth9 = require("firebase/auth");
-var import_auth10 = require("firebase/auth");
-var AuthAdapter = class {
-  get auth() {
-    return getFirebaseAuth();
-  }
-  // Authentication Methods
-  async signIn(email, password) {
-    try {
-      return await (0, import_auth9.signInWithEmailAndPassword)(this.auth, email, password);
-    } catch (error) {
-      throw this.handleAuthError(error);
-    }
-  }
-  async signUp(email, password, displayName) {
-    try {
-      const result = await (0, import_auth9.createUserWithEmailAndPassword)(this.auth, email, password);
-      await (0, import_auth9.updateProfile)(result.user, { displayName });
-      await (0, import_auth9.sendEmailVerification)(result.user);
-      return result;
-    } catch (error) {
-      throw this.handleAuthError(error);
-    }
-  }
-  async signInWithGoogle() {
-    try {
-      const provider = new import_auth10.GoogleAuthProvider();
-      provider.addScope("profile");
-      provider.addScope("email");
-      return await (0, import_auth9.signInWithPopup)(this.auth, provider);
-    } catch (error) {
-      throw this.handleAuthError(error);
-    }
-  }
-  async signOut() {
-    try {
-      await (0, import_auth9.signOut)(this.auth);
-    } catch (error) {
-      throw createAuthError("SIGN_OUT_FAILED" /* SIGN_OUT_FAILED */, "Sign out failed", error);
-    }
-  }
-  async sendPasswordReset(email) {
-    try {
-      await (0, import_auth9.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 (0, import_auth9.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 (0, import_auth9.updateProfile)(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 = import_auth9.EmailAuthProvider.credential(user.email, password);
-      await (0, import_auth9.reauthenticateWithCredential)(user, credential);
-      await (0, import_auth9.updateEmail)(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 = import_auth9.EmailAuthProvider.credential(user.email, currentPassword);
-      await (0, import_auth9.reauthenticateWithCredential)(user, credential);
-      await (0, import_auth9.updatePassword)(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 = import_auth9.EmailAuthProvider.credential(user.email, password);
-      await (0, import_auth9.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
-var import_firestore2 = require("firebase/firestore");
-var FirestoreAdapter = class {
-  get db() {
-    return getFirebaseDB();
-  }
-  USERS_COLLECTION = "users";
-  async getUser(userId) {
-    try {
-      const docRef = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      const snap = await (0, import_firestore2.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 = (0, import_firestore2.query)((0, import_firestore2.collection)(this.db, this.USERS_COLLECTION), (0, import_firestore2.where)("profile.email", "==", email));
-      const snap = await (0, import_firestore2.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 = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.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 = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.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 = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.deleteDoc)(docRef);
-    } catch (error) {
-      throw createRepositoryError("DOCUMENT_NOT_FOUND" /* DOCUMENT_NOT_FOUND */, "Failed to delete user", error);
-    }
-  }
-  async updateProfile(userId, updates) {
-    try {
-      const docRef = (0, import_firestore2.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 (0, import_firestore2.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 = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.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 = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.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 = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-      await (0, import_firestore2.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 = (0, import_firestore2.query)((0, import_firestore2.collection)(this.db, this.USERS_COLLECTION), ...constraints);
-      const snap = await (0, import_firestore2.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 = (0, import_firestore2.doc)(this.db, this.USERS_COLLECTION, userId);
-    const unsubscribe = (0, import_firestore2.onSnapshot)(
-      docRef,
-      (snap) => {
-        if (snap.exists()) {
-          callback(snap.data());
-        } else {
-          callback(null);
-        }
-      },
-      (error) => {
-        onError?.(error);
-      }
-    );
-    return unsubscribe;
-  }
-};
-
-// src/infrastructure/firebase/storage.adapter.ts
-var import_storage2 = require("firebase/storage");
-var StorageAdapter = class {
-  get storage() {
-    return getFirebaseStorage();
-  }
-  // Upload Methods
-  async uploadFile(userId, path, file, options) {
-    const storageRef = (0, import_storage2.ref)(this.storage, `users/${userId}/${path}`);
-    const uploadTask = (0, import_storage2.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 (0, import_storage2.getDownloadURL)(uploadTask.snapshot.ref);
-          const metadata = await (0, import_storage2.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 = (0, import_storage2.ref)(this.storage, `users/${userId}/profile/${Date.now()}_${file.name}`);
-    await (0, import_storage2.uploadBytes)(storageRef, file);
-    const downloadURL = await (0, import_storage2.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 = (0, import_storage2.ref)(this.storage, path);
-      return await (0, import_storage2.getDownloadURL)(storageRef);
-    } catch (error) {
-      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
-    }
-  }
-  // Delete Methods
-  async deleteFile(path) {
-    try {
-      const storageRef = (0, import_storage2.ref)(this.storage, path);
-      await (0, import_storage2.deleteObject)(storageRef);
-    } catch (error) {
-      throw createRepositoryError("FILE_NOT_FOUND" /* FILE_NOT_FOUND */, "File not found", error);
-    }
-  }
-  async deleteUserFiles(userId) {
-    try {
-      const userRef = (0, import_storage2.ref)(this.storage, `users/${userId}`);
-      const result = await (0, import_storage2.listAll)(userRef);
-      for (const prefix of result.prefixes) {
-        const prefixResult = await (0, import_storage2.listAll)(prefix);
-        await Promise.all(prefixResult.items.map((item) => (0, import_storage2.deleteObject)(item)));
-      }
-      await Promise.all(result.items.map((item) => (0, import_storage2.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 = (0, import_storage2.ref)(this.storage, path ? `users/${userId}/${path}` : `users/${userId}`);
-    const result = await (0, import_storage2.listAll)(userRef);
-    const urls = await Promise.all(result.items.map((item) => (0, import_storage2.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 = (0, import_storage2.ref)(this.storage, path);
-      const metadata = await (0, import_storage2.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 = (0, import_storage2.ref)(this.storage, `users/${userId}`);
-    const result = await (0, import_storage2.listAll)(userRef);
-    const files = await Promise.all(
-      result.items.map(async (item) => {
-        const metadata = await (0, import_storage2.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
-var import_storage3 = require("firebase/storage");
-async function uploadFile(storage2, path, file) {
-  const storageRef = (0, import_storage3.ref)(storage2, path);
-  await (0, import_storage3.uploadBytes)(storageRef, file);
-  const url = await (0, import_storage3.getDownloadURL)(storageRef);
-  return { url, path };
-}
-async function uploadBase64(storage2, path, base64, mimeType = "image/jpeg") {
-  const storageRef = (0, import_storage3.ref)(storage2, path);
-  const dataUrl = base64.startsWith("data:") ? base64 : `data:${mimeType};base64,${base64}`;
-  await (0, import_storage3.uploadString)(storageRef, dataUrl, "data_url");
-  const url = await (0, import_storage3.getDownloadURL)(storageRef);
-  return { url, path };
-}
-async function deleteFile(storage2, path) {
-  await (0, import_storage3.deleteObject)((0, import_storage3.ref)(storage2, path));
-}
-
-// src/presentation/hooks/useFirebaseAuth.ts
-var import_react = require("react");
-var import_auth12 = require("firebase/auth");
-function mapUser(u) {
-  return {
-    uid: u.uid,
-    email: u.email,
-    displayName: u.displayName,
-    photoURL: u.photoURL,
-    emailVerified: u.emailVerified
-  };
-}
-function useFirebaseAuth(auth2, options) {
-  const [user, setUser] = (0, import_react.useState)(null);
-  const [loading, setLoading] = (0, import_react.useState)(true);
-  (0, import_react.useEffect)(() => {
-    const unsub = (0, import_auth12.onAuthStateChanged)(auth2, (firebaseUser) => {
-      const mapped = firebaseUser ? mapUser(firebaseUser) : null;
-      setUser(mapped);
-      setLoading(false);
-      options?.onUserChange?.(mapped);
-    });
-    return unsub;
-  }, [auth2, options]);
-  const signIn = (0, import_react.useCallback)(
-    (email, password) => (0, import_auth12.signInWithEmailAndPassword)(auth2, email, password),
-    [auth2]
-  );
-  const signUp = (0, import_react.useCallback)(
-    async (email, password, name) => {
-      const cred = await (0, import_auth12.createUserWithEmailAndPassword)(auth2, email, password);
-      if (name && cred.user) await (0, import_auth12.updateProfile)(cred.user, { displayName: name });
-      return cred;
-    },
-    [auth2]
-  );
-  const signOut = (0, import_react.useCallback)(() => (0, import_auth12.signOut)(auth2), [auth2]);
-  const updateUserProfile = (0, import_react.useCallback)(
-    async (name, photoURL) => {
-      if (!auth2.currentUser) throw new Error("No authenticated user");
-      await (0, import_auth12.updateProfile)(auth2.currentUser, {
-        displayName: name,
-        ...photoURL !== void 0 && { photoURL }
-      });
-    },
-    [auth2]
-  );
-  const updateUserPassword = (0, import_react.useCallback)(
-    async (newPassword) => {
-      if (!auth2.currentUser) throw new Error("No authenticated user");
-      await (0, import_auth12.updatePassword)(auth2.currentUser, newPassword);
-    },
-    [auth2]
-  );
-  const resetPassword = (0, import_react.useCallback)(
-    (email) => (0, import_auth12.sendPasswordResetEmail)(auth2, email),
-    [auth2]
-  );
-  const getIdToken = (0, import_react.useCallback)(async () => {
-    if (!auth2.currentUser) throw new Error("No authenticated user");
-    return auth2.currentUser.getIdToken();
-  }, [auth2]);
-  return {
-    user,
-    loading,
-    isAuthenticated: !!user,
-    signIn,
-    signUp,
-    signOut,
-    updateUserProfile,
-    updateUserPassword,
-    resetPassword,
-    getIdToken
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AuthAdapter,
-  AuthError,
-  AuthErrorCode,
-  DeleteAccountUseCase,
-  Email,
-  FileErrorCode,
-  FilePath,
-  FirestoreAdapter,
-  RepositoryError,
-  RepositoryErrorCode,
-  ResetPasswordUseCase,
-  SignInUseCase,
-  SignInWithGoogleUseCase,
-  SignOutUseCase,
-  SignUpUseCase,
-  StorageAdapter,
-  Timestamp,
-  USER_COLLECTIONS,
-  USER_SUBCOLLECTIONS,
-  UpdateProfileUseCase,
-  UserId,
-  analytics,
-  app,
-  auth,
-  createAuthError,
-  createRepositoryError,
-  db,
-  deleteFile,
-  functions,
-  getFirebaseAnalytics,
-  getFirebaseApp,
-  getFirebaseAuth,
-  getFirebaseDB,
-  getFirebaseFunctions,
-  getFirebaseInstances,
-  getFirebaseStorage,
-  initializeFirebase,
-  serverTimestamp,
-  storage,
-  uploadBase64,
-  uploadFile,
-  useFirebaseAuth
-});