@edgespark/web 0.0.0-beta.920378e

package/dist/auth-ui/ManagedAuthUI.d.ts

@@ -0,0 +1,85 @@
+import { BetterAuthClientInstance } from '../auth/types';
+import { NormalizedAuthUIConfig } from './config';
+import { MountAuthUIOptions, MountedAuthUI } from './types';
+export interface ManagedAuthUIRuntimeOptions {
+    syncPublicSession?: () => Promise<void> | void;
+}
+/**
+ * Internal managed auth UI implementation.
+ *
+ * The public API only exposes `authUI.mount(...)`; this class owns the DOM,
+ * form flows, and lifecycle.
+ */
+export declare class ManagedAuthUI implements MountedAuthUI {
+    private readonly container;
+    private readonly auth;
+    private readonly options;
+    private readonly loadConfig;
+    private readonly runtimeOptions?;
+    private readonly labels;
+    private readonly root;
+    private readonly state;
+    private destroyed;
+    private terminalActionInProgress;
+    private config;
+    private countdownUntil;
+    private countdownTimer;
+    private pendingFocusSnapshot;
+    private focusRestoreTimer;
+    private verificationCompletionAction;
+    constructor(container: HTMLElement, auth: BetterAuthClientInstance, options: MountAuthUIOptions, loadConfig: () => Promise<NormalizedAuthUIConfig>, runtimeOptions?: ManagedAuthUIRuntimeOptions | undefined);
+    destroy(): void;
+    private initialize;
+    private redirectAfterManagedReturnLookupFailure;
+    private navigateToRedirect;
+    private readMountSession;
+    private render;
+    private renderLoading;
+    private renderStatus;
+    private renderCurrentView;
+    private renderSignInView;
+    private renderSignUpView;
+    private renderVerifyEmailView;
+    private renderForgotPasswordView;
+    private renderResetPasswordView;
+    private renderOAuthProviders;
+    private renderInput;
+    private bindDOM;
+    private switchView;
+    private handleSignIn;
+    private handleSignUp;
+    private handleOAuthSignIn;
+    private handleForgotPassword;
+    private resendResetCode;
+    private handleResetPassword;
+    private resendVerificationEmail;
+    private sendVerificationEmail;
+    private completeAuth;
+    private retryAuthCompletionDataIfNeeded;
+    private syncPublicSessionBestEffort;
+    private resolveAuthCompletionData;
+    private completePasswordReset;
+    private handleExistingSessionOnMount;
+    private runAction;
+    private maybeHandleVerificationRequired;
+    private handleVerificationEmailSent;
+    private invokeRedirectModeSuccessHook;
+    private handleError;
+    private failValidation;
+    private getManagedReturnURL;
+    private consumeManagedReturnContext;
+    private startCountdown;
+    private clearCountdown;
+    private captureFocusSnapshot;
+    private scheduleFocusRestore;
+    private clearFocusRestoreTimer;
+    private passwordResetEndpoints;
+    private extractRedirectURL;
+    private extractUser;
+    private canUsePasswordResetEmailOtp;
+    private handleSessionlessManagedReturn;
+    private isCountdownActive;
+    private getCountdownSecondsRemaining;
+    private countdownText;
+    private escape;
+}

package/dist/auth-ui/appearance.d.ts

