@douvery/auth 0.3.0 → 0.3.2

package/dist/qwik/index.js

@@ -1,925 +1,9 @@
 import { createContextId, component$, useSignal, useContextProvider, useVisibleTask$, Slot, useContext, useTask$ } from '@builder.io/qwik';
+import { createDouveryAuth } from '@douvery/auth';
+export { DouveryAuthClient, createDouveryAuth } from '@douvery/auth';
 import { jsx } from '@builder.io/qwik/jsx-runtime';
 
 // src/qwik/index.tsx
-
-// src/types.ts
-var AuthError = class extends Error {
-  constructor(code, message, cause) {
-    super(message);
-    this.code = code;
-    this.cause = cause;
-    this.name = "AuthError";
-  }
-};
-
-// src/pkce.ts
-function generateCodeVerifier(length = 64) {
-  const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
-  const randomValues = crypto.getRandomValues(new Uint8Array(length));
-  return Array.from(randomValues).map((v) => charset[v % charset.length]).join("");
-}
-function generateState() {
-  return generateCodeVerifier(32);
-}
-function generateNonce() {
-  return generateCodeVerifier(32);
-}
-async function generateCodeChallenge(verifier) {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(verifier);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-  return base64UrlEncode(hashBuffer);
-}
-function base64UrlEncode(buffer) {
-  const bytes = new Uint8Array(buffer);
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  const base64 = btoa(binary);
-  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function base64UrlDecode(input) {
-  let base64 = input.replace(/-/g, "+").replace(/_/g, "/");
-  const padding = base64.length % 4;
-  if (padding) {
-    base64 += "=".repeat(4 - padding);
-  }
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes.buffer;
-}
-async function generatePKCEPair() {
-  const codeVerifier = generateCodeVerifier();
-  const codeChallenge = await generateCodeChallenge(codeVerifier);
-  return {
-    codeVerifier,
-    codeChallenge,
-    codeChallengeMethod: "S256"
-  };
-}
-function decodeJWT(token) {
-  const parts = token.split(".");
-  if (parts.length !== 3) {
-    throw new Error("Invalid JWT format");
-  }
-  const payload = parts[1];
-  const decoded = base64UrlDecode(payload);
-  const text = new TextDecoder().decode(decoded);
-  return JSON.parse(text);
-}
-function isTokenExpired(token, clockSkew = 60) {
-  try {
-    const payload = decodeJWT(token);
-    if (!payload.exp) {
-      return false;
-    }
-    const now = Math.floor(Date.now() / 1e3);
-    return payload.exp < now - clockSkew;
-  } catch {
-    return true;
-  }
-}
-
-// src/storage.ts
-var DEFAULT_PREFIX = "douvery_auth";
-var STORAGE_KEYS = {
-  accessToken: `${DEFAULT_PREFIX}_access_token`,
-  refreshToken: `${DEFAULT_PREFIX}_refresh_token`,
-  idToken: `${DEFAULT_PREFIX}_id_token`,
-  expiresAt: `${DEFAULT_PREFIX}_expires_at`,
-  state: `${DEFAULT_PREFIX}_state`,
-  nonce: `${DEFAULT_PREFIX}_nonce`,
-  codeVerifier: `${DEFAULT_PREFIX}_code_verifier`,
-  returnTo: `${DEFAULT_PREFIX}_return_to`
-};
-var MemoryStorage = class {
-  store = /* @__PURE__ */ new Map();
-  get(key) {
-    return this.store.get(key) ?? null;
-  }
-  set(key, value) {
-    this.store.set(key, value);
-  }
-  remove(key) {
-    this.store.delete(key);
-  }
-  clear() {
-    this.store.clear();
-  }
-};
-var LocalStorage = class {
-  get(key) {
-    if (typeof window === "undefined") return null;
-    return localStorage.getItem(key);
-  }
-  set(key, value) {
-    if (typeof window === "undefined") return;
-    localStorage.setItem(key, value);
-  }
-  remove(key) {
-    if (typeof window === "undefined") return;
-    localStorage.removeItem(key);
-  }
-  clear() {
-    if (typeof window === "undefined") return;
-    Object.values(STORAGE_KEYS).forEach((key) => {
-      localStorage.removeItem(key);
-    });
-  }
-};
-var SessionStorage = class {
-  get(key) {
-    if (typeof window === "undefined") return null;
-    return sessionStorage.getItem(key);
-  }
-  set(key, value) {
-    if (typeof window === "undefined") return;
-    sessionStorage.setItem(key, value);
-  }
-  remove(key) {
-    if (typeof window === "undefined") return;
-    sessionStorage.removeItem(key);
-  }
-  clear() {
-    if (typeof window === "undefined") return;
-    Object.values(STORAGE_KEYS).forEach((key) => {
-      sessionStorage.removeItem(key);
-    });
-  }
-};
-var CookieStorage = class {
-  constructor(options = {}) {
-    this.options = options;
-    this.options = { path: "/", secure: true, sameSite: "Lax", ...options };
-  }
-  get(key) {
-    if (typeof document === "undefined") return null;
-    const cookies = document.cookie.split(";");
-    for (const cookie of cookies) {
-      const [name, value] = cookie.trim().split("=");
-      if (name === key) {
-        return decodeURIComponent(value);
-      }
-    }
-    return null;
-  }
-  set(key, value) {
-    if (typeof document === "undefined") return;
-    const parts = [
-      `${key}=${encodeURIComponent(value)}`,
-      `path=${this.options.path}`
-    ];
-    if (this.options.domain) parts.push(`domain=${this.options.domain}`);
-    if (this.options.secure) parts.push("secure");
-    if (this.options.sameSite) parts.push(`samesite=${this.options.sameSite}`);
-    if (this.options.maxAge) parts.push(`max-age=${this.options.maxAge}`);
-    document.cookie = parts.join("; ");
-  }
-  remove(key) {
-    if (typeof document === "undefined") return;
-    document.cookie = `${key}=; path=${this.options.path}; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
-  }
-  clear() {
-    Object.values(STORAGE_KEYS).forEach((key) => this.remove(key));
-  }
-};
-function createStorage(type) {
-  switch (type) {
-    case "localStorage":
-      return new LocalStorage();
-    case "sessionStorage":
-      return new SessionStorage();
-    case "cookie":
-      return new CookieStorage();
-    case "memory":
-    default:
-      return new MemoryStorage();
-  }
-}
-var TokenManager = class {
-  constructor(storage) {
-    this.storage = storage;
-  }
-  async getTokens() {
-    const accessToken = await this.storage.get(STORAGE_KEYS.accessToken);
-    if (!accessToken) return null;
-    const refreshToken = await this.storage.get(STORAGE_KEYS.refreshToken);
-    const idToken = await this.storage.get(STORAGE_KEYS.idToken);
-    const expiresAt = await this.storage.get(STORAGE_KEYS.expiresAt);
-    return {
-      accessToken,
-      refreshToken: refreshToken ?? void 0,
-      idToken: idToken ?? void 0,
-      expiresAt: expiresAt ? parseInt(expiresAt, 10) : 0,
-      tokenType: "Bearer",
-      scope: []
-    };
-  }
-  async setTokens(tokens) {
-    await this.storage.set(STORAGE_KEYS.accessToken, tokens.accessToken);
-    await this.storage.set(STORAGE_KEYS.expiresAt, tokens.expiresAt.toString());
-    if (tokens.refreshToken) {
-      await this.storage.set(STORAGE_KEYS.refreshToken, tokens.refreshToken);
-    }
-    if (tokens.idToken) {
-      await this.storage.set(STORAGE_KEYS.idToken, tokens.idToken);
-    }
-  }
-  async clearTokens() {
-    await this.storage.remove(STORAGE_KEYS.accessToken);
-    await this.storage.remove(STORAGE_KEYS.refreshToken);
-    await this.storage.remove(STORAGE_KEYS.idToken);
-    await this.storage.remove(STORAGE_KEYS.expiresAt);
-  }
-  async saveState(state) {
-    await this.storage.set(STORAGE_KEYS.state, state);
-  }
-  async getState() {
-    return this.storage.get(STORAGE_KEYS.state);
-  }
-  async clearState() {
-    await this.storage.remove(STORAGE_KEYS.state);
-  }
-  async saveNonce(nonce) {
-    await this.storage.set(STORAGE_KEYS.nonce, nonce);
-  }
-  async getNonce() {
-    return this.storage.get(STORAGE_KEYS.nonce);
-  }
-  async clearNonce() {
-    await this.storage.remove(STORAGE_KEYS.nonce);
-  }
-  async saveCodeVerifier(verifier) {
-    await this.storage.set(STORAGE_KEYS.codeVerifier, verifier);
-  }
-  async getCodeVerifier() {
-    return this.storage.get(STORAGE_KEYS.codeVerifier);
-  }
-  async clearCodeVerifier() {
-    await this.storage.remove(STORAGE_KEYS.codeVerifier);
-  }
-  async saveReturnTo(url) {
-    await this.storage.set(STORAGE_KEYS.returnTo, url);
-  }
-  async getReturnTo() {
-    return this.storage.get(STORAGE_KEYS.returnTo);
-  }
-  async clearReturnTo() {
-    await this.storage.remove(STORAGE_KEYS.returnTo);
-  }
-  async clearAll() {
-    await this.storage.clear();
-  }
-};
-
-// src/client.ts
-var DEFAULT_ISSUER = "https://auth.douvery.com";
-var DEFAULT_SCOPES = ["openid", "profile", "email"];
-var DouveryAuthClient = class {
-  config;
-  tokenManager;
-  discovery = null;
-  eventHandlers = /* @__PURE__ */ new Set();
-  refreshTimer = null;
-  state = {
-    status: "loading",
-    user: null,
-    tokens: null,
-    error: null
-  };
-  constructor(config) {
-    this.config = {
-      issuer: DEFAULT_ISSUER,
-      scopes: DEFAULT_SCOPES,
-      storage: "localStorage",
-      autoRefresh: true,
-      refreshThreshold: 60,
-      debug: false,
-      ...config
-    };
-    const storage = config.customStorage ?? createStorage(this.config.storage ?? "localStorage");
-    this.tokenManager = new TokenManager(storage);
-  }
-  /** Initialize the auth client */
-  async initialize() {
-    this.log("Initializing auth client...");
-    try {
-      if (this.isCallback()) {
-        this.log("Handling OAuth callback...");
-        const result = await this.handleCallback();
-        if (result.success && result.user && result.tokens) {
-          this.updateState({
-            status: "authenticated",
-            user: result.user,
-            tokens: result.tokens,
-            error: null
-          });
-          this.setupAutoRefresh();
-        } else {
-          this.updateState({
-            status: "unauthenticated",
-            user: null,
-            tokens: null,
-            error: result.error ?? null
-          });
-        }
-      } else {
-        const tokens = await this.tokenManager.getTokens();
-        if (tokens && tokens.accessToken) {
-          if (!isTokenExpired(tokens.accessToken)) {
-            this.log("Found valid existing session");
-            const user = await this.fetchUser(tokens.accessToken);
-            this.updateState({
-              status: "authenticated",
-              user,
-              tokens,
-              error: null
-            });
-            this.setupAutoRefresh();
-          } else if (tokens.refreshToken) {
-            this.log("Access token expired, attempting refresh...");
-            await this.refreshTokens();
-          } else {
-            this.log("Session expired, no refresh token");
-            await this.tokenManager.clearTokens();
-            this.updateState({
-              status: "unauthenticated",
-              user: null,
-              tokens: null,
-              error: null
-            });
-          }
-        } else {
-          this.log("No existing session found");
-          this.updateState({
-            status: "unauthenticated",
-            user: null,
-            tokens: null,
-            error: null
-          });
-        }
-      }
-      this.emit({ type: "INITIALIZED" });
-    } catch (error) {
-      this.log("Initialization error:", error);
-      this.updateState({
-        status: "unauthenticated",
-        user: null,
-        tokens: null,
-        error: error instanceof AuthError ? error : new AuthError(
-          "unknown_error",
-          "Initialization failed",
-          error
-        )
-      });
-    }
-    return this.state;
-  }
-  /** Start the login flow */
-  async login(options = {}) {
-    this.log("Starting login flow...");
-    this.emit({ type: "LOGIN_STARTED" });
-    try {
-      const discovery = await this.getDiscovery();
-      const pkce = await generatePKCEPair();
-      const state = generateState();
-      const nonce = generateNonce();
-      await this.tokenManager.saveState(state);
-      await this.tokenManager.saveNonce(nonce);
-      await this.tokenManager.saveCodeVerifier(pkce.codeVerifier);
-      if (options.returnTo) {
-        await this.tokenManager.saveReturnTo(options.returnTo);
-      }
-      const params = new URLSearchParams({
-        response_type: "code",
-        client_id: this.config.clientId,
-        redirect_uri: this.config.redirectUri,
-        scope: this.config.scopes.join(" "),
-        state,
-        nonce,
-        code_challenge: pkce.codeChallenge,
-        code_challenge_method: pkce.codeChallengeMethod,
-        ...options.authorizationParams
-      });
-      if (options.prompt) params.set("prompt", options.prompt);
-      if (options.loginHint) params.set("login_hint", options.loginHint);
-      if (options.uiLocales) params.set("ui_locales", options.uiLocales);
-      if (options.maxAge !== void 0)
-        params.set("max_age", options.maxAge.toString());
-      if (options.acrValues) params.set("acr_values", options.acrValues);
-      const authUrl = `${discovery.authorization_endpoint}?${params}`;
-      this.log("Redirecting to:", authUrl);
-      window.location.href = authUrl;
-    } catch (error) {
-      const authError = error instanceof AuthError ? error : new AuthError(
-        "configuration_error",
-        "Login failed",
-        error
-      );
-      this.emit({ type: "LOGIN_ERROR", error: authError });
-      throw authError;
-    }
-  }
-  /** Logout the user */
-  async logout(options = {}) {
-    this.log("Starting logout...");
-    this.emit({ type: "LOGOUT_STARTED" });
-    try {
-      await this.tokenManager.clearAll();
-      this.clearAutoRefresh();
-      this.updateState({
-        status: "unauthenticated",
-        user: null,
-        tokens: null,
-        error: null
-      });
-      if (options.localOnly) {
-        this.emit({ type: "LOGOUT_SUCCESS" });
-        return;
-      }
-      if (options.federated !== false) {
-        const discovery = await this.getDiscovery();
-        if (discovery.end_session_endpoint) {
-          const params = new URLSearchParams();
-          if (this.state.tokens?.idToken) {
-            params.set("id_token_hint", this.state.tokens.idToken);
-          }
-          if (options.returnTo || this.config.postLogoutRedirectUri) {
-            params.set(
-              "post_logout_redirect_uri",
-              options.returnTo || this.config.postLogoutRedirectUri
-            );
-          }
-          params.set("client_id", this.config.clientId);
-          const logoutUrl = `${discovery.end_session_endpoint}?${params}`;
-          this.log("Redirecting to logout:", logoutUrl);
-          window.location.href = logoutUrl;
-          return;
-        }
-      }
-      this.emit({ type: "LOGOUT_SUCCESS" });
-      if (options.returnTo) {
-        window.location.href = options.returnTo;
-      }
-    } catch (error) {
-      const authError = error instanceof AuthError ? error : new AuthError("unknown_error", "Logout failed", error);
-      this.emit({ type: "LOGOUT_ERROR", error: authError });
-      throw authError;
-    }
-  }
-  /** Check if current URL is an OAuth callback */
-  isCallback() {
-    if (typeof window === "undefined") return false;
-    const params = new URLSearchParams(window.location.search);
-    return params.has("code") || params.has("error");
-  }
-  /** Handle the OAuth callback */
-  async handleCallback() {
-    this.log("Processing callback...");
-    if (typeof window === "undefined") {
-      return {
-        success: false,
-        error: new AuthError(
-          "configuration_error",
-          "Cannot handle callback on server"
-        )
-      };
-    }
-    const params = new URLSearchParams(window.location.search);
-    const code = params.get("code");
-    const stateParam = params.get("state");
-    const errorParam = params.get("error");
-    const errorDescription = params.get("error_description");
-    if (errorParam) {
-      const error = new AuthError(
-        errorParam,
-        errorDescription ?? "Authorization failed"
-      );
-      return { success: false, error };
-    }
-    const savedState = await this.tokenManager.getState();
-    if (!stateParam || stateParam !== savedState) {
-      return {
-        success: false,
-        error: new AuthError("state_mismatch", "State parameter mismatch")
-      };
-    }
-    if (!code) {
-      return {
-        success: false,
-        error: new AuthError(
-          "invalid_request",
-          "No authorization code received"
-        )
-      };
-    }
-    const codeVerifier = await this.tokenManager.getCodeVerifier();
-    if (!codeVerifier) {
-      return {
-        success: false,
-        error: new AuthError("pkce_error", "No code verifier found")
-      };
-    }
-    try {
-      const tokens = await this.exchangeCode(code, codeVerifier);
-      await this.tokenManager.setTokens(tokens);
-      const user = await this.fetchUser(tokens.accessToken);
-      const returnTo = await this.tokenManager.getReturnTo();
-      await this.tokenManager.clearState();
-      await this.tokenManager.clearNonce();
-      await this.tokenManager.clearCodeVerifier();
-      await this.tokenManager.clearReturnTo();
-      window.history.replaceState({}, "", window.location.pathname);
-      this.emit({ type: "LOGIN_SUCCESS", user, tokens });
-      return { success: true, user, tokens, returnTo: returnTo ?? void 0 };
-    } catch (error) {
-      const authError = error instanceof AuthError ? error : new AuthError(
-        "invalid_grant",
-        "Token exchange failed",
-        error
-      );
-      this.emit({ type: "LOGIN_ERROR", error: authError });
-      return { success: false, error: authError };
-    }
-  }
-  async exchangeCode(code, codeVerifier) {
-    const discovery = await this.getDiscovery();
-    const response = await fetch(discovery.token_endpoint, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
-        grant_type: "authorization_code",
-        code,
-        redirect_uri: this.config.redirectUri,
-        client_id: this.config.clientId,
-        code_verifier: codeVerifier
-      })
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      throw new AuthError(
-        error.error ?? "invalid_grant",
-        error.error_description ?? "Token exchange failed"
-      );
-    }
-    const tokenSet = await response.json();
-    return this.tokenSetToInfo(tokenSet);
-  }
-  /** Refresh the access token */
-  async refreshTokens() {
-    this.log("Refreshing tokens...");
-    const tokens = await this.tokenManager.getTokens();
-    if (!tokens?.refreshToken) {
-      throw new AuthError("token_refresh_failed", "No refresh token available");
-    }
-    const discovery = await this.getDiscovery();
-    const response = await fetch(discovery.token_endpoint, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
-        grant_type: "refresh_token",
-        refresh_token: tokens.refreshToken,
-        client_id: this.config.clientId
-      })
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      const authError = new AuthError(
-        error.error ?? "token_refresh_failed",
-        error.error_description ?? "Token refresh failed"
-      );
-      this.emit({ type: "TOKEN_REFRESH_ERROR", error: authError });
-      await this.tokenManager.clearTokens();
-      this.updateState({
-        status: "unauthenticated",
-        user: null,
-        tokens: null,
-        error: authError
-      });
-      this.emit({ type: "SESSION_EXPIRED" });
-      throw authError;
-    }
-    const tokenSet = await response.json();
-    const newTokens = this.tokenSetToInfo(tokenSet);
-    await this.tokenManager.setTokens(newTokens);
-    const user = newTokens.idToken ? this.extractUserFromIdToken(newTokens.idToken) : this.state.user;
-    this.updateState({ ...this.state, tokens: newTokens, user });
-    this.emit({ type: "TOKEN_REFRESHED", tokens: newTokens });
-    this.setupAutoRefresh();
-    return newTokens;
-  }
-  /** Get current access token (auto-refreshes if needed) */
-  async getAccessToken() {
-    const tokens = await this.tokenManager.getTokens();
-    if (!tokens) return null;
-    if (isTokenExpired(tokens.accessToken)) {
-      if (tokens.refreshToken) {
-        const newTokens = await this.refreshTokens();
-        return newTokens.accessToken;
-      }
-      return null;
-    }
-    return tokens.accessToken;
-  }
-  // ============================================
-  // Navigation Methods
-  // ============================================
-  /** Redirect to select/switch account */
-  selectAccount(options = {}) {
-    const url = this.buildSelectAccountUrl(options);
-    this.navigate(url, options);
-  }
-  /** Build select-account URL without redirecting */
-  buildSelectAccountUrl(options = {}) {
-    const params = new URLSearchParams();
-    if (options.returnTo) params.set("continue", options.returnTo);
-    if (options.clientId) params.set("client_id", options.clientId);
-    if (options.loginHint) params.set("login_hint", options.loginHint);
-    return this.createAuthUrl("/select-account", params);
-  }
-  /** Redirect to add another account (multi-session) */
-  addAccount(options = {}) {
-    const url = this.buildAddAccountUrl(options);
-    this.navigate(url, options);
-  }
-  /** Build add-account URL without redirecting */
-  buildAddAccountUrl(options = {}) {
-    const params = new URLSearchParams({ add_account: "true" });
-    if (options.returnTo) params.set("continue", options.returnTo);
-    if (options.clientId) params.set("client_id", options.clientId);
-    if (options.loginHint) params.set("login_hint", options.loginHint);
-    return this.createAuthUrl("/login", params);
-  }
-  /** Redirect to register a new account */
-  register(options = {}) {
-    const url = this.buildRegisterUrl(options);
-    this.navigate(url, options);
-  }
-  /** Build register URL without redirecting */
-  buildRegisterUrl(options = {}) {
-    const params = new URLSearchParams();
-    if (options.returnTo) params.set("continue", options.returnTo);
-    if (options.clientId) params.set("client_id", options.clientId);
-    if (options.email) params.set("email", options.email);
-    if (options.firstName) params.set("first_name", options.firstName);
-    if (options.lastName) params.set("last_name", options.lastName);
-    if (options.uiLocales) params.set("ui_locales", options.uiLocales);
-    return this.createAuthUrl("/register", params);
-  }
-  /** Redirect to recover account (forgot password) */
-  recoverAccount(options = {}) {
-    const url = this.buildRecoverAccountUrl(options);
-    this.navigate(url, options);
-  }
-  /** Build recover-account URL without redirecting */
-  buildRecoverAccountUrl(options = {}) {
-    const params = new URLSearchParams();
-    if (options.returnTo) params.set("continue", options.returnTo);
-    if (options.clientId) params.set("client_id", options.clientId);
-    if (options.email) params.set("email", options.email);
-    return this.createAuthUrl("/recover-account", params);
-  }
-  /** Redirect to verify account (email verification) */
-  verifyAccount(options = {}) {
-    const url = this.buildVerifyAccountUrl(options);
-    this.navigate(url, options);
-  }
-  /** Build verify-account URL without redirecting */
-  buildVerifyAccountUrl(options = {}) {
-    const params = new URLSearchParams();
-    if (options.returnTo) params.set("continue", options.returnTo);
-    if (options.clientId) params.set("client_id", options.clientId);
-    if (options.email) params.set("email", options.email);
-    return this.createAuthUrl("/verify-account", params);
-  }
-  /** Redirect to upgrade account (guest → full account) */
-  upgradeAccount(options = {}) {
-    const url = this.buildUpgradeAccountUrl(options);
-    this.navigate(url, options);
-  }
-  /** Build upgrade-account URL without redirecting */
-  buildUpgradeAccountUrl(options = {}) {
-    const params = new URLSearchParams();
-    if (options.returnTo) params.set("continue", options.returnTo);
-    if (options.clientId) params.set("client_id", options.clientId);
-    if (options.scopes?.length) params.set("scope", options.scopes.join(" "));
-    return this.createAuthUrl("/upgrade-account", params);
-  }
-  /** Redirect to passkey setup */
-  setupPasskey(options = {}) {
-    const url = this.buildSetupPasskeyUrl(options);
-    this.navigate(url, options);
-  }
-  /** Build setup-passkey URL without redirecting */
-  buildSetupPasskeyUrl(options = {}) {
-    const params = new URLSearchParams();
-    if (options.returnTo) params.set("continue", options.returnTo);
-    if (options.clientId) params.set("client_id", options.clientId);
-    return this.createAuthUrl("/setup-passkey", params);
-  }
-  /** Redirect to address setup */
-  setupAddress(options = {}) {
-    const url = this.buildSetupAddressUrl(options);
-    this.navigate(url, options);
-  }
-  /** Build setup-address URL without redirecting */
-  buildSetupAddressUrl(options = {}) {
-    const params = new URLSearchParams();
-    if (options.returnTo) params.set("continue", options.returnTo);
-    if (options.clientId) params.set("client_id", options.clientId);
-    return this.createAuthUrl("/setup-address", params);
-  }
-  /** Build a login URL without redirecting (useful for links/buttons) */
-  buildLoginUrl(options = {}) {
-    const params = new URLSearchParams();
-    if (options.returnTo) params.set("continue", options.returnTo);
-    if (options.loginHint) params.set("email", options.loginHint);
-    if (options.prompt) params.set("prompt", options.prompt);
-    if (options.uiLocales) params.set("ui_locales", options.uiLocales);
-    return this.createAuthUrl("/login", params);
-  }
-  /** Build a logout URL without redirecting */
-  buildLogoutUrl(options = {}) {
-    const params = new URLSearchParams();
-    if (options.returnTo) params.set("continue", options.returnTo);
-    return this.createAuthUrl("/logout", params);
-  }
-  /** Revoke a token (access or refresh) */
-  async revokeToken(options = {}) {
-    this.log("Revoking token...");
-    const token = options.token ?? (await this.tokenManager.getTokens())?.accessToken;
-    if (!token) {
-      throw new AuthError("invalid_token", "No token to revoke");
-    }
-    const revokeUrl = `${this.config.issuer}/oauth/revoke`;
-    const body = new URLSearchParams({
-      token,
-      client_id: this.config.clientId
-    });
-    if (options.tokenTypeHint) {
-      body.set("token_type_hint", options.tokenTypeHint);
-    }
-    const response = await fetch(revokeUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      throw new AuthError(
-        error.error ?? "server_error",
-        error.error_description ?? "Token revocation failed"
-      );
-    }
-    this.log("Token revoked successfully");
-  }
-  /** Check if the user's session is expired */
-  isSessionExpired() {
-    if (!this.state.tokens) return true;
-    return isTokenExpired(this.state.tokens.accessToken);
-  }
-  /** Check if user needs email verification */
-  needsEmailVerification() {
-    return this.state.user?.emailVerified === false;
-  }
-  /** Check if user is a guest account */
-  isGuestAccount() {
-    return this.state.user?.accountType === "guest";
-  }
-  tokenSetToInfo(tokenSet) {
-    return {
-      accessToken: tokenSet.access_token,
-      refreshToken: tokenSet.refresh_token,
-      idToken: tokenSet.id_token,
-      expiresAt: Date.now() + tokenSet.expires_in * 1e3,
-      tokenType: tokenSet.token_type,
-      scope: tokenSet.scope?.split(" ") ?? []
-    };
-  }
-  /** Build an AuthUrl object for a given path and params */
-  createAuthUrl(path, params) {
-    const query = params.toString();
-    const url = `${this.config.issuer}${path}${query ? `?${query}` : ""}`;
-    return {
-      url,
-      redirect: () => {
-        window.location.href = url;
-      },
-      open: () => {
-        return window.open(url, "_blank");
-      }
-    };
-  }
-  /** Navigate to an auth URL, respecting openInNewTab option */
-  navigate(authUrl, options) {
-    if (options.openInNewTab) {
-      authUrl.open();
-    } else {
-      authUrl.redirect();
-    }
-  }
-  async fetchUser(accessToken) {
-    const discovery = await this.getDiscovery();
-    const response = await fetch(discovery.userinfo_endpoint, {
-      headers: { Authorization: `Bearer ${accessToken}` }
-    });
-    if (!response.ok) {
-      throw new AuthError("invalid_token", "Failed to fetch user info");
-    }
-    const userInfo = await response.json();
-    return this.normalizeUser(userInfo);
-  }
-  extractUserFromIdToken(idToken) {
-    const claims = decodeJWT(idToken);
-    return this.normalizeUser(claims);
-  }
-  normalizeUser(claims) {
-    return {
-      id: claims.sub,
-      email: claims.email,
-      emailVerified: claims.email_verified,
-      name: claims.name,
-      firstName: claims.given_name,
-      lastName: claims.family_name,
-      picture: claims.picture,
-      phoneNumber: claims.phone_number,
-      phoneNumberVerified: claims.phone_number_verified,
-      locale: claims.locale,
-      ...claims
-    };
-  }
-  async getDiscovery() {
-    if (this.discovery) return this.discovery;
-    const discoveryUrl = `${this.config.issuer}/.well-known/openid-configuration`;
-    const response = await fetch(discoveryUrl);
-    if (!response.ok) {
-      throw new AuthError(
-        "configuration_error",
-        "Failed to fetch discovery document"
-      );
-    }
-    this.discovery = await response.json();
-    return this.discovery;
-  }
-  setupAutoRefresh() {
-    if (!this.config.autoRefresh || !this.state.tokens) return;
-    this.clearAutoRefresh();
-    const expiresIn = this.state.tokens.expiresAt - Date.now();
-    const refreshIn = expiresIn - this.config.refreshThreshold * 1e3;
-    if (refreshIn > 0) {
-      this.log(`Scheduling token refresh in ${Math.round(refreshIn / 1e3)}s`);
-      this.refreshTimer = setTimeout(() => {
-        this.refreshTokens().catch(
-          (error) => this.log("Auto-refresh failed:", error)
-        );
-      }, refreshIn);
-    }
-  }
-  clearAutoRefresh() {
-    if (this.refreshTimer) {
-      clearTimeout(this.refreshTimer);
-      this.refreshTimer = null;
-    }
-  }
-  getState() {
-    return { ...this.state };
-  }
-  isAuthenticated() {
-    return this.state.status === "authenticated";
-  }
-  getUser() {
-    return this.state.user;
-  }
-  subscribe(handler) {
-    this.eventHandlers.add(handler);
-    return () => this.eventHandlers.delete(handler);
-  }
-  updateState(newState) {
-    this.state = newState;
-  }
-  emit(event) {
-    this.eventHandlers.forEach((handler) => {
-      try {
-        handler(event);
-      } catch (error) {
-        console.error("Event handler error:", error);
-      }
-    });
-  }
-  log(...args) {
-    if (this.config.debug) {
-      console.log("[DouveryAuth]", ...args);
-    }
-  }
-};
-function createDouveryAuth(config) {
-  return new DouveryAuthClient(config);
-}
 var DouveryAuthContext = createContextId("douvery-auth");
 var DouveryAuthProvider = component$(
   ({ config }) => {
@@ -1080,6 +164,6 @@ function useSessionStatus() {
   return { isExpired, needsVerification, isGuest };
 }
 
-export { DouveryAuthClient, DouveryAuthContext, DouveryAuthProvider, createDouveryAuth, useAuthActions, useAuthUrls, useDouveryAuth, useIsAuthenticated, useSessionStatus, useUser };
+export { DouveryAuthContext, DouveryAuthProvider, useAuthActions, useAuthUrls, useDouveryAuth, useIsAuthenticated, useSessionStatus, useUser };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map