@digilogiclabs/saas-factory-auth 0.2.0 → 0.3.2

package/dist/index.js

@@ -1,148 +1,1890 @@
 'use strict';
 
+var supabaseJs = require('@supabase/supabase-js');
+var app = require('firebase/app');
+var auth = require('firebase/auth');
 var react = require('react');
 var zustand = require('zustand');
-var authHelpersNextjs = require('@supabase/auth-helpers-nextjs');
 var jsxRuntime = require('react/jsx-runtime');
+var authHelpersNextjs = require('@supabase/auth-helpers-nextjs');
+var navigation = require('next/navigation');
+var server = require('next/server');
+var headers = require('next/headers');
 
-var createClient = () => {
-  if (!process.env.NEXT_PUBLIC_SUPABASE_URL || !process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY) {
-    throw new Error("Missing Supabase environment variables");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  NativeAuthStorage: () => exports.NativeAuthStorage,
+  WebAuthStorage: () => exports.WebAuthStorage,
+  createAuthStorage: () => exports.createAuthStorage
+});
+exports.WebAuthStorage = void 0; exports.NativeAuthStorage = void 0; exports.createAuthStorage = void 0;
+var init_storage = __esm({
+  "src/config/storage.ts"() {
+    exports.WebAuthStorage = class {
+      async getItem(key) {
+        if (typeof window === "undefined") return null;
+        return localStorage.getItem(key);
+      }
+      async setItem(key, value) {
+        if (typeof window === "undefined") return;
+        localStorage.setItem(key, value);
+      }
+      async removeItem(key) {
+        if (typeof window === "undefined") return;
+        localStorage.removeItem(key);
+      }
+    };
+    exports.NativeAuthStorage = class {
+      constructor() {
+        try {
+          this.AsyncStorage = __require("@react-native-async-storage/async-storage").default;
+        } catch (error) {
+          throw new Error("AsyncStorage is required for React Native. Install @react-native-async-storage/async-storage");
+        }
+      }
+      async getItem(key) {
+        return await this.AsyncStorage.getItem(key);
+      }
+      async setItem(key, value) {
+        await this.AsyncStorage.setItem(key, value);
+      }
+      async removeItem(key) {
+        await this.AsyncStorage.removeItem(key);
+      }
+    };
+    exports.createAuthStorage = () => {
+      const isReactNative2 = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+      if (isReactNative2) {
+        return new exports.NativeAuthStorage();
+      } else {
+        return new exports.WebAuthStorage();
+      }
+    };
+  }
+});
+
+// src/core/IAuthProvider.ts
+var AuthErrorType = /* @__PURE__ */ ((AuthErrorType2) => {
+  AuthErrorType2["INVALID_CREDENTIALS"] = "INVALID_CREDENTIALS";
+  AuthErrorType2["USER_NOT_FOUND"] = "USER_NOT_FOUND";
+  AuthErrorType2["EMAIL_ALREADY_EXISTS"] = "EMAIL_ALREADY_EXISTS";
+  AuthErrorType2["WEAK_PASSWORD"] = "WEAK_PASSWORD";
+  AuthErrorType2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  AuthErrorType2["PROVIDER_ERROR"] = "PROVIDER_ERROR";
+  AuthErrorType2["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
+  AuthErrorType2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  return AuthErrorType2;
+})(AuthErrorType || {});
+var AuthError = class _AuthError extends Error {
+  constructor(type, message, originalError, context) {
+    super(message);
+    this.type = type;
+    this.originalError = originalError;
+    this.context = context;
+    this.name = "AuthError";
+    this.timestamp = /* @__PURE__ */ new Date();
+    this.code = type;
+    Object.setPrototypeOf(this, _AuthError.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AuthError);
+    }
+  }
+  /**
+   * Convert error to JSON for logging/debugging
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      type: this.type,
+      code: this.code,
+      message: this.message,
+      timestamp: this.timestamp.toISOString(),
+      context: this.context,
+      originalError: this.originalError ? {
+        name: this.originalError.name,
+        message: this.originalError.message,
+        code: this.originalError.code
+      } : undefined
+    };
+  }
+  /**
+   * Check if error is of a specific type
+   */
+  isType(type) {
+    return this.type === type;
+  }
+  /**
+   * Check if error is retryable
+   */
+  isRetryable() {
+    return [
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "PROVIDER_ERROR" /* PROVIDER_ERROR */
+    ].includes(this.type);
+  }
+};
+var AuthEvent = /* @__PURE__ */ ((AuthEvent2) => {
+  AuthEvent2["SIGNED_IN"] = "SIGNED_IN";
+  AuthEvent2["SIGNED_OUT"] = "SIGNED_OUT";
+  AuthEvent2["TOKEN_REFRESHED"] = "TOKEN_REFRESHED";
+  AuthEvent2["USER_UPDATED"] = "USER_UPDATED";
+  return AuthEvent2;
+})(AuthEvent || {});
+
+// src/config/env.ts
+var isNextJS = typeof window !== "undefined" && typeof process !== "undefined";
+var isExpo = typeof global !== "undefined" && global.__expo;
+var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var getAuthConfig = () => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  let config = {};
+  if (isNextJS) {
+    config = {
+      supabaseUrl: process.env.NEXT_PUBLIC_SUPABASE_URL,
+      supabaseAnonKey: process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY,
+      firebaseApiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY,
+      firebaseAuthDomain: process.env.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN,
+      firebaseProjectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID,
+      redirectUrl: process.env.NEXT_PUBLIC_AUTH_REDIRECT_URL
+    };
+  } else if (isExpo) {
+    try {
+      const Constants = __require("expo-constants").default;
+      config = {
+        supabaseUrl: (_b = (_a = Constants.expoConfig) == null ? void 0 : _a.extra) == null ? void 0 : _b.supabaseUrl,
+        supabaseAnonKey: (_d = (_c = Constants.expoConfig) == null ? void 0 : _c.extra) == null ? void 0 : _d.supabaseAnonKey,
+        firebaseApiKey: (_f = (_e = Constants.expoConfig) == null ? void 0 : _e.extra) == null ? void 0 : _f.firebaseApiKey,
+        firebaseAuthDomain: (_h = (_g = Constants.expoConfig) == null ? void 0 : _g.extra) == null ? void 0 : _h.firebaseAuthDomain,
+        firebaseProjectId: (_j = (_i = Constants.expoConfig) == null ? void 0 : _i.extra) == null ? void 0 : _j.firebaseProjectId,
+        redirectUrl: (_l = (_k = Constants.expoConfig) == null ? void 0 : _k.extra) == null ? void 0 : _l.authRedirectUrl
+      };
+    } catch (error) {
+      console.warn("Expo Constants not available, using empty config");
+    }
+  } else if (isReactNative) {
+    try {
+      const Config = __require("react-native-config").default;
+      config = {
+        supabaseUrl: Config.SUPABASE_URL,
+        supabaseAnonKey: Config.SUPABASE_ANON_KEY,
+        firebaseApiKey: Config.FIREBASE_API_KEY,
+        firebaseAuthDomain: Config.FIREBASE_AUTH_DOMAIN,
+        firebaseProjectId: Config.FIREBASE_PROJECT_ID,
+        redirectUrl: Config.AUTH_REDIRECT_URL
+      };
+    } catch (error) {
+      console.warn("react-native-config not available, using empty config");
+    }
+  }
+  return config;
+};
+var validateConfig = (config, provider) => {
+  if (provider === "supabase") {
+    if (!config.supabaseUrl || !config.supabaseAnonKey) {
+      throw new Error(`Missing required Supabase configuration. Required: SUPABASE_URL, SUPABASE_ANON_KEY`);
+    }
+  } else if (provider === "firebase") {
+    if (!config.firebaseApiKey || !config.firebaseAuthDomain || !config.firebaseProjectId) {
+      throw new Error(`Missing required Firebase configuration. Required: FIREBASE_API_KEY, FIREBASE_AUTH_DOMAIN, FIREBASE_PROJECT_ID`);
+    }
+  }
+};
+
+// src/core/SupabaseAuthProvider.ts
+var mapSupabaseUserToCommonUser = (supabaseUser) => {
+  var _a, _b, _c;
+  if (!supabaseUser) return null;
+  return {
+    id: supabaseUser.id,
+    email: supabaseUser.email,
+    displayName: ((_a = supabaseUser.user_metadata) == null ? undefined : _a.full_name) || ((_b = supabaseUser.user_metadata) == null ? undefined : _b.name) || null,
+    photoURL: ((_c = supabaseUser.user_metadata) == null ? undefined : _c.avatar_url) || null,
+    metadata: supabaseUser.user_metadata || {}
+  };
+};
+var mapSupabaseError = (error) => {
+  const message = error.message || "Unknown error occurred";
+  if (message.includes("Invalid login credentials")) {
+    return new AuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, message, error);
+  }
+  if (message.includes("User not found")) {
+    return new AuthError("USER_NOT_FOUND" /* USER_NOT_FOUND */, message, error);
+  }
+  if (message.includes("User already registered")) {
+    return new AuthError("EMAIL_ALREADY_EXISTS" /* EMAIL_ALREADY_EXISTS */, message, error);
+  }
+  if (message.includes("Password should be")) {
+    return new AuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, message, error);
+  }
+  if (message.includes("network") || message.includes("fetch")) {
+    return new AuthError("NETWORK_ERROR" /* NETWORK_ERROR */, message, error);
+  }
+  return new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, message, error);
+};
+var validateEmail = (email) => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    throw new AuthError("VALIDATION_ERROR" /* VALIDATION_ERROR */, "Invalid email format");
+  }
+};
+var SupabaseAuthProvider = class {
+  constructor(storage) {
+    this.storage = storage;
+    const config = getAuthConfig();
+    validateConfig(config, "supabase");
+    this.client = supabaseJs.createClient(config.supabaseUrl, config.supabaseAnonKey, {
+      auth: {
+        storage: {
+          getItem: (key) => this.storage.getItem(key),
+          setItem: (key, value) => this.storage.setItem(key, value),
+          removeItem: (key) => this.storage.removeItem(key)
+        },
+        autoRefreshToken: true,
+        persistSession: true
+      }
+    });
+  }
+  /**
+   * Validates Supabase configuration
+   */
+  async validateConfiguration() {
+    try {
+      const config = getAuthConfig();
+      validateConfig(config, "supabase");
+    } catch (error) {
+      throw new AuthError(
+        "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+        error instanceof Error ? error.message : "Invalid Supabase configuration"
+      );
+    }
+  }
+  async signIn(email, password) {
+    try {
+      validateEmail(email);
+      if (!password) {
+        throw new AuthError(
+          "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          "Password is required for email sign-in with Supabase"
+        );
+      }
+      const { data, error } = await this.client.auth.signInWithPassword({ email, password });
+      if (error) {
+        throw mapSupabaseError(error);
+      }
+      return mapSupabaseUserToCommonUser(data.user);
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, "Sign in failed", error);
+    }
+  }
+  async signUp(email, password) {
+    try {
+      validateEmail(email);
+      if (!password) {
+        throw new AuthError(
+          "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          "Password is required for email sign-up with Supabase"
+        );
+      }
+      const { data, error } = await this.client.auth.signUp({ email, password });
+      if (error) {
+        throw mapSupabaseError(error);
+      }
+      return mapSupabaseUserToCommonUser(data.user);
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, "Sign up failed", error);
+    }
+  }
+  async signInWithOAuth(provider, redirectTo) {
+    try {
+      const { error } = await this.client.auth.signInWithOAuth({
+        provider,
+        options: { redirectTo }
+      });
+      if (error) {
+        throw mapSupabaseError(error);
+      }
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, "OAuth sign in failed", error);
+    }
+  }
+  async signInWithMagicLink(email, redirectTo) {
+    try {
+      validateEmail(email);
+      const { error } = await this.client.auth.signInWithOtp({
+        email,
+        options: { emailRedirectTo: redirectTo }
+      });
+      if (error) {
+        throw mapSupabaseError(error);
+      }
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, "Magic link sign in failed", error);
+    }
+  }
+  async signOut() {
+    try {
+      const { error } = await this.client.auth.signOut();
+      if (error) {
+        throw mapSupabaseError(error);
+      }
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, "Sign out failed", error);
+    }
+  }
+  async resetPassword(email) {
+    try {
+      validateEmail(email);
+      const { error } = await this.client.auth.resetPasswordForEmail(email);
+      if (error) {
+        throw mapSupabaseError(error);
+      }
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, "Password reset failed", error);
+    }
+  }
+  async getUser() {
+    try {
+      const { data: { user }, error } = await this.client.auth.getUser();
+      if (error) {
+        throw mapSupabaseError(error);
+      }
+      return mapSupabaseUserToCommonUser(user);
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, "Get user failed", error);
+    }
+  }
+  onAuthStateChange(callback) {
+    const { data: { subscription } } = this.client.auth.onAuthStateChange((event, session) => {
+      const commonUser = mapSupabaseUserToCommonUser((session == null ? undefined : session.user) || null);
+      let authEvent;
+      switch (event) {
+        case "SIGNED_IN":
+          authEvent = "SIGNED_IN" /* SIGNED_IN */;
+          break;
+        case "SIGNED_OUT":
+          authEvent = "SIGNED_OUT" /* SIGNED_OUT */;
+          break;
+        case "TOKEN_REFRESHED":
+          authEvent = "TOKEN_REFRESHED" /* TOKEN_REFRESHED */;
+          break;
+        case "USER_UPDATED":
+          authEvent = "USER_UPDATED" /* USER_UPDATED */;
+          break;
+        default:
+          authEvent = "USER_UPDATED" /* USER_UPDATED */;
+      }
+      const authSession = commonUser ? {
+        user: commonUser,
+        expiresAt: (session == null ? undefined : session.expires_at) ? session.expires_at * 1e3 : undefined,
+        accessToken: session == null ? undefined : session.access_token
+      } : null;
+      callback(authEvent, authSession);
+    });
+    return { data: { subscription } };
+  }
+};
+var mapFirebaseUserToCommonUser = (firebaseUser) => {
+  var _a, _b;
+  if (!firebaseUser) return null;
+  return {
+    id: firebaseUser.uid,
+    email: firebaseUser.email || undefined,
+    displayName: firebaseUser.displayName,
+    photoURL: firebaseUser.photoURL,
+    metadata: {
+      phoneNumber: firebaseUser.phoneNumber,
+      emailVerified: firebaseUser.emailVerified,
+      isAnonymous: firebaseUser.isAnonymous,
+      tenantId: firebaseUser.tenantId,
+      providerData: firebaseUser.providerData,
+      creationTime: (_a = firebaseUser.metadata) == null ? undefined : _a.creationTime,
+      lastSignInTime: (_b = firebaseUser.metadata) == null ? undefined : _b.lastSignInTime
+    }
+  };
+};
+var mapFirebaseError = (error) => {
+  const code = error.code || "";
+  const message = error.message || "Unknown error occurred";
+  switch (code) {
+    case "auth/invalid-email":
+    case "auth/user-disabled":
+    case "auth/user-not-found":
+    case "auth/wrong-password":
+    case "auth/invalid-credential":
+      return new AuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, message, error);
+    case "auth/email-already-in-use":
+      return new AuthError("EMAIL_ALREADY_EXISTS" /* EMAIL_ALREADY_EXISTS */, message, error);
+    case "auth/weak-password":
+      return new AuthError("WEAK_PASSWORD" /* WEAK_PASSWORD */, message, error);
+    case "auth/network-request-failed":
+    case "auth/timeout":
+      return new AuthError("NETWORK_ERROR" /* NETWORK_ERROR */, message, error);
+    case "auth/configuration-not-found":
+    case "auth/invalid-api-key":
+      return new AuthError("CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */, message, error);
+    default:
+      return new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, message, error);
+  }
+};
+var validateEmail2 = (email) => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    throw new AuthError("VALIDATION_ERROR" /* VALIDATION_ERROR */, "Invalid email format");
+  }
+};
+var getOAuthProvider = (provider) => {
+  switch (provider) {
+    case "google":
+      return new auth.GoogleAuthProvider();
+    case "github":
+      return new auth.GithubAuthProvider();
+    case "facebook":
+      return new auth.FacebookAuthProvider();
+    case "twitter":
+      return new auth.TwitterAuthProvider();
+    case "apple":
+      const appleProvider = new auth.OAuthProvider("apple.com");
+      return appleProvider;
+    case "discord":
+      const discordProvider = new auth.OAuthProvider("discord.com");
+      return discordProvider;
+    default:
+      throw new AuthError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Unsupported OAuth provider for Firebase: ${provider}`
+      );
+  }
+};
+var FirebaseAuthProvider = class {
+  constructor(storage) {
+    this.storage = storage;
+    const config = getAuthConfig();
+    validateConfig(config, "firebase");
+    this.app = app.initializeApp({
+      apiKey: config.firebaseApiKey,
+      authDomain: config.firebaseAuthDomain,
+      projectId: config.firebaseProjectId
+    });
+    this.auth = auth.getAuth(this.app);
+  }
+  /**
+   * Validates Firebase configuration
+   */
+  async validateConfiguration() {
+    try {
+      const config = getAuthConfig();
+      validateConfig(config, "firebase");
+    } catch (error) {
+      throw new AuthError(
+        "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+        error instanceof Error ? error.message : "Invalid Firebase configuration"
+      );
+    }
+  }
+  async signIn(email, password) {
+    try {
+      validateEmail2(email);
+      if (!password) {
+        throw new AuthError(
+          "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          "Password is required for email sign-in with Firebase"
+        );
+      }
+      const userCredential = await auth.signInWithEmailAndPassword(this.auth, email, password);
+      return mapFirebaseUserToCommonUser(userCredential.user);
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw mapFirebaseError(error);
+    }
+  }
+  async signUp(email, password) {
+    try {
+      validateEmail2(email);
+      if (!password) {
+        throw new AuthError(
+          "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          "Password is required for email sign-up with Firebase"
+        );
+      }
+      const userCredential = await auth.createUserWithEmailAndPassword(this.auth, email, password);
+      return mapFirebaseUserToCommonUser(userCredential.user);
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw mapFirebaseError(error);
+    }
+  }
+  async signInWithOAuth(provider, redirectTo) {
+    try {
+      const authProvider = getOAuthProvider(provider);
+      if (redirectTo) {
+        console.warn(
+          "redirectTo is not directly supported for Firebase signInWithPopup. Consider using signInWithRedirect or handling redirects manually."
+        );
+      }
+      await auth.signInWithPopup(this.auth, authProvider);
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw mapFirebaseError(error);
+    }
+  }
+  async signInWithMagicLink(email, redirectTo) {
+    try {
+      validateEmail2(email);
+      if (!redirectTo) {
+        throw new AuthError(
+          "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          "redirectTo is required for Firebase magic link sign-in"
+        );
+      }
+      await auth.sendSignInLinkToEmail(this.auth, email, {
+        url: redirectTo,
+        handleCodeInApp: true
+      });
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw mapFirebaseError(error);
+    }
+  }
+  async signOut() {
+    try {
+      await auth.signOut(this.auth);
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw mapFirebaseError(error);
+    }
+  }
+  async resetPassword(email) {
+    try {
+      validateEmail2(email);
+      await auth.sendPasswordResetEmail(this.auth, email);
+    } catch (error) {
+      if (error instanceof AuthError) {
+        throw error;
+      }
+      throw mapFirebaseError(error);
+    }
+  }
+  async getUser() {
+    return mapFirebaseUserToCommonUser(this.auth.currentUser);
+  }
+  onAuthStateChange(callback) {
+    const unsubscribe = auth.onAuthStateChanged(this.auth, (user) => {
+      const commonUser = mapFirebaseUserToCommonUser(user);
+      let authEvent;
+      if (user) {
+        authEvent = "SIGNED_IN" /* SIGNED_IN */;
+      } else {
+        authEvent = "SIGNED_OUT" /* SIGNED_OUT */;
+      }
+      const authSession = commonUser ? {
+        user: commonUser,
+        // Firebase doesn't provide explicit expiration time in the same way as Supabase
+        // You might need to get this from the ID token if needed
+        expiresAt: undefined,
+        // Explicitly undefined if not available
+        accessToken: undefined
+        // Explicitly undefined if not available
+      } : null;
+      callback(authEvent, authSession);
+    });
+    return { data: { subscription: { unsubscribe } } };
+  }
+};
+
+// src/core/AuthProviderFactory.ts
+init_storage();
+var AuthProviderFactory = class {
+  /**
+   * Gets provider based on environment variables (auto-detection)
+   * @param config Optional configuration overrides
+   * @returns Authentication provider instance
+   */
+  static async getProviderFromEnvironment(config) {
+    const detectedType = this.detectProviderFromEnvironment();
+    return this.getProvider(__spreadValues({
+      type: detectedType,
+      validateConfig: true,
+      useSingleton: true
+    }, config));
+  }
+  /**
+   * Gets provider instance with configuration
+   * @param config Provider configuration
+   * @returns Authentication provider instance
+   */
+  static async getProvider(config) {
+    const { type, validateConfig: validateConfig3 = false, useSingleton = false, storage } = config;
+    if (useSingleton && this.instances.has(type)) {
+      const instance = this.instances.get(type);
+      if (validateConfig3 && instance.validateConfiguration) {
+        await instance.validateConfiguration();
+      }
+      return instance;
+    }
+    const provider = this.createProvider(type, storage);
+    if (validateConfig3 && provider.validateConfiguration) {
+      await provider.validateConfiguration();
+    }
+    if (useSingleton) {
+      this.instances.set(type, provider);
+    }
+    return provider;
+  }
+  /**
+   * Creates a new provider instance without caching
+   * @param type Provider type
+   * @param storage Optional custom storage implementation
+   * @returns Authentication provider instance
+   */
+  static createProvider(type, storage) {
+    const authStorage = storage || exports.createAuthStorage();
+    switch (type) {
+      case "supabase":
+        return new SupabaseAuthProvider(authStorage);
+      case "firebase":
+        return new FirebaseAuthProvider(authStorage);
+      default:
+        throw new AuthError(
+          "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+          `Unsupported authentication provider: ${type}. Supported providers: supabase, firebase`
+        );
+    }
+  }
+  /**
+   * Detects provider type from environment variables
+   * @returns Detected provider type
+   */
+  static detectProviderFromEnvironment() {
+    const config = getAuthConfig();
+    const hasSupabaseConfig = !!(config.supabaseUrl && config.supabaseAnonKey);
+    const hasFirebaseConfig = !!(config.firebaseApiKey && config.firebaseAuthDomain && config.firebaseProjectId);
+    const explicitProvider = this.getExplicitProvider();
+    if (explicitProvider && this.isValidProviderType(explicitProvider)) {
+      return explicitProvider;
+    }
+    if (hasSupabaseConfig && !hasFirebaseConfig) {
+      return "supabase";
+    }
+    if (hasFirebaseConfig && !hasSupabaseConfig) {
+      return "firebase";
+    }
+    if (hasSupabaseConfig && hasFirebaseConfig) {
+      console.warn(
+        "Both Supabase and Firebase configurations detected. Set AUTH_PROVIDER environment variable to explicitly choose a provider. Defaulting to Supabase."
+      );
+      return "supabase";
+    }
+    throw new AuthError(
+      "CONFIGURATION_ERROR" /* CONFIGURATION_ERROR */,
+      "No authentication provider configuration found. Please configure either Supabase or Firebase environment variables."
+    );
+  }
+  /**
+   * Gets explicit provider from environment variables (platform-agnostic)
+   */
+  static getExplicitProvider() {
+    var _a, _b;
+    if (typeof process !== "undefined" && process.env) {
+      return process.env.NEXT_PUBLIC_AUTH_PROVIDER || process.env.AUTH_PROVIDER;
+    }
+    try {
+      const Constants = __require("expo-constants").default;
+      return (_b = (_a = Constants.expoConfig) == null ? void 0 : _a.extra) == null ? void 0 : _b.authProvider;
+    } catch (error) {
+    }
+    try {
+      const Config = __require("react-native-config").default;
+      return Config.AUTH_PROVIDER;
+    } catch (error) {
+    }
+    return undefined;
+  }
+  /**
+   * Validates if a string is a valid provider type
+   * @param type String to validate
+   * @returns True if valid provider type
+   */
+  static isValidProviderType(type) {
+    return type === "supabase" || type === "firebase";
+  }
+  /**
+   * Gets list of supported provider types
+   * @returns Array of supported provider types
+   */
+  static getSupportedProviders() {
+    return ["supabase", "firebase"];
+  }
+  /**
+   * Checks if a provider type is supported
+   * @param type Provider type to check
+   * @returns True if supported
+   */
+  static isProviderSupported(type) {
+    return this.isValidProviderType(type);
+  }
+  /**
+   * Clears singleton instances (useful for testing)
+   */
+  static clearInstances() {
+    this.instances.clear();
+  }
+  /**
+   * Gets current singleton instances (useful for debugging)
+   * @returns Map of current instances
+   */
+  static getInstances() {
+    return new Map(this.instances);
   }
-  return authHelpersNextjs.createClientComponentClient();
 };
-var supabase = createClient();
+AuthProviderFactory.instances = /* @__PURE__ */ new Map();
 
-// src/store/authStore.ts
-var useAuthStore = zustand.create((set) => ({
+// src/index.ts
+init_storage();
+init_storage();
+var createAuthStore = ({ authProvider }) => zustand.create((set) => ({
   user: null,
   loading: true,
   error: null,
+  updateUser: (user) => set({ user }),
+  setLoading: (loading) => set({ loading }),
+  setError: (error) => set({ error }),
   signIn: async (email, password) => {
+    set({ loading: true, error: null });
     try {
-      set({ loading: true, error: null });
-      const { error } = await supabase.auth.signInWithPassword({
-        email,
-        password
-      });
-      if (error) throw error;
+      const user = await authProvider.signIn(email, password);
+      set({ user, loading: false });
     } catch (error) {
-      set({ error });
-    } finally {
-      set({ loading: false });
+      set({ error, loading: false });
+      throw error;
     }
   },
   signUp: async (email, password) => {
+    set({ loading: true, error: null });
     try {
-      set({ loading: true, error: null });
-      const { error } = await supabase.auth.signUp({
-        email,
-        password
-      });
-      if (error) throw error;
+      const user = await authProvider.signUp(email, password);
+      set({ user, loading: false });
     } catch (error) {
-      set({ error });
-    } finally {
-      set({ loading: false });
+      set({ error, loading: false });
+      throw error;
     }
   },
-  signOut: async () => {
+  signInWithOAuth: async (provider, redirectTo) => {
+    set({ loading: true, error: null });
     try {
-      set({ loading: true, error: null });
-      const { error } = await supabase.auth.signOut();
-      if (error) throw error;
-      set({ user: null });
-    } catch (error) {
-      set({ error });
-    } finally {
+      await authProvider.signInWithOAuth(provider, redirectTo);
       set({ loading: false });
+    } catch (error) {
+      set({ error, loading: false });
+      throw error;
     }
   },
-  resetPassword: async (email) => {
+  signInWithMagicLink: async (email, redirectTo) => {
+    set({ loading: true, error: null });
     try {
-      set({ loading: true, error: null });
-      const { error } = await supabase.auth.resetPasswordForEmail(email);
-      if (error) throw error;
-    } catch (error) {
-      set({ error });
-    } finally {
+      await authProvider.signInWithMagicLink(email, redirectTo);
       set({ loading: false });
+    } catch (error) {
+      set({ error, loading: false });
+      throw error;
     }
   },
-  signInWithOAuth: async (provider, redirectTo) => {
+  signOut: async () => {
+    set({ loading: true, error: null });
     try {
-      set({ loading: true, error: null });
-      const { error } = await supabase.auth.signInWithOAuth({
-        provider,
-        options: {
-          redirectTo
-        }
-      });
-      if (error) throw error;
+      await authProvider.signOut();
+      set({ user: null, loading: false });
     } catch (error) {
-      set({ error });
-    } finally {
+      set({ error, loading: false });
+      throw error;
+    }
+  },
+  resetPassword: async (email) => {
+    set({ loading: true, error: null });
+    try {
+      await authProvider.resetPassword(email);
       set({ loading: false });
+    } catch (error) {
+      set({ error, loading: false });
+      throw error;
     }
   },
-  signInWithMagicLink: async (email, redirectTo) => {
+  getUser: async () => {
     try {
-      set({ loading: true, error: null });
-      const { error } = await supabase.auth.signInWithOtp({
-        email,
-        options: {
-          emailRedirectTo: redirectTo
-        }
-      });
-      if (error) throw error;
+      return await authProvider.getUser();
     } catch (error) {
       set({ error });
-    } finally {
-      set({ loading: false });
+      throw error;
     }
   },
-  updateUser: (user) => set({ user }),
-  setLoading: (loading) => set({ loading }),
-  setError: (error) => set({ error })
+  onAuthStateChange: (callback) => {
+    return authProvider.onAuthStateChange(callback);
+  }
 }));
+var AuthContext = react.createContext(null);
+var AuthProvider = ({ children, providerType = "supabase", storage }) => {
+  const [authProvider, setAuthProvider] = react.useState(null);
+  const [useAuthStore, setUseAuthStore] = react.useState(null);
+  react.useEffect(() => {
+    const initializeProvider = async () => {
+      try {
+        const authStorage = storage || exports.createAuthStorage();
+        const provider = await AuthProviderFactory.getProvider({
+          type: providerType,
+          validateConfig: true,
+          useSingleton: true,
+          storage: authStorage
+        });
+        setAuthProvider(provider);
+        setUseAuthStore(createAuthStore({ authProvider: provider }));
+      } catch (error) {
+        console.error("Failed to initialize auth provider:", error);
+      }
+    };
+    initializeProvider();
+  }, [providerType, storage]);
+  react.useEffect(() => {
+    if (!authProvider || !useAuthStore) return;
+    const subscriptionResult = authProvider.onAuthStateChange((event, session) => {
+      useAuthStore.getState().updateUser((session == null ? undefined : session.user) || null);
+      useAuthStore.getState().setLoading(false);
+    });
+    let unsubscribe;
+    if ("data" in subscriptionResult && subscriptionResult.data && "subscription" in subscriptionResult.data && typeof subscriptionResult.data.subscription === "object" && subscriptionResult.data.subscription !== null && "unsubscribe" in subscriptionResult.data.subscription && typeof subscriptionResult.data.subscription.unsubscribe === "function") {
+      unsubscribe = subscriptionResult.data.subscription.unsubscribe;
+    } else if ("data" in subscriptionResult && subscriptionResult.data && "unsubscribe" in subscriptionResult.data && typeof subscriptionResult.data.unsubscribe === "function") {
+      unsubscribe = subscriptionResult.data.unsubscribe;
+    } else if ("unsubscribe" in subscriptionResult && typeof subscriptionResult.unsubscribe === "function") {
+      unsubscribe = subscriptionResult.unsubscribe;
+    }
+    authProvider.getUser().then((user) => {
+      useAuthStore.getState().updateUser(user);
+      useAuthStore.getState().setLoading(false);
+    }).catch((error) => {
+      console.error("Failed to get initial user:", error);
+      useAuthStore.getState().setLoading(false);
+    });
+    return () => {
+      if (unsubscribe) {
+        unsubscribe();
+      }
+    };
+  }, [authProvider, useAuthStore]);
+  if (!useAuthStore) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { children: "Loading authentication..." });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(AuthContext.Provider, { value: useAuthStore.getState(), children });
+};
 
 // src/hooks/useAuth.ts
 var useAuth = () => {
-  const store = useAuthStore();
+  const store = react.useContext(AuthContext);
+  if (!store) {
+    throw new Error("useAuth must be used within an AuthProvider");
+  }
+  react.useEffect(() => {
+    return () => {
+    };
+  }, [store]);
+  return __spreadValues({}, store);
+};
+var useAuthForm = (options = {}) => {
+  const auth = react.useContext(AuthContext);
+  const [email, setEmail] = react.useState("");
+  const [password, setPassword] = react.useState("");
+  const [confirmPassword, setConfirmPassword] = react.useState("");
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [message, setMessage] = react.useState(null);
+  if (!auth) {
+    throw new Error("useAuthForm must be used within AuthProvider");
+  }
+  const clearError = () => setError(null);
+  const clearMessage = () => setMessage(null);
+  const handleSignIn = async () => {
+    var _a, _b;
+    setLoading(true);
+    setError(null);
+    setMessage(null);
+    try {
+      await auth.signIn(email, password);
+      (_a = options.onSuccess) == null ? void 0 : _a.call(options);
+    } catch (err) {
+      const authError = err instanceof AuthError ? err : new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, err.message);
+      setError(authError.message);
+      (_b = options.onError) == null ? undefined : _b.call(options, authError);
+    } finally {
+      setLoading(false);
+    }
+  };
+  const handleSignUp = async () => {
+    var _a, _b;
+    if (password !== confirmPassword) {
+      setError("Passwords do not match");
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    setMessage(null);
+    try {
+      await auth.signUp(email, password);
+      setMessage("Check your email to confirm your account");
+      (_a = options.onSuccess) == null ? void 0 : _a.call(options);
+    } catch (err) {
+      const authError = err instanceof AuthError ? err : new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, err.message);
+      setError(authError.message);
+      (_b = options.onError) == null ? undefined : _b.call(options, authError);
+    } finally {
+      setLoading(false);
+    }
+  };
+  const handleOAuthSignIn = async (provider) => {
+    var _a, _b;
+    setLoading(true);
+    setError(null);
+    try {
+      await auth.signInWithOAuth(provider, options.redirectUrl);
+      (_a = options.onSuccess) == null ? void 0 : _a.call(options);
+    } catch (err) {
+      const authError = err instanceof AuthError ? err : new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, err.message);
+      setError(authError.message);
+      (_b = options.onError) == null ? undefined : _b.call(options, authError);
+    } finally {
+      setLoading(false);
+    }
+  };
+  const handlePasswordReset = async () => {
+    var _a;
+    if (!email) {
+      setError("Please enter your email address");
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    setMessage(null);
+    try {
+      await auth.resetPassword(email);
+      setMessage("Password reset email sent");
+    } catch (err) {
+      const authError = err instanceof AuthError ? err : new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, err.message);
+      setError(authError.message);
+      (_a = options.onError) == null ? undefined : _a.call(options, authError);
+    } finally {
+      setLoading(false);
+    }
+  };
+  const handleMagicLink = async () => {
+    var _a;
+    if (!email) {
+      setError("Please enter your email address");
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    setMessage(null);
+    try {
+      await auth.signInWithMagicLink(email, options.redirectUrl);
+      setMessage("Magic link sent to your email");
+    } catch (err) {
+      const authError = err instanceof AuthError ? err : new AuthError("PROVIDER_ERROR" /* PROVIDER_ERROR */, err.message);
+      setError(authError.message);
+      (_a = options.onError) == null ? undefined : _a.call(options, authError);
+    } finally {
+      setLoading(false);
+    }
+  };
+  return {
+    // State
+    email,
+    password,
+    confirmPassword,
+    loading,
+    error,
+    message,
+    // Actions
+    setEmail,
+    setPassword,
+    setConfirmPassword,
+    handleSignIn,
+    handleSignUp,
+    handleOAuthSignIn,
+    handlePasswordReset,
+    handleMagicLink,
+    clearError,
+    clearMessage
+  };
+};
+var useProtectedRoute = (options = {}) => {
+  const auth = react.useContext(AuthContext);
   react.useEffect(() => {
-    supabase.auth.getSession().then(({ data: { session } }) => {
+    if (!auth || auth.loading) return;
+    const checkAuth = async () => {
+      var _a, _b;
+      const user = await auth.getUser();
+      if (!user) {
+        (_a = options.onUnauthenticated) == null ? undefined : _a.call(options);
+        return;
+      }
+      if (options.requiredRoles && options.requiredRoles.length > 0) {
+        const userRoles = user.roles || [];
+        const hasRequiredRole = options.requiredRoles.some((role) => userRoles.includes(role));
+        if (!hasRequiredRole) {
+          (_b = options.onUnauthorized) == null ? undefined : _b.call(options);
+          return;
+        }
+      }
+    };
+    checkAuth();
+    const unsubscribe = auth.onAuthStateChange((event, session) => {
       var _a;
-      store.updateUser((_a = session == null ? undefined : session.user) != null ? _a : null);
-      store.setLoading(false);
+      if (!(session == null ? undefined : session.user)) {
+        (_a = options.onUnauthenticated) == null ? undefined : _a.call(options);
+      }
     });
+    return () => {
+      var _a, _b;
+      if (typeof unsubscribe === "function") {
+        unsubscribe();
+      } else if (unsubscribe && "data" in unsubscribe && ((_b = (_a = unsubscribe.data) == null ? undefined : _a.subscription) == null ? undefined : _b.unsubscribe)) {
+        unsubscribe.data.subscription.unsubscribe();
+      }
+    };
+  }, [auth, options]);
+  return {
+    user: auth == null ? undefined : auth.user,
+    loading: auth == null ? undefined : auth.loading,
+    isAuthenticated: !!(auth == null ? undefined : auth.user)
+  };
+};
+function useRBAC() {
+  const auth = react.useContext(AuthContext);
+  if (!auth) throw new Error("AuthContext not provided");
+  const { user } = auth;
+  const checkPermission = (permission) => {
+    var _a, _b, _c;
+    const userRole = (_a = user == null ? undefined : user.metadata) == null ? undefined : _a.role;
+    return (_c = (_b = userRole == null ? undefined : userRole.permissions) == null ? undefined : _b.includes(permission)) != null ? _c : false;
+  };
+  const hasRole = (role) => {
+    var _a;
+    const userRole = (_a = user == null ? undefined : user.metadata) == null ? undefined : _a.role;
+    return (userRole == null ? undefined : userRole.role) === role;
+  };
+  return {
+    checkPermission,
+    hasRole
+  };
+}
+var createClient2 = () => {
+  if (!process.env.NEXT_PUBLIC_SUPABASE_URL || !process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY) {
+    throw new Error("Missing Supabase environment variables");
+  }
+  return authHelpersNextjs.createClientComponentClient();
+};
+var supabase = (() => {
+  try {
+    if (process.env.NEXT_PUBLIC_SUPABASE_URL && process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY) {
+      return createClient2();
+    }
+  } catch (error) {
+    console.warn("Supabase client not initialized: environment variables not available");
+  }
+  return null;
+})();
+
+// src/hooks/use2FA.ts
+function use2FA() {
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const setup2FA = async () => {
+    if (!supabase) {
+      throw new Error("Supabase client not initialized. Please check your environment variables.");
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const { data, error: error2 } = await supabase.auth.mfa.enroll({
+        factorType: "totp"
+      });
+      if (error2) throw error2;
+      return data;
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  };
+  const verify2FA = async (factorId, challengeId, code) => {
+    if (!supabase) {
+      throw new Error("Supabase client not initialized. Please check your environment variables.");
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const { data, error: error2 } = await supabase.auth.mfa.verify({
+        factorId,
+        challengeId,
+        code
+      });
+      if (error2) throw error2;
+      return data;
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  };
+  const unenroll2FA = async (factorId) => {
+    if (!supabase) {
+      throw new Error("Supabase client not initialized. Please check your environment variables.");
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const { data, error: error2 } = await supabase.auth.mfa.unenroll({
+        factorId
+      });
+      if (error2) throw error2;
+      return data;
+    } catch (err) {
+      const error2 = err;
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  };
+  return {
+    setup2FA,
+    verify2FA,
+    unenroll2FA,
+    loading,
+    error
+  };
+}
+function useRedirectUrl(defaultUrl = "/dashboard") {
+  const searchParams = navigation.useSearchParams();
+  return (searchParams == null ? undefined : searchParams.get("returnUrl")) || defaultUrl;
+}
+
+// src/utils/authConfig.ts
+var defaultAuthConfig = {
+  passwordRequirements: {
+    minLength: 8,
+    requireNumbers: true,
+    requireSpecialChars: true,
+    requireUppercase: true
+  },
+  maxLoginAttempts: 5,
+  lockoutDuration: 15,
+  // 15 minutes
+  jwtExpiryTime: 3600,
+  // 1 hour
+  require2FA: false
+};
+
+// src/utils/password.ts
+function validatePassword(password, config) {
+  if (!config) return true;
+  const { minLength, requireNumbers, requireSpecialChars, requireUppercase } = config;
+  if (password.length < minLength) {
+    throw new Error(`Password must be at least ${minLength} characters long`);
+  }
+  if (requireNumbers && !/\d/.test(password)) {
+    throw new Error("Password must contain at least one number");
+  }
+  if (requireSpecialChars && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
+    throw new Error("Password must contain at least one special character");
+  }
+  if (requireUppercase && !/[A-Z]/.test(password)) {
+    throw new Error("Password must contain at least one uppercase letter");
+  }
+  return true;
+}
+
+// src/utils/validation.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var ValidationUtils = class {
+  /**
+   * Validate email address format
+   */
+  static validateEmail(email) {
+    if (!email || typeof email !== "string") {
+      throw new AuthError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        "Email is required and must be a string",
+        null,
+        { field: "email", value: email }
+      );
+    }
+    if (!EMAIL_REGEX.test(email.trim())) {
+      throw new AuthError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        "Invalid email format",
+        null,
+        { field: "email", value: email }
+      );
+    }
+  }
+  /**
+   * Validate password strength
+   */
+  static validatePassword(password, requirements) {
+    if (!password || typeof password !== "string") {
+      throw new AuthError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        "Password is required and must be a string",
+        null,
+        { field: "password" }
+      );
+    }
     const {
-      data: { subscription }
-    } = supabase.auth.onAuthStateChange((_event, session) => {
-      var _a;
-      store.updateUser((_a = session == null ? undefined : session.user) != null ? _a : null);
-    });
-    return () => subscription.unsubscribe();
-  }, []);
-  return store;
+      minLength = 8,
+      requireNumbers = true,
+      requireSpecialChars = true,
+      requireUppercase = true
+    } = requirements || {};
+    if (password.length < minLength) {
+      throw new AuthError(
+        "WEAK_PASSWORD" /* WEAK_PASSWORD */,
+        `Password must be at least ${minLength} characters long`,
+        null,
+        { field: "password", requirement: "minLength", expected: minLength, actual: password.length }
+      );
+    }
+    if (requireNumbers && !/\d/.test(password)) {
+      throw new AuthError(
+        "WEAK_PASSWORD" /* WEAK_PASSWORD */,
+        "Password must contain at least one number",
+        null,
+        { field: "password", requirement: "numbers" }
+      );
+    }
+    if (requireSpecialChars && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
+      throw new AuthError(
+        "WEAK_PASSWORD" /* WEAK_PASSWORD */,
+        "Password must contain at least one special character",
+        null,
+        { field: "password", requirement: "specialChars" }
+      );
+    }
+    if (requireUppercase && !/[A-Z]/.test(password)) {
+      throw new AuthError(
+        "WEAK_PASSWORD" /* WEAK_PASSWORD */,
+        "Password must contain at least one uppercase letter",
+        null,
+        { field: "password", requirement: "uppercase" }
+      );
+    }
+  }
+  /**
+   * Validate OAuth provider
+   */
+  static validateOAuthProvider(provider) {
+    if (!provider || typeof provider !== "string") {
+      throw new AuthError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        "OAuth provider is required and must be a string",
+        null,
+        { field: "provider", value: provider }
+      );
+    }
+    const validProviders = ["google", "github", "apple", "facebook", "twitter", "discord"];
+    if (!validProviders.includes(provider.toLowerCase())) {
+      throw new AuthError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Invalid OAuth provider: ${provider}. Supported providers: ${validProviders.join(", ")}`,
+        null,
+        { field: "provider", value: provider, validProviders }
+      );
+    }
+  }
+  /**
+   * Validate URL format
+   */
+  static validateUrl(url, fieldName = "url") {
+    if (!url || typeof url !== "string") {
+      throw new AuthError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `${fieldName} is required and must be a string`,
+        null,
+        { field: fieldName, value: url }
+      );
+    }
+    try {
+      new URL(url);
+    } catch (error) {
+      throw new AuthError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `Invalid ${fieldName} format`,
+        error,
+        { field: fieldName, value: url }
+      );
+    }
+  }
+  /**
+   * Validate required string field
+   */
+  static validateRequiredString(value, fieldName) {
+    if (!value || typeof value !== "string" || value.trim().length === 0) {
+      throw new AuthError(
+        "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+        `${fieldName} is required and must be a non-empty string`,
+        null,
+        { field: fieldName, value }
+      );
+    }
+  }
+  /**
+   * Sanitize email input
+   */
+  static sanitizeEmail(email) {
+    return (email == null ? undefined : email.trim().toLowerCase()) || "";
+  }
+  /**
+   * Check if error is a validation error
+   */
+  static isValidationError(error) {
+    return error instanceof AuthError && (error.type === "VALIDATION_ERROR" /* VALIDATION_ERROR */ || error.type === "WEAK_PASSWORD" /* WEAK_PASSWORD */);
+  }
 };