@@ -0,0 +1,64 @@
+export declare const AUTH_UI_THEME: {
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+};
+export declare const AUTH_UI_THEME_LIGHT: "light";
+export declare const AUTH_UI_THEME_DARK: "dark";
+export declare const AUTH_UI_THEMES: readonly ["light", "dark"];
+export declare const AUTH_UI_DEFAULT_THEME: "light";
+export type AuthUITheme = (typeof AUTH_UI_THEME)[keyof typeof AUTH_UI_THEME];
+export declare const AUTH_UI_APPEARANCE_VARIABLE: {
+    readonly BACKGROUND: "--edgespark-auth-bg";
+    readonly BACKGROUND_MUTED: "--edgespark-auth-bg-muted";
+    readonly CARD_BACKGROUND: "--edgespark-auth-card-bg";
+    readonly BORDER: "--edgespark-auth-border";
+    readonly TEXT: "--edgespark-auth-text";
+    readonly TEXT_MUTED: "--edgespark-auth-text-muted";
+    readonly DIVIDER_BACKGROUND: "--edgespark-auth-divider-bg";
+    readonly PRIMARY: "--edgespark-auth-primary";
+    readonly PRIMARY_HOVER: "--edgespark-auth-primary-hover";
+    readonly PRIMARY_CONTRAST: "--edgespark-auth-primary-contrast";
+    readonly ERROR: "--edgespark-auth-error";
+    readonly INFO: "--edgespark-auth-info";
+    readonly CARD_RADIUS: "--edgespark-auth-radius-card";
+    readonly CONTROL_RADIUS: "--edgespark-auth-radius-control";
+    readonly SHADOW: "--edgespark-auth-shadow";
+    readonly FONT: "--edgespark-auth-font";
+    readonly MODAL_BACKDROP: "--edgespark-auth-modal-backdrop";
+    readonly MODAL_CARD_BACKGROUND: "--edgespark-auth-modal-card-bg";
+    readonly MODAL_SHADOW: "--edgespark-auth-modal-shadow";
+};
+export type AuthUIAppearanceVariableName = (typeof AUTH_UI_APPEARANCE_VARIABLE)[keyof typeof AUTH_UI_APPEARANCE_VARIABLE];
+export declare const AUTH_UI_APPEARANCE_VARIABLE_NAMES: readonly AuthUIAppearanceVariableName[];
+export type AuthUIAppearanceVariables = Partial<Record<AuthUIAppearanceVariableName, string>>;
+export interface AuthUIAppearance {
+    /**
+     * Built-in visual preset for the managed auth UI root.
+     *
+     * Defaults to `"light"` when omitted. Variable overrides apply on top of the
+     * selected preset instead of replacing the entire theme contract.
+     */
+    theme?: AuthUITheme;
+    /**
+     * Optional class applied to the managed auth UI root container.
+     *
+     * Use this to scope additional app-level CSS around the stable root element.
+     */
+    className?: string;
+    /**
+     * Stable CSS custom properties supported by the managed auth UI.
+     *
+     * This is the supported appearance contract for light-touch theming. When a
+     * variable is omitted, the current theme preset keeps its default value.
+     */
+    variables?: AuthUIAppearanceVariables;
+}
+interface NormalizedAuthUIAppearance {
+    theme: AuthUITheme;
+    className: string;
+    variables: AuthUIAppearanceVariables;
+}
+export declare function isAuthUITheme(value: unknown): value is AuthUITheme;
+export declare function isAuthUIAppearanceVariableName(value: string): value is AuthUIAppearanceVariableName;
+export declare function normalizeAuthUIAppearance(appearance?: AuthUIAppearance): NormalizedAuthUIAppearance;
+export {};

package/dist/auth-ui/config.d.ts

@@ -0,0 +1,33 @@
+export type OAuthProviderId = "google" | "apple" | "microsoft" | "github" | "gitlab" | "discord";
+interface OAuthProviderBlock {
+    enabled?: boolean;
+}
+interface ProviderEmailPassword {
+    enabled?: boolean;
+    config?: {
+        minPasswordLength?: number;
+        requireEmailVerification?: boolean;
+        requirePasswordResetEmailVerification?: boolean;
+    };
+}
+interface AuthConfigResponse {
+    disableSignUp?: boolean;
+    providerEmailPassword?: ProviderEmailPassword;
+    providerGoogle?: OAuthProviderBlock;
+    providerApple?: OAuthProviderBlock;
+    providerMicrosoft?: OAuthProviderBlock;
+    providerGithub?: OAuthProviderBlock;
+    providerGitlab?: OAuthProviderBlock;
+    providerDiscord?: OAuthProviderBlock;
+}
+export interface NormalizedAuthUIConfig {
+    disableSignUp: boolean;
+    emailPasswordEnabled: boolean;
+    minPasswordLength: number;
+    requireEmailVerification: boolean;
+    passwordResetEmailOtpEnabled: boolean;
+    oauthProviders: OAuthProviderId[];
+}
+export declare function loadNormalizedAuthUIConfig(): Promise<NormalizedAuthUIConfig>;
+export declare function normalizeAuthUIConfig(config: AuthConfigResponse): NormalizedAuthUIConfig;
+export {};

package/dist/auth-ui/default-labels.d.ts

@@ -0,0 +1,2 @@
+import { AuthUILabelOverrides, AuthUILabels } from './types';
+export declare function mergeAuthUILabels(base: AuthUILabels, overrides?: AuthUILabelOverrides): AuthUILabels;

package/dist/auth-ui/index.d.ts

@@ -0,0 +1,4 @@
+export { createAuthUIModule } from './mount';
+export { AUTH_UI_APPEARANCE_VARIABLE, AUTH_UI_APPEARANCE_VARIABLE_NAMES, AUTH_UI_THEME, AUTH_UI_DEFAULT_THEME, AUTH_UI_THEME_DARK, AUTH_UI_THEME_LIGHT, AUTH_UI_THEMES, } from './appearance';
+export type { AuthUIAppearance, AuthUIAppearanceVariableName, AuthUIAppearanceVariables, AuthUITheme, } from './appearance';
+export type { AuthSuccessEvent, AuthUILabelOverrides, AuthUILabels, ControlledAuthUIOptions, EdgeSparkAuthUI, MountAuthUIOptions, MountedAuthUI, RedirectAuthUIOptions, } from './types';

