@authsome/ui-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1453 @@
+'use strict';
+
+// src/types/auth.ts
+var AuthState = /* @__PURE__ */ ((AuthState2) => {
+  AuthState2["AUTHENTICATED"] = "authenticated";
+  AuthState2["UNAUTHENTICATED"] = "unauthenticated";
+  AuthState2["LOADING"] = "loading";
+  AuthState2["ERROR"] = "error";
+  return AuthState2;
+})(AuthState || {});
+var AuthErrorType = /* @__PURE__ */ ((AuthErrorType2) => {
+  AuthErrorType2["INVALID_CREDENTIALS"] = "invalid_credentials";
+  AuthErrorType2["USER_NOT_FOUND"] = "user_not_found";
+  AuthErrorType2["USER_ALREADY_EXISTS"] = "user_already_exists";
+  AuthErrorType2["INVALID_TOKEN"] = "invalid_token";
+  AuthErrorType2["TOKEN_EXPIRED"] = "token_expired";
+  AuthErrorType2["NETWORK_ERROR"] = "network_error";
+  AuthErrorType2["VALIDATION_ERROR"] = "validation_error";
+  AuthErrorType2["MFA_REQUIRED"] = "mfa_required";
+  AuthErrorType2["EMAIL_NOT_VERIFIED"] = "email_not_verified";
+  AuthErrorType2["PHONE_NOT_VERIFIED"] = "phone_not_verified";
+  AuthErrorType2["RATE_LIMIT_EXCEEDED"] = "rate_limit_exceeded";
+  AuthErrorType2["UNKNOWN_ERROR"] = "unknown_error";
+  return AuthErrorType2;
+})(AuthErrorType || {});
+var AuthError = class _AuthError extends Error {
+  constructor(message, type = "unknown_error" /* UNKNOWN_ERROR */, options) {
+    super(message);
+    this.name = "AuthError";
+    this.type = type;
+    this.details = options?.details;
+    this.code = options?.code;
+    this.originalError = options?.originalError;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AuthError);
+    }
+  }
+};
+var OAuthProvider = /* @__PURE__ */ ((OAuthProvider2) => {
+  OAuthProvider2["GOOGLE"] = "google";
+  OAuthProvider2["GITHUB"] = "github";
+  OAuthProvider2["FACEBOOK"] = "facebook";
+  OAuthProvider2["TWITTER"] = "twitter";
+  OAuthProvider2["MICROSOFT"] = "microsoft";
+  OAuthProvider2["APPLE"] = "apple";
+  OAuthProvider2["LINKEDIN"] = "linkedin";
+  OAuthProvider2["DISCORD"] = "discord";
+  return OAuthProvider2;
+})(OAuthProvider || {});
+var TwoFactorMethod = /* @__PURE__ */ ((TwoFactorMethod2) => {
+  TwoFactorMethod2["TOTP"] = "totp";
+  TwoFactorMethod2["SMS"] = "sms";
+  TwoFactorMethod2["EMAIL"] = "email";
+  TwoFactorMethod2["BACKUP_CODE"] = "backup_code";
+  return TwoFactorMethod2;
+})(TwoFactorMethod || {});
+
+// src/types/storage.ts
+var LocalStorageAdapter = class {
+  getItem(key) {
+    if (typeof window === "undefined") return null;
+    return window.localStorage.getItem(key);
+  }
+  setItem(key, value) {
+    if (typeof window === "undefined") return;
+    window.localStorage.setItem(key, value);
+  }
+  removeItem(key) {
+    if (typeof window === "undefined") return;
+    window.localStorage.removeItem(key);
+  }
+  clear() {
+    if (typeof window === "undefined") return;
+    window.localStorage.clear();
+  }
+};
+var SessionStorageAdapter = class {
+  getItem(key) {
+    if (typeof window === "undefined") return null;
+    return window.sessionStorage.getItem(key);
+  }
+  setItem(key, value) {
+    if (typeof window === "undefined") return;
+    window.sessionStorage.setItem(key, value);
+  }
+  removeItem(key) {
+    if (typeof window === "undefined") return;
+    window.sessionStorage.removeItem(key);
+  }
+  clear() {
+    if (typeof window === "undefined") return;
+    window.sessionStorage.clear();
+  }
+};
+var MemoryStorageAdapter = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  getItem(key) {
+    return this.store.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.store.set(key, value);
+  }
+  removeItem(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+
+// src/types/observable.ts
+var Observable = class {
+  constructor(initialValue) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.value = initialValue;
+  }
+  /**
+   * Get current value
+   */
+  getValue() {
+    return this.value;
+  }
+  /**
+   * Set new value and notify listeners
+   */
+  setValue(newValue) {
+    if (this.value !== newValue) {
+      this.value = newValue;
+      this.notify();
+    }
+  }
+  /**
+   * Update value with a function
+   */
+  update(updater) {
+    this.setValue(updater(this.value));
+  }
+  /**
+   * Subscribe to value changes
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.value);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Notify all listeners
+   */
+  notify() {
+    this.listeners.forEach((listener) => listener(this.value));
+  }
+  /**
+   * Clear all listeners
+   */
+  clearListeners() {
+    this.listeners.clear();
+  }
+  /**
+   * Get number of listeners
+   */
+  getListenerCount() {
+    return this.listeners.size;
+  }
+};
+
+// src/utils/errors.ts
+function createAuthError(type, message, details, code) {
+  return new AuthError(message, type, { details, code });
+}
+function isAuthError(error) {
+  return error instanceof AuthError;
+}
+function toAuthError(error) {
+  if (isAuthError(error)) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new AuthError(error.message, "unknown_error" /* UNKNOWN_ERROR */, {
+      details: {
+        originalError: error.name,
+        stack: error.stack
+      }
+    });
+  }
+  if (typeof error === "string") {
+    return new AuthError(error, "unknown_error" /* UNKNOWN_ERROR */);
+  }
+  return new AuthError(
+    "An unknown error occurred",
+    "unknown_error" /* UNKNOWN_ERROR */,
+    { details: { error } }
+  );
+}
+function isNetworkError(error) {
+  if (error instanceof Error) {
+    return error.name === "NetworkError" || error.message.includes("network") || error.message.includes("fetch");
+  }
+  return false;
+}
+function isUnauthenticatedError(error) {
+  if (isAuthError(error)) {
+    return error.type === "invalid_token" /* INVALID_TOKEN */ || error.type === "token_expired" /* TOKEN_EXPIRED */;
+  }
+  return false;
+}
+function isMFARequiredError(error) {
+  if (isAuthError(error)) {
+    return error.type === "mfa_required" /* MFA_REQUIRED */;
+  }
+  return false;
+}
+
+// src/utils/validation.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var PHONE_REGEX = /^\+?[1-9]\d{1,14}$/;
+var USERNAME_REGEX = /^[a-zA-Z0-9_-]{3,30}$/;
+function validateEmail(email) {
+  if (!email) {
+    return { field: "email", message: "Email is required" };
+  }
+  if (!EMAIL_REGEX.test(email)) {
+    return { field: "email", message: "Invalid email address" };
+  }
+  return null;
+}
+function validatePassword(password, options = {}) {
+  const {
+    minLength = 8,
+    requireUppercase = true,
+    requireLowercase = true,
+    requireNumber = true,
+    requireSpecial = false
+  } = options;
+  if (!password) {
+    return { field: "password", message: "Password is required" };
+  }
+  if (password.length < minLength) {
+    return {
+      field: "password",
+      message: `Password must be at least ${minLength} characters`
+    };
+  }
+  if (requireUppercase && !/[A-Z]/.test(password)) {
+    return {
+      field: "password",
+      message: "Password must contain at least one uppercase letter"
+    };
+  }
+  if (requireLowercase && !/[a-z]/.test(password)) {
+    return {
+      field: "password",
+      message: "Password must contain at least one lowercase letter"
+    };
+  }
+  if (requireNumber && !/\d/.test(password)) {
+    return { field: "password", message: "Password must contain at least one number" };
+  }
+  if (requireSpecial && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
+    return {
+      field: "password",
+      message: "Password must contain at least one special character"
+    };
+  }
+  return null;
+}
+function validatePhone(phone) {
+  if (!phone) {
+    return { field: "phone", message: "Phone number is required" };
+  }
+  if (!PHONE_REGEX.test(phone)) {
+    return {
+      field: "phone",
+      message: "Invalid phone number. Use international format (+1234567890)"
+    };
+  }
+  return null;
+}
+function validateUsername(username) {
+  if (!username) {
+    return { field: "username", message: "Username is required" };
+  }
+  if (!USERNAME_REGEX.test(username)) {
+    return {
+      field: "username",
+      message: "Username must be 3-30 characters and contain only letters, numbers, underscores, and hyphens"
+    };
+  }
+  return null;
+}
+function validate2FACode(code) {
+  if (!code) {
+    return { field: "code", message: "Verification code is required" };
+  }
+  if (!/^\d{6}$/.test(code)) {
+    return { field: "code", message: "Code must be 6 digits" };
+  }
+  return null;
+}
+function validateRequired(value, fieldName) {
+  if (!value || typeof value === "string" && !value.trim()) {
+    return { field: fieldName, message: `${fieldName} is required` };
+  }
+  return null;
+}
+
+// src/utils/tokens.ts
+var TOKEN_KEY = "authsome_token";
+var REFRESH_TOKEN_KEY = "authsome_refresh_token";
+var TokenManager = class {
+  constructor(storage = new LocalStorageAdapter()) {
+    this.storage = storage;
+  }
+  /**
+   * Get access token
+   */
+  async getToken() {
+    return await Promise.resolve(this.storage.getItem(TOKEN_KEY));
+  }
+  /**
+   * Set access token
+   */
+  async setToken(token) {
+    await Promise.resolve(this.storage.setItem(TOKEN_KEY, token));
+  }
+  /**
+   * Remove access token
+   */
+  async removeToken() {
+    await Promise.resolve(this.storage.removeItem(TOKEN_KEY));
+  }
+  /**
+   * Get refresh token
+   */
+  async getRefreshToken() {
+    return await Promise.resolve(this.storage.getItem(REFRESH_TOKEN_KEY));
+  }
+  /**
+   * Set refresh token
+   */
+  async setRefreshToken(token) {
+    await Promise.resolve(this.storage.setItem(REFRESH_TOKEN_KEY, token));
+  }
+  /**
+   * Remove refresh token
+   */
+  async removeRefreshToken() {
+    await Promise.resolve(this.storage.removeItem(REFRESH_TOKEN_KEY));
+  }
+  /**
+   * Clear all tokens
+   */
+  async clearTokens() {
+    await this.removeToken();
+    await this.removeRefreshToken();
+  }
+  /**
+   * Check if token is expired
+   */
+  isTokenExpired(token) {
+    try {
+      const payload = this.decodeToken(token);
+      if (!payload.exp) return false;
+      const expiresAt = payload.exp * 1e3;
+      const now = Date.now();
+      return expiresAt - now < 6e4;
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Decode JWT token (without verification)
+   */
+  decodeToken(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      throw new Error("Invalid token format");
+    }
+    const payload = parts[1];
+    const decoded = atob(payload);
+    return JSON.parse(decoded);
+  }
+};
+
+// src/adapters/base-provider.ts
+var BaseAuthProvider = class {
+  constructor() {
+    this.config = {};
+    this.initialized = false;
+  }
+  /**
+   * Initialize the provider
+   */
+  async initialize(config) {
+    this.config = config;
+    this.initialized = true;
+  }
+  /**
+   * Ensure provider is initialized
+   */
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error(`Provider ${this.name} is not initialized`);
+    }
+  }
+  /**
+   * Make HTTP request
+   */
+  async request(url, options = {}) {
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({
+        message: response.statusText
+      }));
+      throw error;
+    }
+    return response.json();
+  }
+  /**
+   * Normalize error to AuthError
+   */
+  normalizeError(error) {
+    return toAuthError(error);
+  }
+};
+
+// src/client.ts
+var AuthClient = class {
+  constructor(config) {
+    this.provider = config.provider;
+    this.autoRefresh = config.autoRefresh ?? true;
+    this.refreshInterval = config.refreshInterval ?? 5 * 60 * 1e3;
+    this.state = new Observable({
+      state: "loading" /* LOADING */,
+      user: null,
+      session: null,
+      error: null,
+      isAuthenticated: false,
+      isLoading: true
+    });
+  }
+  /**
+   * Initialize the auth client
+   */
+  async initialize() {
+    try {
+      const user = await this.provider.getCurrentUser();
+      const session = await this.provider.getCurrentSession();
+      if (user && session) {
+        this.updateState({
+          state: "authenticated" /* AUTHENTICATED */,
+          user,
+          session,
+          error: null,
+          isAuthenticated: true,
+          isLoading: false
+        });
+        if (this.autoRefresh) {
+          this.startAutoRefresh();
+        }
+      } else {
+        this.updateState({
+          state: "unauthenticated" /* UNAUTHENTICATED */,
+          user: null,
+          session: null,
+          error: null,
+          isAuthenticated: false,
+          isLoading: false
+        });
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Sign in with credentials
+   */
+  async signIn(request) {
+    try {
+      this.setLoading();
+      const response = await this.provider.signIn(request);
+      if (response.requiresTwoFactor) {
+        this.updateState({
+          state: "unauthenticated" /* UNAUTHENTICATED */,
+          user: response.user,
+          session: null,
+          error: null,
+          isAuthenticated: false,
+          isLoading: false
+        });
+        return;
+      }
+      this.updateState({
+        state: "authenticated" /* AUTHENTICATED */,
+        user: response.user,
+        session: response.session,
+        error: null,
+        isAuthenticated: true,
+        isLoading: false
+      });
+      if (this.autoRefresh) {
+        this.startAutoRefresh();
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Sign up with credentials
+   */
+  async signUp(request) {
+    try {
+      this.setLoading();
+      const response = await this.provider.signUp(request);
+      this.updateState({
+        state: "authenticated" /* AUTHENTICATED */,
+        user: response.user,
+        session: response.session,
+        error: null,
+        isAuthenticated: true,
+        isLoading: false
+      });
+      if (this.autoRefresh) {
+        this.startAutoRefresh();
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Sign out
+   */
+  async signOut() {
+    try {
+      this.stopAutoRefresh();
+      await this.provider.signOut();
+      this.updateState({
+        state: "unauthenticated" /* UNAUTHENTICATED */,
+        user: null,
+        session: null,
+        error: null,
+        isAuthenticated: false,
+        isLoading: false
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Update user profile
+   */
+  async updateUser(request) {
+    try {
+      const user = await this.provider.updateUser(request);
+      const currentState = this.state.getValue();
+      this.updateState({
+        ...currentState,
+        user
+      });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Change password
+   */
+  async changePassword(request) {
+    try {
+      await this.provider.changePassword(request);
+    } catch (error) {
+      throw this.provider.normalizeError(error);
+    }
+  }
+  /**
+   * Request password reset
+   */
+  async requestPasswordReset(request) {
+    try {
+      await this.provider.requestPasswordReset(request);
+    } catch (error) {
+      throw this.provider.normalizeError(error);
+    }
+  }
+  /**
+   * Confirm password reset
+   */
+  async confirmPasswordReset(request) {
+    try {
+      await this.provider.confirmPasswordReset(request);
+    } catch (error) {
+      throw this.provider.normalizeError(error);
+    }
+  }
+  /**
+   * Get OAuth sign in URL
+   */
+  async getOAuthUrl(request) {
+    return this.provider.oauthSignIn(request);
+  }
+  /**
+   * Handle OAuth callback
+   */
+  async handleOAuthCallback(request) {
+    try {
+      this.setLoading();
+      const response = await this.provider.oauthCallback(request);
+      this.updateState({
+        state: "authenticated" /* AUTHENTICATED */,
+        user: response.user,
+        session: response.session,
+        error: null,
+        isAuthenticated: true,
+        isLoading: false
+      });
+      if (this.autoRefresh) {
+        this.startAutoRefresh();
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Get available OAuth providers
+   */
+  async getOAuthProviders() {
+    return this.provider.getOAuthProviders();
+  }
+  /**
+   * Send magic link
+   */
+  async sendMagicLink(request) {
+    try {
+      await this.provider.sendMagicLink(request);
+    } catch (error) {
+      throw this.provider.normalizeError(error);
+    }
+  }
+  /**
+   * Verify magic link
+   */
+  async verifyMagicLink(request) {
+    try {
+      this.setLoading();
+      const response = await this.provider.verifyMagicLink(request);
+      this.updateState({
+        state: "authenticated" /* AUTHENTICATED */,
+        user: response.user,
+        session: response.session,
+        error: null,
+        isAuthenticated: true,
+        isLoading: false
+      });
+      if (this.autoRefresh) {
+        this.startAutoRefresh();
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Send phone verification code
+   */
+  async sendPhoneCode(request) {
+    try {
+      await this.provider.sendPhoneCode(request);
+    } catch (error) {
+      throw this.provider.normalizeError(error);
+    }
+  }
+  /**
+   * Verify phone code
+   */
+  async verifyPhoneCode(request) {
+    try {
+      this.setLoading();
+      const response = await this.provider.verifyPhoneCode(request);
+      this.updateState({
+        state: "authenticated" /* AUTHENTICATED */,
+        user: response.user,
+        session: response.session,
+        error: null,
+        isAuthenticated: true,
+        isLoading: false
+      });
+      if (this.autoRefresh) {
+        this.startAutoRefresh();
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Setup 2FA
+   */
+  async setupTwoFactor(request) {
+    return this.provider.setupTwoFactor(request);
+  }
+  /**
+   * Verify 2FA code
+   */
+  async verifyTwoFactor(request) {
+    try {
+      this.setLoading();
+      const response = await this.provider.verifyTwoFactor(request);
+      this.updateState({
+        state: "authenticated" /* AUTHENTICATED */,
+        user: response.user,
+        session: response.session,
+        error: null,
+        isAuthenticated: true,
+        isLoading: false
+      });
+      if (this.autoRefresh) {
+        this.startAutoRefresh();
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Disable 2FA
+   */
+  async disableTwoFactor() {
+    return this.provider.disableTwoFactor();
+  }
+  /**
+   * Get 2FA status
+   */
+  async getTwoFactorStatus() {
+    return this.provider.getTwoFactorStatus();
+  }
+  /**
+   * Register passkey
+   */
+  async registerPasskey(request) {
+    return this.provider.registerPasskey(request);
+  }
+  /**
+   * Authenticate with passkey
+   */
+  async authenticatePasskey(request) {
+    try {
+      this.setLoading();
+      const response = await this.provider.authenticatePasskey(request);
+      this.updateState({
+        state: "authenticated" /* AUTHENTICATED */,
+        user: response.user,
+        session: response.session,
+        error: null,
+        isAuthenticated: true,
+        isLoading: false
+      });
+      if (this.autoRefresh) {
+        this.startAutoRefresh();
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * List passkeys
+   */
+  async listPasskeys() {
+    return this.provider.listPasskeys();
+  }
+  /**
+   * Delete passkey
+   */
+  async deletePasskey(credentialId) {
+    return this.provider.deletePasskey(credentialId);
+  }
+  /**
+   * Get all organizations the user belongs to
+   * Only available if the provider supports organizations
+   */
+  async getOrganizations() {
+    if (!this.provider.getOrganizations) {
+      throw this.createUnsupportedError("Organization support");
+    }
+    return this.provider.getOrganizations();
+  }
+  /**
+   * Get the currently active organization
+   * Only available if the provider supports organizations
+   */
+  async getActiveOrganization() {
+    if (!this.provider.getActiveOrganization) {
+      throw this.createUnsupportedError("Organization support");
+    }
+    return this.provider.getActiveOrganization();
+  }
+  /**
+   * Set the active organization and refresh user state
+   * Only available if the provider supports organizations
+   */
+  async setActiveOrganization(organizationId) {
+    if (!this.provider.setActiveOrganization) {
+      throw this.createUnsupportedError("Organization support");
+    }
+    await this.provider.setActiveOrganization(organizationId);
+    await this.refreshSession();
+  }
+  /**
+   * Get organization memberships with roles and permissions
+   * Only available if the provider supports organizations
+   */
+  async getOrganizationMemberships() {
+    if (!this.provider.getOrganizationMemberships) {
+      throw this.createUnsupportedError("Organization memberships");
+    }
+    return this.provider.getOrganizationMemberships();
+  }
+  /**
+   * Check if the provider supports organizations
+   */
+  supportsOrganizations() {
+    return !!(this.provider.getOrganizations && this.provider.getActiveOrganization && this.provider.setActiveOrganization);
+  }
+  /**
+   * Refresh session
+   */
+  async refreshSession() {
+    try {
+      const session = await this.provider.refreshSession();
+      const currentState = this.state.getValue();
+      this.updateState({
+        ...currentState,
+        session
+      });
+    } catch (error) {
+      await this.signOut();
+    }
+  }
+  /**
+   * Get current user
+   */
+  getUser() {
+    return this.state.getValue().user;
+  }
+  /**
+   * Get current session
+   */
+  getSession() {
+    return this.state.getValue().session;
+  }
+  /**
+   * Check if authenticated
+   */
+  isAuthenticated() {
+    return this.state.getValue().isAuthenticated;
+  }
+  /**
+   * Get current error
+   */
+  getError() {
+    return this.state.getValue().error;
+  }
+  /**
+   * Clear error
+   */
+  clearError() {
+    const currentState = this.state.getValue();
+    this.updateState({
+      ...currentState,
+      error: null
+    });
+  }
+  /**
+   * Subscribe to auth state changes
+   */
+  subscribe(listener) {
+    return this.state.subscribe(listener);
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.stopAutoRefresh();
+    this.state.clearListeners();
+  }
+  // Private methods
+  updateState(newState) {
+    this.state.setValue(newState);
+  }
+  setLoading() {
+    const currentState = this.state.getValue();
+    this.updateState({
+      ...currentState,
+      state: "loading" /* LOADING */,
+      isLoading: true,
+      error: null
+    });
+  }
+  handleError(error) {
+    const authError = this.provider.normalizeError(error);
+    const currentState = this.state.getValue();
+    this.updateState({
+      ...currentState,
+      state: "error" /* ERROR */,
+      error: authError,
+      isLoading: false
+    });
+  }
+  startAutoRefresh() {
+    this.stopAutoRefresh();
+    this.refreshTimer = setInterval(() => {
+      this.refreshSession();
+    }, this.refreshInterval);
+  }
+  stopAutoRefresh() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = void 0;
+    }
+  }
+  createUnsupportedError(feature) {
+    return {
+      name: "AuthError",
+      message: `${feature} is not available with this auth provider`,
+      type: "unknown_error" /* UNKNOWN_ERROR */
+    };
+  }
+};
+
+// src/flows/types.ts
+var FlowStep = /* @__PURE__ */ ((FlowStep2) => {
+  FlowStep2["SIGN_IN"] = "sign_in";
+  FlowStep2["SIGN_UP"] = "sign_up";
+  FlowStep2["EMAIL_PASSWORD_SIGN_IN"] = "email_password_sign_in";
+  FlowStep2["EMAIL_PASSWORD_SIGN_UP"] = "email_password_sign_up";
+  FlowStep2["OAUTH_SELECT"] = "oauth_select";
+  FlowStep2["OAUTH_CALLBACK"] = "oauth_callback";
+  FlowStep2["MAGIC_LINK_REQUEST"] = "magic_link_request";
+  FlowStep2["MAGIC_LINK_VERIFY"] = "magic_link_verify";
+  FlowStep2["MAGIC_LINK_SENT"] = "magic_link_sent";
+  FlowStep2["PHONE_REQUEST"] = "phone_request";
+  FlowStep2["PHONE_VERIFY"] = "phone_verify";
+  FlowStep2["USERNAME_SIGN_IN"] = "username_sign_in";
+  FlowStep2["USERNAME_SIGN_UP"] = "username_sign_up";
+  FlowStep2["PASSKEY_REGISTER"] = "passkey_register";
+  FlowStep2["PASSKEY_AUTHENTICATE"] = "passkey_authenticate";
+  FlowStep2["MFA_REQUIRED"] = "mfa_required";
+  FlowStep2["MFA_SETUP"] = "mfa_setup";
+  FlowStep2["MFA_VERIFY"] = "mfa_verify";
+  FlowStep2["MFA_SELECT_METHOD"] = "mfa_select_method";
+  FlowStep2["EMAIL_VERIFICATION_REQUIRED"] = "email_verification_required";
+  FlowStep2["EMAIL_VERIFICATION_SENT"] = "email_verification_sent";
+  FlowStep2["PHONE_VERIFICATION_REQUIRED"] = "phone_verification_required";
+  FlowStep2["PASSWORD_RESET_REQUEST"] = "password_reset_request";
+  FlowStep2["PASSWORD_RESET_SENT"] = "password_reset_sent";
+  FlowStep2["PASSWORD_RESET_CONFIRM"] = "password_reset_confirm";
+  FlowStep2["PASSWORD_CHANGE"] = "password_change";
+  FlowStep2["PROFILE_UPDATE"] = "profile_update";
+  FlowStep2["PROFILE_COMPLETE"] = "profile_complete";
+  FlowStep2["SUCCESS"] = "success";
+  FlowStep2["ERROR"] = "error";
+  FlowStep2["CANCELLED"] = "cancelled";
+  return FlowStep2;
+})(FlowStep || {});
+var FlowConfigType = /* @__PURE__ */ ((FlowConfigType2) => {
+  FlowConfigType2["SIMPLE_SIGN_IN"] = "simple_sign_in";
+  FlowConfigType2["SIMPLE_SIGN_UP"] = "simple_sign_up";
+  FlowConfigType2["SIGN_UP_WITH_EMAIL_VERIFICATION"] = "sign_up_with_email_verification";
+  FlowConfigType2["SIGN_IN_WITH_MFA"] = "sign_in_with_mfa";
+  FlowConfigType2["OAUTH_SIGN_IN"] = "oauth_sign_in";
+  FlowConfigType2["MAGIC_LINK_FLOW"] = "magic_link_flow";
+  FlowConfigType2["PHONE_AUTH_FLOW"] = "phone_auth_flow";
+  FlowConfigType2["COMPLETE_SIGN_UP_FLOW"] = "complete_sign_up_flow";
+  FlowConfigType2["SECURE_SIGN_IN_FLOW"] = "secure_sign_in_flow";
+  FlowConfigType2["PASSWORD_RESET_FLOW"] = "password_reset_flow";
+  FlowConfigType2["CUSTOM"] = "custom";
+  return FlowConfigType2;
+})(FlowConfigType || {});
+var FlowAction = /* @__PURE__ */ ((FlowAction2) => {
+  FlowAction2["START"] = "start";
+  FlowAction2["NEXT"] = "next";
+  FlowAction2["BACK"] = "back";
+  FlowAction2["CANCEL"] = "cancel";
+  FlowAction2["ERROR"] = "error";
+  FlowAction2["RESET"] = "reset";
+  return FlowAction2;
+})(FlowAction || {});
+
+// src/flows/engine.ts
+var FlowEngine = class {
+  constructor(config, initialState) {
+    this.history = [];
+    this.config = config;
+    this.state = {
+      currentStep: config.initialStep,
+      ...initialState
+    };
+    this.history.push(this.state.currentStep);
+  }
+  /**
+   * Get current flow state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get current step
+   */
+  getCurrentStep() {
+    return this.state.currentStep;
+  }
+  /**
+   * Check if step is allowed in this flow
+   */
+  isStepAllowed(step) {
+    return this.config.allowedSteps.includes(step);
+  }
+  /**
+   * Transition to next step based on action
+   */
+  async transition(event) {
+    const { action, data, error } = event;
+    switch (action) {
+      case "start":
+        return this.handleStart(data);
+      case "next":
+        return this.handleNext(data);
+      case "back":
+        return this.handleBack();
+      case "cancel":
+        return this.handleCancel();
+      case "error":
+        return this.handleError(error);
+      case "reset":
+        return this.handleReset();
+      default:
+        throw new AuthError(
+          `Unknown flow action: ${action}`,
+          "validation_error" /* VALIDATION_ERROR */
+        );
+    }
+  }
+  /**
+   * Start or restart the flow
+   */
+  handleStart(data) {
+    this.state = {
+      currentStep: this.config.initialStep,
+      ...data
+    };
+    this.history = [this.state.currentStep];
+    if (this.config.onStepChange) {
+      this.config.onStepChange(this.state.currentStep, this.state);
+    }
+    return this.getState();
+  }
+  /**
+   * Move to next step
+   */
+  handleNext(data) {
+    this.state = {
+      ...this.state,
+      ...data,
+      previousStep: this.state.currentStep
+    };
+    const transitionConfig = this.config.transitions[this.state.currentStep];
+    if (!transitionConfig) {
+      throw new AuthError(
+        `No transition configured for step: ${this.state.currentStep}`,
+        "validation_error" /* VALIDATION_ERROR */
+      );
+    }
+    if (transitionConfig.conditions) {
+      for (const condition of transitionConfig.conditions) {
+        if (condition.when(this.state)) {
+          return this.moveToStep(condition.then);
+        }
+      }
+    }
+    if (transitionConfig.onSuccess) {
+      return this.moveToStep(transitionConfig.onSuccess);
+    }
+    throw new AuthError(
+      `No valid transition found for step: ${this.state.currentStep}`,
+      "validation_error" /* VALIDATION_ERROR */
+    );
+  }
+  /**
+   * Go back to previous step
+   */
+  handleBack() {
+    if (this.history.length < 2) {
+      throw new AuthError(
+        "Cannot go back - already at first step",
+        "validation_error" /* VALIDATION_ERROR */
+      );
+    }
+    this.history.pop();
+    const previousStep = this.history[this.history.length - 1];
+    const transitionConfig = this.config.transitions[this.state.currentStep];
+    const targetStep = transitionConfig?.onBack || previousStep;
+    return this.moveToStep(targetStep, false);
+  }
+  /**
+   * Cancel the flow
+   */
+  handleCancel() {
+    const transitionConfig = this.config.transitions[this.state.currentStep];
+    const targetStep = transitionConfig?.onCancel;
+    if (this.config.onCancel) {
+      this.config.onCancel(this.state);
+    }
+    if (targetStep) {
+      return this.moveToStep(targetStep);
+    }
+    this.state.currentStep = "cancelled";
+    return this.getState();
+  }
+  /**
+   * Handle error in flow
+   */
+  handleError(error) {
+    this.state.error = error;
+    const transitionConfig = this.config.transitions[this.state.currentStep];
+    const targetStep = transitionConfig?.onError;
+    if (this.config.onError) {
+      this.config.onError(error, this.state);
+    }
+    if (targetStep) {
+      return this.moveToStep(targetStep);
+    }
+    return this.getState();
+  }
+  /**
+   * Reset flow to initial state
+   */
+  handleReset() {
+    return this.handleStart();
+  }
+  /**
+   * Move to a specific step
+   */
+  moveToStep(step, addToHistory = true) {
+    if (!this.isStepAllowed(step)) {
+      throw new AuthError(
+        `Step ${step} is not allowed in this flow`,
+        "validation_error" /* VALIDATION_ERROR */
+      );
+    }
+    this.state.currentStep = step;
+    if (addToHistory) {
+      this.history.push(step);
+    }
+    if (this.config.onStepChange) {
+      this.config.onStepChange(step, this.state);
+    }
+    if (step === "success" && this.state.user && this.state.session) {
+      if (this.config.onComplete) {
+        this.config.onComplete(this.state.user, this.state.session);
+      }
+    }
+    return this.getState();
+  }
+  /**
+   * Get flow history
+   */
+  getHistory() {
+    return [...this.history];
+  }
+  /**
+   * Check if can go back
+   */
+  canGoBack() {
+    return this.history.length > 1;
+  }
+};
+
+// src/flows/configs.ts
+var simpleSignInFlow = {
+  name: "Simple Sign In",
+  description: "Basic email/password sign-in",
+  initialStep: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
+  allowedSteps: [
+    "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
+    "password_reset_request" /* PASSWORD_RESET_REQUEST */,
+    "password_reset_sent" /* PASSWORD_RESET_SENT */,
+    "success" /* SUCCESS */,
+    "error" /* ERROR */
+  ],
+  transitions: {
+    ["email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */]: {
+      onSuccess: "success" /* SUCCESS */,
+      onError: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */
+    },
+    ["password_reset_request" /* PASSWORD_RESET_REQUEST */]: {
+      onSuccess: "password_reset_sent" /* PASSWORD_RESET_SENT */,
+      onBack: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */
+    },
+    ["password_reset_sent" /* PASSWORD_RESET_SENT */]: {
+      onSuccess: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */
+    }
+  }
+};
+var signInWithMFAFlow = {
+  name: "Sign In with MFA",
+  description: "Sign-in that handles MFA if enabled",
+  initialStep: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
+  allowedSteps: [
+    "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
+    "mfa_required" /* MFA_REQUIRED */,
+    "mfa_select_method" /* MFA_SELECT_METHOD */,
+    "mfa_verify" /* MFA_VERIFY */,
+    "password_reset_request" /* PASSWORD_RESET_REQUEST */,
+    "password_reset_sent" /* PASSWORD_RESET_SENT */,
+    "success" /* SUCCESS */,
+    "error" /* ERROR */
+  ],
+  transitions: {
+    ["email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */]: {
+      onSuccess: "success" /* SUCCESS */,
+      onError: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */,
+      conditions: [
+        {
+          when: (state) => state.mfaRequired === true,
+          then: "mfa_required" /* MFA_REQUIRED */
+        }
+      ]
+    },
+    ["mfa_required" /* MFA_REQUIRED */]: {
+      onSuccess: "mfa_verify" /* MFA_VERIFY */,
+      conditions: [
+        {
+          when: (state) => (state.mfaMethods?.length || 0) > 1,
+          then: "mfa_select_method" /* MFA_SELECT_METHOD */
+        }
+      ]
+    },
+    ["mfa_select_method" /* MFA_SELECT_METHOD */]: {
+      onSuccess: "mfa_verify" /* MFA_VERIFY */,
+      onBack: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */
+    },
+    ["mfa_verify" /* MFA_VERIFY */]: {
+      onSuccess: "success" /* SUCCESS */,
+      onError: "mfa_verify" /* MFA_VERIFY */,
+      onBack: "mfa_select_method" /* MFA_SELECT_METHOD */
+    },
+    ["password_reset_request" /* PASSWORD_RESET_REQUEST */]: {
+      onSuccess: "password_reset_sent" /* PASSWORD_RESET_SENT */,
+      onBack: "email_password_sign_in" /* EMAIL_PASSWORD_SIGN_IN */
+    }
+  }
+};
+var completeSignUpFlow = {
+  name: "Complete Sign Up",
+  description: "Sign-up with email verification and profile completion",
+  initialStep: "email_password_sign_up" /* EMAIL_PASSWORD_SIGN_UP */,
+  allowedSteps: [
+    "email_password_sign_up" /* EMAIL_PASSWORD_SIGN_UP */,
+    "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */,
+    "email_verification_sent" /* EMAIL_VERIFICATION_SENT */,
+    "profile_complete" /* PROFILE_COMPLETE */,
+    "success" /* SUCCESS */,
+    "error" /* ERROR */
+  ],
+  transitions: {
+    ["email_password_sign_up" /* EMAIL_PASSWORD_SIGN_UP */]: {
+      onSuccess: "email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */,
+      onError: "email_password_sign_up" /* EMAIL_PASSWORD_SIGN_UP */,
+      conditions: [
+        {
+          when: (state) => state.verificationRequired === false,
+          then: "profile_complete" /* PROFILE_COMPLETE */
+        }
+      ]
+    },
+    ["email_verification_required" /* EMAIL_VERIFICATION_REQUIRED */]: {
+      onSuccess: "email_verification_sent" /* EMAIL_VERIFICATION_SENT */
+    },
+    ["email_verification_sent" /* EMAIL_VERIFICATION_SENT */]: {
+      onSuccess: "profile_complete" /* PROFILE_COMPLETE */
+    },
+    ["profile_complete" /* PROFILE_COMPLETE */]: {
+      onSuccess: "success" /* SUCCESS */,
+      onError: "profile_complete" /* PROFILE_COMPLETE */
+    }
+  }
+};
+var magicLinkFlow = {
+  name: "Magic Link",
+  description: "Passwordless authentication via email",
+  initialStep: "magic_link_request" /* MAGIC_LINK_REQUEST */,
+  allowedSteps: [
+    "magic_link_request" /* MAGIC_LINK_REQUEST */,
+    "magic_link_sent" /* MAGIC_LINK_SENT */,
+    "magic_link_verify" /* MAGIC_LINK_VERIFY */,
+    "success" /* SUCCESS */,
+    "error" /* ERROR */
+  ],
+  transitions: {
+    ["magic_link_request" /* MAGIC_LINK_REQUEST */]: {
+      onSuccess: "magic_link_sent" /* MAGIC_LINK_SENT */,
+      onError: "magic_link_request" /* MAGIC_LINK_REQUEST */
+    },
+    ["magic_link_sent" /* MAGIC_LINK_SENT */]: {
+      onSuccess: "magic_link_verify" /* MAGIC_LINK_VERIFY */
+    },
+    ["magic_link_verify" /* MAGIC_LINK_VERIFY */]: {
+      onSuccess: "success" /* SUCCESS */,
+      onError: "magic_link_request" /* MAGIC_LINK_REQUEST */
+    }
+  }
+};
+var phoneAuthFlow = {
+  name: "Phone Authentication",
+  description: "SMS-based authentication",
+  initialStep: "phone_request" /* PHONE_REQUEST */,
+  allowedSteps: [
+    "phone_request" /* PHONE_REQUEST */,
+    "phone_verify" /* PHONE_VERIFY */,
+    "success" /* SUCCESS */,
+    "error" /* ERROR */
+  ],
+  transitions: {
+    ["phone_request" /* PHONE_REQUEST */]: {
+      onSuccess: "phone_verify" /* PHONE_VERIFY */,
+      onError: "phone_request" /* PHONE_REQUEST */
+    },
+    ["phone_verify" /* PHONE_VERIFY */]: {
+      onSuccess: "success" /* SUCCESS */,
+      onError: "phone_verify" /* PHONE_VERIFY */,
+      onBack: "phone_request" /* PHONE_REQUEST */
+    }
+  }
+};
+var oauthSignInFlow = {
+  name: "OAuth Sign In",
+  description: "Third-party OAuth authentication",
+  initialStep: "oauth_select" /* OAUTH_SELECT */,
+  allowedSteps: [
+    "oauth_select" /* OAUTH_SELECT */,
+    "oauth_callback" /* OAUTH_CALLBACK */,
+    "success" /* SUCCESS */,
+    "error" /* ERROR */
+  ],
+  transitions: {
+    ["oauth_select" /* OAUTH_SELECT */]: {
+      onSuccess: "oauth_callback" /* OAUTH_CALLBACK */,
+      onError: "oauth_select" /* OAUTH_SELECT */
+    },
+    ["oauth_callback" /* OAUTH_CALLBACK */]: {
+      onSuccess: "success" /* SUCCESS */,
+      onError: "oauth_select" /* OAUTH_SELECT */
+    }
+  }
+};
+var passwordResetFlow = {
+  name: "Password Reset",
+  description: "Reset forgotten password",
+  initialStep: "password_reset_request" /* PASSWORD_RESET_REQUEST */,
+  allowedSteps: [
+    "password_reset_request" /* PASSWORD_RESET_REQUEST */,
+    "password_reset_sent" /* PASSWORD_RESET_SENT */,
+    "password_reset_confirm" /* PASSWORD_RESET_CONFIRM */,
+    "success" /* SUCCESS */,
+    "error" /* ERROR */
+  ],
+  transitions: {
+    ["password_reset_request" /* PASSWORD_RESET_REQUEST */]: {
+      onSuccess: "password_reset_sent" /* PASSWORD_RESET_SENT */,
+      onError: "password_reset_request" /* PASSWORD_RESET_REQUEST */
+    },
+    ["password_reset_sent" /* PASSWORD_RESET_SENT */]: {
+      onSuccess: "password_reset_confirm" /* PASSWORD_RESET_CONFIRM */
+    },
+    ["password_reset_confirm" /* PASSWORD_RESET_CONFIRM */]: {
+      onSuccess: "success" /* SUCCESS */,
+      onError: "password_reset_confirm" /* PASSWORD_RESET_CONFIRM */
+    }
+  }
+};
+function getFlowConfig(type) {
+  switch (type) {
+    case "simple_sign_in" /* SIMPLE_SIGN_IN */:
+      return simpleSignInFlow;
+    case "sign_in_with_mfa" /* SIGN_IN_WITH_MFA */:
+      return signInWithMFAFlow;
+    case "complete_sign_up_flow" /* COMPLETE_SIGN_UP_FLOW */:
+      return completeSignUpFlow;
+    case "magic_link_flow" /* MAGIC_LINK_FLOW */:
+      return magicLinkFlow;
+    case "phone_auth_flow" /* PHONE_AUTH_FLOW */:
+      return phoneAuthFlow;
+    case "oauth_sign_in" /* OAUTH_SIGN_IN */:
+      return oauthSignInFlow;
+    case "password_reset_flow" /* PASSWORD_RESET_FLOW */:
+      return passwordResetFlow;
+    default:
+      throw new Error(`Unknown flow type: ${type}`);
+  }
+}
+var predefinedFlows = {
+  ["simple_sign_in" /* SIMPLE_SIGN_IN */]: simpleSignInFlow,
+  ["sign_in_with_mfa" /* SIGN_IN_WITH_MFA */]: signInWithMFAFlow,
+  ["complete_sign_up_flow" /* COMPLETE_SIGN_UP_FLOW */]: completeSignUpFlow,
+  ["magic_link_flow" /* MAGIC_LINK_FLOW */]: magicLinkFlow,
+  ["phone_auth_flow" /* PHONE_AUTH_FLOW */]: phoneAuthFlow,
+  ["oauth_sign_in" /* OAUTH_SIGN_IN */]: oauthSignInFlow,
+  ["password_reset_flow" /* PASSWORD_RESET_FLOW */]: passwordResetFlow
+};
+
+exports.AuthClient = AuthClient;
+exports.AuthError = AuthError;
+exports.AuthErrorType = AuthErrorType;
+exports.AuthState = AuthState;
+exports.BaseAuthProvider = BaseAuthProvider;
+exports.FlowAction = FlowAction;
+exports.FlowConfigType = FlowConfigType;
+exports.FlowEngine = FlowEngine;
+exports.FlowStep = FlowStep;
+exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.MemoryStorageAdapter = MemoryStorageAdapter;
+exports.OAuthProvider = OAuthProvider;
+exports.Observable = Observable;
+exports.SessionStorageAdapter = SessionStorageAdapter;
+exports.TokenManager = TokenManager;
+exports.TwoFactorMethod = TwoFactorMethod;
+exports.completeSignUpFlow = completeSignUpFlow;
+exports.createAuthError = createAuthError;
+exports.getFlowConfig = getFlowConfig;
+exports.isAuthError = isAuthError;
+exports.isMFARequiredError = isMFARequiredError;
+exports.isNetworkError = isNetworkError;
+exports.isUnauthenticatedError = isUnauthenticatedError;
+exports.magicLinkFlow = magicLinkFlow;
+exports.oauthSignInFlow = oauthSignInFlow;
+exports.passwordResetFlow = passwordResetFlow;
+exports.phoneAuthFlow = phoneAuthFlow;
+exports.predefinedFlows = predefinedFlows;
+exports.signInWithMFAFlow = signInWithMFAFlow;
+exports.simpleSignInFlow = simpleSignInFlow;
+exports.toAuthError = toAuthError;
+exports.validate2FACode = validate2FACode;
+exports.validateEmail = validateEmail;
+exports.validatePassword = validatePassword;
+exports.validatePhone = validatePhone;
+exports.validateRequired = validateRequired;
+exports.validateUsername = validateUsername;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map