-var AuthContext = react.createContext(null);
-var AuthProvider = ({ children }) => {
-  const auth = useAuth();
-  return /* @__PURE__ */ jsxRuntime.jsx(AuthContext.Provider, { value: auth, children });
+function validateParams(validations) {
+  return function(target, propertyName, descriptor) {
+    const method = descriptor.value;
+    descriptor.value = function(...args) {
+      const paramNames = getParameterNames(method);
+      paramNames.forEach((paramName, index) => {
+        if (validations[paramName] && args[index] !== undefined) {
+          validations[paramName](args[index]);
+        }
+      });
+      return method.apply(this, args);
+    };
+  };
+}
+function getParameterNames(func) {
+  const funcStr = func.toString();
+  const match = funcStr.match(/\(([^)]*)\)/);
+  if (!match) return [];
+  return match[1].split(",").map((param) => param.trim().split(/\s+/)[0]).filter((param) => param.length > 0);
+}
+
+// src/utils/performance.ts
+function memoize(fn, keyGenerator) {
+  const cache = /* @__PURE__ */ new Map();
+  return (...args) => {
+    const key = keyGenerator ? keyGenerator(...args) : JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  };
+}
+function debounce(fn, delay) {
+  let timeoutId;
+  return (...args) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn(...args), delay);
+  };
+}
+function throttle(fn, limit) {
+  let inThrottle;
+  return (...args) => {
+    if (!inThrottle) {
+      fn(...args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, limit);
+    }
+  };
+}
+async function retryWithBackoff(fn, maxRetries = 3, baseDelay = 1e3, maxDelay = 1e4) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxRetries) {
+        throw lastError;
+      }
+      const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+}
+var LRUCache = class {
+  constructor(maxSize = 100) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    if (this.cache.has(key)) {
+      const value = this.cache.get(key);
+      this.cache.delete(key);
+      this.cache.set(key, value);
+      return value;
+    }
+    return undefined;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+};
+var PerformanceMonitor = class {
+  static start(label) {
+    this.timers.set(label, performance.now());
+  }
+  static end(label) {
+    const startTime = this.timers.get(label);
+    if (!startTime) {
+      console.warn(`Performance timer '${label}' was not started`);
+      return 0;
+    }
+    const duration = performance.now() - startTime;
+    this.timers.delete(label);
+    return duration;
+  }
+  static measure(label, fn) {
+    this.start(label);
+    try {
+      const result = fn();
+      return result;
+    } finally {
+      const duration = this.end(label);
+      console.debug(`${label} took ${duration.toFixed(2)}ms`);
+    }
+  }
+  static async measureAsync(label, fn) {
+    this.start(label);
+    try {
+      const result = await fn();
+      return result;
+    } finally {
+      const duration = this.end(label);
+      console.debug(`${label} took ${duration.toFixed(2)}ms`);
+    }
+  }
+};
+PerformanceMonitor.timers = /* @__PURE__ */ new Map();
+
+// src/utils/healthCheck.ts
+var HealthChecker = class {
+  /**
+   * Perform comprehensive system health check
+   */
+  static async performHealthCheck() {
+    const timestamp = /* @__PURE__ */ new Date();
+    const checks = {
+      configuration: await this.checkConfiguration(),
+      provider: await this.checkProvider(),
+      storage: await this.checkStorage()
+    };
+    const statuses = Object.values(checks).map((check) => check.status);
+    let overall = "healthy";
+    if (statuses.includes("error")) {
+      overall = "error";
+    } else if (statuses.includes("warning")) {
+      overall = "warning";
+    }
+    return {
+      overall,
+      checks,
+      timestamp
+    };
+  }
+  /**
+   * Check configuration validity
+   */
+  static async checkConfiguration() {
+    try {
+      const config = getAuthConfig();
+      const timestamp = /* @__PURE__ */ new Date();
+      let providerType = null;
+      if (config.supabaseUrl && config.supabaseAnonKey) {
+        providerType = "supabase";
+      } else if (config.firebaseApiKey && config.firebaseAuthDomain && config.firebaseProjectId) {
+        providerType = "firebase";
+      }
+      if (!providerType) {
+        return {
+          status: "error",
+          message: "No valid authentication provider configuration found",
+          details: {
+            hasSupabaseConfig: !!(config.supabaseUrl && config.supabaseAnonKey),
+            hasFirebaseConfig: !!(config.firebaseApiKey && config.firebaseAuthDomain && config.firebaseProjectId)
+          },
+          timestamp
+        };
+      }
+      if (providerType === "supabase") {
+        if (!config.supabaseUrl || !config.supabaseAnonKey) {
+          return {
+            status: "error",
+            message: "Missing Supabase configuration (URL or anonymous key)",
+            details: {
+              hasUrl: !!config.supabaseUrl,
+              hasAnonKey: !!config.supabaseAnonKey
+            },
+            timestamp
+          };
+        }
+      } else if (providerType === "firebase") {
+        if (!config.firebaseApiKey || !config.firebaseAuthDomain || !config.firebaseProjectId) {
+          return {
+            status: "error",
+            message: "Missing Firebase configuration (API key, auth domain, or project ID)",
+            details: {
+              hasApiKey: !!config.firebaseApiKey,
+              hasAuthDomain: !!config.firebaseAuthDomain,
+              hasProjectId: !!config.firebaseProjectId
+            },
+            timestamp
+          };
+        }
+      }
+      return {
+        status: "healthy",
+        message: "Configuration is valid",
+        details: {
+          provider: providerType,
+          hasRedirectUrl: !!config.redirectUrl
+        },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Configuration check failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        details: { error },
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    }
+  }
+  /**
+   * Check provider initialization
+   */
+  static async checkProvider() {
+    try {
+      const timestamp = /* @__PURE__ */ new Date();
+      const provider = await AuthProviderFactory.getProviderFromEnvironment();
+      if (!provider) {
+        return {
+          status: "error",
+          message: "Failed to initialize authentication provider",
+          timestamp
+        };
+      }
+      return {
+        status: "healthy",
+        message: "Authentication provider initialized successfully",
+        details: { providerType: provider.constructor.name },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Provider initialization failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        details: { error },
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    }
+  }
+  /**
+   * Check storage functionality
+   */
+  static async checkStorage() {
+    try {
+      const timestamp = /* @__PURE__ */ new Date();
+      const { createAuthStorage: createAuthStorage2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
+      const storage = createAuthStorage2();
+      const testKey = "health-check-test";
+      const testValue = "test-value";
+      await storage.setItem(testKey, testValue);
+      const retrievedValue = await storage.getItem(testKey);
+      await storage.removeItem(testKey);
+      if (retrievedValue !== testValue) {
+        return {
+          status: "error",
+          message: "Storage read/write test failed",
+          details: { expected: testValue, actual: retrievedValue },
+          timestamp
+        };
+      }
+      return {
+        status: "healthy",
+        message: "Storage is functioning correctly",
+        details: { storageType: storage.constructor.name },
+        timestamp
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        message: `Storage check failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        details: { error },
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    }
+  }
+  /**
+   * Check network connectivity to authentication services
+   */
+  static async checkNetworkConnectivity() {
+    try {
+      const timestamp = /* @__PURE__ */ new Date();
+      const config = getAuthConfig();
+      if (config.supabaseUrl && config.supabaseAnonKey) {
+        const response = await fetch(`${config.supabaseUrl}/rest/v1/`, {
+          method: "HEAD",
+          headers: {
+            "apikey": config.supabaseAnonKey
+          }
+        });
+        if (!response.ok) {
+          return {
+            status: "warning",
+            message: `Supabase connectivity issue: ${response.status} ${response.statusText}`,
+            details: { status: response.status, statusText: response.statusText },
+            timestamp
+          };
+        }
+      }
+      return {
+        status: "healthy",
+        message: "Network connectivity is working",
+        timestamp
+      };
+    } catch (error) {
+      return {
+        status: "warning",
+        message: `Network connectivity check failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        details: { error },
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    }
+  }
+  /**
+   * Generate health check report
+   */
+  static generateReport(healthCheck) {
+    const { overall, checks, timestamp } = healthCheck;
+    let report = `Authentication System Health Check Report
+`;
+    report += `Generated: ${timestamp.toISOString()}
+`;
+    report += `Overall Status: ${overall.toUpperCase()}
+
+`;
+    Object.entries(checks).forEach(([checkName, result]) => {
+      report += `${checkName.toUpperCase()} CHECK:
+`;
+      report += `  Status: ${result.status.toUpperCase()}
+`;
+      report += `  Message: ${result.message}
+`;
+      if (result.details) {
+        report += `  Details: ${JSON.stringify(result.details, null, 2)}
+`;
+      }
+      report += `
+`;
+    });
+    return report;
+  }
+  /**
+   * Quick health check for monitoring
+   */
+  static async quickCheck() {
+    try {
+      const configCheck = await this.checkConfiguration();
+      const providerCheck = await this.checkProvider();
+      return configCheck.status !== "error" && providerCheck.status !== "error";
+    } catch (error) {
+      return false;
+    }
+  }
 };
-var useAuthContext = () => {
-  const context = react.useContext(AuthContext);
-  if (!context) {
-    throw new Error("useAuthContext must be used within an AuthProvider");
+var supabaseAdmin = null;
+var getSupabaseAdmin = () => {
+  if (!supabaseAdmin) {
+    if (!process.env.NEXT_PUBLIC_SUPABASE_URL || !process.env.SUPABASE_SERVICE_ROLE_KEY) {
+      throw new Error("Missing required Supabase environment variables for admin client");
+    }
+    supabaseAdmin = supabaseJs.createClient(
+      process.env.NEXT_PUBLIC_SUPABASE_URL,
+      process.env.SUPABASE_SERVICE_ROLE_KEY
+    );
   }
-  return context;
+  return supabaseAdmin;
 };
+function withAuth(middleware, options = {}) {
+  const {
+    publicRoutes = ["/login", "/signup", "/reset-password"],
+    loginRoute = "/login"
+  } = options;
+  return async function middlewareWithAuth(req) {
+    const res = server.NextResponse.next();
+    const supabase2 = authHelpersNextjs.createMiddlewareClient({ req, res });
+    const {
+      data: { session }
+    } = await supabase2.auth.getSession();
+    let user = session == null ? undefined : session.user;
+    if (!user) {
+      const authHeader = req.headers.get("authorization");
+      if (authHeader == null ? undefined : authHeader.startsWith("Bearer ")) {
+        const token = authHeader.substring(7);
+        try {
+          const admin = getSupabaseAdmin();
+          const { data: { user: bearerUser } } = await admin.auth.getUser(token);
+          user = bearerUser;
+        } catch (error) {
+          console.error("Bearer token verification failed:", error);
+        }
+      }
+    }
+    const isPublicRoute = publicRoutes.includes(req.nextUrl.pathname);
+    const isLoginRoute = req.nextUrl.pathname === loginRoute;
+    if (isPublicRoute) {
+      if (user && isLoginRoute) {
+        const returnUrl = req.nextUrl.searchParams.get("returnUrl");
+        return server.NextResponse.redirect(new URL(returnUrl || "/dashboard", req.url));
+      }
+      return middleware(req);
+    }
+    if (!user) {
+      const redirectUrl = new URL(loginRoute, req.url);
+      redirectUrl.searchParams.set("returnUrl", req.nextUrl.pathname);
+      return server.NextResponse.redirect(redirectUrl);
+    }
+    return middleware(req);
+  };
+}
+async function handleEmailVerification(token) {
+  const supabase2 = authHelpersNextjs.createServerComponentClient({ cookies: headers.cookies });
+  try {
+    const { error } = await supabase2.auth.verifyOtp({
+      token_hash: token,
+      type: "email"
+    });
+    if (error) throw error;
+    return { success: true };
+  } catch (error) {
+    return { success: false, error };
+  }
+}
 
+exports.AuthContext = AuthContext;
+exports.AuthError = AuthError;
+exports.AuthErrorType = AuthErrorType;
+exports.AuthEvent = AuthEvent;
 exports.AuthProvider = AuthProvider;
-exports.createClient = createClient;
-exports.supabase = supabase;
+exports.AuthProviderFactory = AuthProviderFactory;
+exports.FirebaseAuthProvider = FirebaseAuthProvider;
+exports.HealthChecker = HealthChecker;
+exports.LRUCache = LRUCache;
+exports.PerformanceMonitor = PerformanceMonitor;
+exports.SupabaseAuthProvider = SupabaseAuthProvider;
+exports.ValidationUtils = ValidationUtils;
+exports.createAuthStore = createAuthStore;
+exports.debounce = debounce;
+exports.defaultAuthConfig = defaultAuthConfig;
+exports.handleEmailVerification = handleEmailVerification;
+exports.memoize = memoize;
+exports.retryWithBackoff = retryWithBackoff;
+exports.throttle = throttle;
+exports.use2FA = use2FA;
 exports.useAuth = useAuth;
-exports.useAuthContext = useAuthContext;
-exports.useAuthStore = useAuthStore;
+exports.useAuthForm = useAuthForm;
+exports.useProtectedRoute = useProtectedRoute;
+exports.useRBAC = useRBAC;
+exports.useRedirectUrl = useRedirectUrl;
+exports.validateParams = validateParams;
+exports.validatePassword = validatePassword;
+exports.withAuth = withAuth;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map