package/dist/auth-ui/mount.d.ts

@@ -0,0 +1,4 @@
+import { BetterAuthClientInstance } from '../auth/types';
+import { ManagedAuthUIRuntimeOptions } from './ManagedAuthUI';
+import { EdgeSparkAuthUI } from './types';
+export declare function createAuthUIModule(auth: BetterAuthClientInstance, runtimeOptions?: ManagedAuthUIRuntimeOptions): EdgeSparkAuthUI;

package/dist/auth-ui/runtime.d.ts

@@ -0,0 +1,7 @@
+import { AuthSession, AuthUser, BetterAuthClientInstance } from '../auth/types';
+import { EdgeSparkAuthError } from '../errors';
+export declare function normalizeAuthError(error: unknown, fallbackMessage?: string): EdgeSparkAuthError;
+export declare function readCurrentSession(auth: BetterAuthClientInstance): Promise<{
+    user: AuthUser | null;
+    session: AuthSession | null;
+}>;

package/dist/auth-ui/types.d.ts

@@ -0,0 +1,156 @@
+import { AuthSession, AuthUser } from '../auth/types';
+import { EdgeSparkAuthError } from '../errors';
+import { RedirectTarget } from '../redirect';
+import { DeepPartial } from '../shared/types';
+import { AuthUIAppearance } from './appearance';
+/** Sign-in or sign-up completed with an authenticated session. */
+export type AuthenticatedAuthSuccessEvent = {
+    action: "sign-in";
+    user: AuthUser;
+    session: AuthSession;
+} | {
+    action: "sign-up";
+    user: AuthUser;
+    session: AuthSession;
+};
+/** Password was reset. No session — the user must sign in again. */
+export interface PasswordResetSuccessEvent {
+    action: "password-reset";
+    user: null;
+    session: null;
+}
+/**
+ * Payload emitted by `onSuccess` after a managed auth flow completes.
+ *
+ * Switch on `event.action` to narrow `user` and `session`:
+ * - `"sign-in"` / `"sign-up"` → `user: AuthUser`, `session: AuthSession`
+ * - `"password-reset"` → `user: null`, `session: null`
+ */
+export type AuthSuccessEvent = AuthenticatedAuthSuccessEvent | PasswordResetSuccessEvent;
+export interface AuthUILabels {
+    common: {
+        loading: string;
+        redirecting: string;
+        backToSignIn: string;
+    };
+    signIn: {
+        title: string;
+        subtitle: string;
+        emailLabel: string;
+        passwordLabel: string;
+        submitButton: string;
+        forgotPassword: string;
+        switchToSignUp: string;
+        signUpPrompt: string;
+    };
+    signUp: {
+        title: string;
+        subtitle: string;
+        nameLabel: string;
+        emailLabel: string;
+        passwordLabel: string;
+        confirmPasswordLabel: string;
+        submitButton: string;
+        switchToSignIn: string;
+        signInPrompt: string;
+    };
+    verifyEmail: {
+        title: string;
+        subtitle: string;
+        sentToLabel: string;
+        resendButton: string;
+        resendCountdown: string;
+        changeEmailButton: string;
+    };
+    forgotPassword: {
+        title: string;
+        subtitle: string;
+        emailLabel: string;
+        submitButton: string;
+    };
+    resetPassword: {
+        title: string;
+        subtitle: string;
+        codeLabel: string;
+        newPasswordLabel: string;
+        confirmPasswordLabel: string;
+        submitButton: string;
+        resendCodeButton: string;
+        resendCountdown: string;
+    };
+    oauth: {
+        dividerText: string;
+        continueWith: string;
+    };
+    errors: {
+        invalidEmail: string;
+        requiredField: string;
+        passwordTooShort: string;
+        passwordMismatch: string;
+        invalidCode: string;
+        generic: string;
+    };
+}
+export type AuthUILabelOverrides = DeepPartial<AuthUILabels>;
+interface BaseAuthUIOptions {
+    onError?: (error: EdgeSparkAuthError) => void;
+    labels?: AuthUILabelOverrides;
+    /**
+     * Optional, constrained visual customization for the managed auth UI.
+     *
+     * This is intentionally smaller than the headless auth path. Use
+     * `client.auth` when the app needs full UI ownership.
+     */
+    appearance?: AuthUIAppearance;
+}
+/**
+ * Redirect mode — use when the auth UI is a full-page login gate.
+ *
+ * After successful auth the SDK navigates to `redirectTo` automatically.
+ * This is the common case: dedicated `/login` page → redirect to `/dashboard`.
+ *
+ * `onSuccess` is optional and fires *before* the redirect (useful for analytics).
+ */
+export interface RedirectAuthUIOptions extends BaseAuthUIOptions {
+    redirectTo: RedirectTarget;
+    onSuccess?: (event: AuthSuccessEvent) => void;
+}
+/**
+ * Controlled mode — use when the app owns what happens after auth.
+ *
+ * The SDK will not navigate. Instead, `onSuccess` fires with the auth event
+ * and the app decides the next step (close a modal, update state, navigate
+ * programmatically via a router, etc.).
+ *
+ * Use this for: modals, embedded auth widgets, SPA routing, onboarding flows.
+ */
+export interface ControlledAuthUIOptions extends BaseAuthUIOptions {
+    onSuccess: (event: AuthSuccessEvent) => void;
+    redirectTo?: never;
+}
+/**
+ * Two post-auth strategies — pick one:
+ *
+ * - **Redirect mode** (`{ redirectTo }`) — SDK navigates after auth.
+ *   Best for dedicated login pages.
+ *
+ * - **Controlled mode** (`{ onSuccess }`) — app handles post-auth behavior.
+ *   Best for modals, embedded widgets, or SPA routing.
+ */
+export type MountAuthUIOptions = RedirectAuthUIOptions | ControlledAuthUIOptions;
+export interface MountedAuthUI {
+    /**
+     * Removes the mounted UI and clears internal timers/listeners.
+     */
+    destroy(): void;
+}
+export interface EdgeSparkAuthUI {
+    /**
+     * Mounts the managed auth UI into a container element.
+     *
+     * Pass `redirectTo` for the common login-page case, or `onSuccess` when the
+     * surrounding app wants to control routing/state after auth completes.
+     */
+    mount(container: HTMLElement, options: MountAuthUIOptions): MountedAuthUI;
+}
+export {};

package/dist/browser.d.ts

@@ -0,0 +1,2 @@
+export declare function assertBrowserRuntime(): void;
+export declare function getBrowserOrigin(): string;

package/dist/client.d.ts

@@ -0,0 +1,43 @@
+import { EdgeSparkApi } from './api/types';
+import { EdgeSparkAuth } from './auth/types';
+import { EdgeSparkAuthUI } from './auth-ui';
+export interface EdgeSparkClient {
+    /**
+       * Headless auth client with a better-auth-aligned API shape, plus a small
+       * set of EdgeSpark session helpers:
+       *
+       * - `requireSession()` — resolves or throws, for route guards
+       * - `onSessionChange()` — hydration-safe session observer
+       *
+       * Standard auth methods such as `signIn.email`, `signIn.social`,
+       * `signUp.email`, `signOut`, and `getSession` remain available on the same
+       * familiar shape.
+       *
+       * Some upstream better-auth methods may still be intentionally unsupported
+       * by the current EdgeSpark platform capability set. Those methods fail fast
+       * with `UNSUPPORTED_AUTH_METHOD` instead of deferring to a platform 400/404.
+     */
+    auth: EdgeSparkAuth;
+    /**
+     * Same-origin fetch wrapper for app APIs.
+     *
+     * Always sends cookie credentials. Rejects cross-origin URLs.
+     */
+    api: EdgeSparkApi;
+    /**
+     * Managed auth UI for login, sign-up, verification, and password reset flows.
+     *
+     * Mount with `{ redirectTo }` for login pages, or `{ onSuccess }` for
+     * modals and SPA routing.
+     */
+    authUI: EdgeSparkAuthUI;
+}
+/**
+ * Creates the EdgeSpark browser client.
+ *
+ * The v2 SDK is intentionally zero-config:
+ * - current page origin is always used
+ * - cookie credentials are always enabled
+ * - auth routes stay internal
+ */
+export declare function createEdgeSpark(): EdgeSparkClient;

package/dist/errors.d.ts

@@ -0,0 +1,32 @@
+/** Base error class for all EdgeSpark SDK errors. Use `instanceof` to catch. */
+export declare class EdgeSparkError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/** Programmer mistake: bad options, invalid container, cross-origin fetch, etc. */
+export declare class EdgeSparkConfigError extends EdgeSparkError {
+    constructor(message: string);
+}
+/** Called outside a browser (SSR, Node, tests without DOM). */
+export declare class EdgeSparkRuntimeError extends EdgeSparkError {
+    constructor(message: string);
+}
+/** Auth operation failed (sign-in rejected, session missing, etc.). */
+export declare class EdgeSparkAuthError extends EdgeSparkError {
+    readonly cause?: unknown;
+    readonly status?: number;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+        status?: number;
+    });
+}
+/**
+ * Normalize an unknown thrown value into an {@link EdgeSparkAuthError}.
+ *
+ * Already-normalized instances pass through unchanged. Objects with
+ * `message`/`code`/`status` fields are preserved. Plain strings become
+ * the error message. Everything else falls back to the caller-supplied
+ * defaults.
+ */
+export declare function normalizeToAuthError(error: unknown, fallbackMessage?: string, fallbackCode?: string): EdgeSparkAuthError;