@absolutejs/auth 0.69.4 → 0.69.5

package/dist/client/components/react/SignUp.d.ts

@@ -0,0 +1,29 @@
+import { type FormEvent } from 'react';
+import type { AuthClient, AuthClientError } from '../../createAuthClient';
+type SignUpSuccess = {
+    status: 'authenticated';
+} | {
+    status: 'verification_required';
+};
+export type SignUpProps = {
+    client: AuthClient;
+    classNames?: {
+        button?: string;
+        container?: string;
+        error?: string;
+        field?: string;
+        input?: string;
+        label?: string;
+    };
+    emailLabel?: string;
+    onError?: (error: AuthClientError) => void;
+    onSuccess?: (result: SignUpSuccess) => void;
+    passwordLabel?: string;
+    submitLabel?: string;
+};
+export declare const SignUp: ({ client, classNames, emailLabel, onError, onSuccess, passwordLabel, submitLabel }: SignUpProps) => import("react").ReactElement<{
+    className: string | undefined;
+    'data-abs-auth': string;
+    onSubmit: (event: FormEvent<HTMLFormElement>) => Promise<void>;
+}, string | import("react").JSXElementConstructor<any>>;
+export {};

package/dist/client/components/react/UserButton.d.ts

@@ -0,0 +1,36 @@
+import type { AuthClient } from '../../createAuthClient';
+export type UserButtonUser = {
+    avatarUrl?: string;
+    email?: string;
+    givenName?: string;
+};
+export type UserButtonItem = {
+    href: string;
+    label: string;
+};
+export type UserButtonProps = {
+    client: AuthClient;
+    classNames?: {
+        avatar?: string;
+        container?: string;
+        email?: string;
+        menu?: string;
+        menuItem?: string;
+        signOut?: string;
+        toggle?: string;
+    };
+    items?: UserButtonItem[];
+    onSignOut?: () => void;
+    signedOutHref?: string;
+    signOutLabel?: string;
+    user: UserButtonUser | null;
+};
+export declare const UserButton: ({ client, classNames, items, onSignOut, signedOutHref, signOutLabel, user }: UserButtonProps) => import("react").DetailedReactHTMLElement<{
+    className: string | undefined;
+    'data-abs-auth': string;
+    href: string;
+}, HTMLElement> | import("react").DetailedReactHTMLElement<{
+    className: string | undefined;
+    'data-abs-auth': string;
+    'data-abs-auth-open': string;
+}, HTMLElement>;

package/dist/client/createAuthClient.d.ts

@@ -0,0 +1,311 @@
+import type { PublicKeyCredentialCreationOptionsJSON, PublicKeyCredentialRequestOptionsJSON } from '@simplewebauthn/browser';
+export type AuthClientError = {
+    body: unknown;
+    message: string;
+    status: number;
+};
+export type AuthClientResult<T> = {
+    data: null;
+    error: AuthClientError;
+} | {
+    data: T;
+    error: null;
+};
+export type AuthClientRoutes = {
+    emailVerify?: string;
+    emailVerifyRequest?: string;
+    login?: string;
+    magicLinkRequest?: string;
+    magicLinkVerify?: string;
+    mfaChallenge?: string;
+    mfaManagement?: string;
+    mfaSetup?: string;
+    mfaVerifySetup?: string;
+    passkeyAuthenticateOptions?: string;
+    passkeyAuthenticateVerify?: string;
+    passkeyList?: string;
+    passkeyRegisterOptions?: string;
+    passkeyRegisterVerify?: string;
+    passkeyRemove?: string;
+    passwordReset?: string;
+    passwordResetRequest?: string;
+    register?: string;
+    sessions?: string;
+    signout?: string;
+    status?: string;
+};
+export type AuthClientConfig = {
+    baseUrl?: string;
+    credentials?: RequestCredentials;
+    fetch?: AuthClientFetch;
+    routes?: AuthClientRoutes;
+    transport?: AuthClientTransport;
+};
+export type AuthClientFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type AuthClientTransport = {
+    fetch?: AuthClientFetch;
+    signInEmail?: (body: {
+        email: string;
+        password: string;
+    }) => Promise<{
+        passwordCompromised?: boolean;
+        status: 'authenticated' | 'mfa_required';
+    }>;
+    signOut?: () => Promise<null>;
+    signUpEmail?: (body: {
+        email: string;
+        password: string;
+        [extra: string]: unknown;
+    }) => Promise<{
+        status: 'authenticated';
+    } | {
+        status: 'verification_required';
+    }>;
+    status?: () => Promise<{
+        impersonator?: unknown;
+        user: unknown | null;
+    }>;
+};
+export declare const createAuthClient: ({ baseUrl, credentials, fetch: fetchImpl, routes, transport: configuredTransport }?: AuthClientConfig) => {
+    emailVerification: {
+        request: (body: {
+            email: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+        verify: (body: {
+            token: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+    };
+    mfa: {
+        challenge: (body: {
+            code: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                status: "authenticated";
+            };
+            error: null;
+        }>;
+        disable: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                status: "disabled";
+            };
+            error: null;
+        }>;
+        setup: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                secret: string;
+                uri: string;
+            };
+            error: null;
+        }>;
+        status: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: import("..").MfaStatus;
+            error: null;
+        }>;
+        verifySetup: (body: {
+            code: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                backupCodes: string[];
+            };
+            error: null;
+        }>;
+    };
+    passkeys: {
+        authenticateOptions: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: PublicKeyCredentialRequestOptionsJSON;
+            error: null;
+        }>;
+        authenticateVerify: (response: unknown) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                status: "authenticated";
+            };
+            error: null;
+        }>;
+        list: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: unknown[];
+            error: null;
+        }>;
+        registerOptions: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: PublicKeyCredentialCreationOptionsJSON;
+            error: null;
+        }>;
+        registerVerify: (response: unknown) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+        remove: (credentialId: string) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+    };
+    passwordless: {
+        requestMagicLink: (body: {
+            email: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+        verifyMagicLink: (body: {
+            token: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                status: "authenticated";
+            };
+            error: null;
+        }>;
+    };
+    passwordReset: {
+        confirm: (body: {
+            password: string;
+            token: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+        request: (body: {
+            email: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+    };
+    sessions: {
+        list: () => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: unknown[];
+            error: null;
+        }>;
+        revoke: (sessionId: string) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                ok: true;
+            };
+            error: null;
+        }>;
+    };
+    signIn: {
+        email: (body: {
+            email: string;
+            password: string;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                passwordCompromised?: boolean;
+                status: "authenticated" | "mfa_required";
+            };
+            error: null;
+        }>;
+    };
+    signUp: {
+        email: (body: {
+            email: string;
+            password: string;
+            [extra: string]: unknown;
+        }) => Promise<{
+            data: null;
+            error: AuthClientError;
+        } | {
+            data: {
+                status: "authenticated";
+            } | {
+                status: "verification_required";
+            };
+            error: null;
+        }>;
+    };
+    signOut: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: null;
+        error: null;
+    }>;
+    status: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            impersonator?: unknown;
+            user: unknown | null;
+        };
+        error: null;
+    }>;
+};
+export type AuthClient = ReturnType<typeof createAuthClient>;

package/dist/client/index.d.ts

@@ -0,0 +1,6 @@
+export * from './createAuthClient';
+export * from './sessionExpiry';
+export * from './mobile';
+export * from './runtimeTransport';
+export * from '../redirect';
+export { runConditionalAuthentication, runPasskeyRegistration } from './passkeyHelpers';

package/dist/client/mobile.d.ts

@@ -0,0 +1,87 @@
+export type MobileAuthSecureStorage = {
+    capability?: () => Promise<{
+        available: boolean;
+        message?: string;
+    }>;
+    get(key: string): Promise<string | null>;
+    remove(key: string): Promise<void>;
+    set(key: string, value: string): Promise<void>;
+};
+export type MobileAuthLinks = {
+    getLaunchUrl(): Promise<string | null>;
+    onOpen(listener: (url: string) => void): Promise<() => Promise<void> | void>;
+    openExternal(url: string): Promise<void>;
+};
+export type MobileAuthLifecycle = {
+    onResume?(listener: () => void): Promise<() => Promise<void> | void>;
+};
+export type MobileAuthDiscovery = {
+    authorization_endpoint: string;
+    code_challenge_methods_supported?: string[];
+    issuer: string;
+    jwks_uri: string;
+    revocation_endpoint?: string;
+    socket_ticket_endpoint?: string;
+    token_endpoint: string;
+    token_endpoint_auth_methods_supported?: string[];
+    userinfo_endpoint: string;
+};
+export type MobileAuthClientConfig = {
+    allowedOrigins?: readonly string[];
+    clientId: string;
+    clockSkewMs?: number;
+    fetch?: typeof globalThis.fetch;
+    issuer: string;
+    lifecycle?: MobileAuthLifecycle;
+    links: MobileAuthLinks;
+    now?: () => number;
+    redirectUri: string;
+    resource?: string;
+    scopes?: readonly string[];
+    storage: MobileAuthSecureStorage;
+};
+export type MobileAuthSignInOptions = {
+    authorizationParameters?: Readonly<Record<string, string>>;
+    signal?: AbortSignal;
+};
+export type MobileAuthTokens = {
+    accessToken: string;
+    expiresAt: number;
+    idToken: string;
+    refreshToken: string;
+    scope: string[];
+    tokenType: 'Bearer';
+};
+export type MobileAuthUser = Record<string, unknown> & {
+    sub: string;
+};
+export type MobileAuthErrorCode = 'aborted' | 'callback' | 'discovery' | 'id-token' | 'network' | 'oauth' | 'origin' | 'secure-storage' | 'token';
+export declare class MobileAuthError extends Error {
+    readonly code: MobileAuthErrorCode;
+    readonly cause?: unknown;
+    constructor(code: MobileAuthErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare const createMobileAuthClient: (config: MobileAuthClientConfig) => {
+    fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    fetchOptional: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    handleCallback: (value: string) => Promise<MobileAuthTokens>;
+    refresh: () => Promise<string>;
+    signIn: (options?: MobileAuthSignInOptions) => Promise<MobileAuthTokens>;
+    signOut: () => Promise<void>;
+    socketTicket: (audience?: string) => Promise<string>;
+    start: () => Promise<void>;
+    status: () => Promise<{
+        sub: string;
+    } | null>;
+    stop: () => Promise<void>;
+};
+export type MobileAuthClient = ReturnType<typeof createMobileAuthClient>;
+/** Adapts the native OAuth lifecycle behind the same createAuthClient API used
+ * by web applications. Passwords stay out of the WebView request path; the
+ * external authorization UI owns credential entry and MFA. */
+export declare const createMobileAuthTransport: (client: MobileAuthClient, options?: {
+    baseUrl?: string;
+}) => import("./createAuthClient").AuthClientTransport;
+export { installAuthClientRuntimeTransport } from './runtimeTransport';

package/dist/client/passkeyHelpers.d.ts

@@ -0,0 +1,19 @@
+import type { AuthClient, AuthClientError } from './createAuthClient';
+export declare const runConditionalAuthentication: (client: AuthClient) => Promise<{
+    data: null;
+    error: AuthClientError;
+} | {
+    data: {
+        status: "authenticated";
+    };
+    error: null;
+}>;
+export declare const runPasskeyRegistration: (client: AuthClient) => Promise<{
+    data: null;
+    error: AuthClientError;
+} | {
+    data: {
+        ok: true;
+    };
+    error: null;
+}>;

package/dist/client/react.d.ts

@@ -0,0 +1,87 @@
+import type { AuthClient, AuthClientError } from './createAuthClient';
+type Mutator<Args, Data> = (args: Args) => Promise<{
+    data: Data | null;
+    error: AuthClientError | null;
+}>;
+type MutationState<Args, Data> = {
+    data: Data | null;
+    error: AuthClientError | null;
+    isPending: boolean;
+    mutate: Mutator<Args, Data>;
+    reset: () => void;
+};
+export declare const useMagicLink: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useMfaChallenge: (client: AuthClient) => MutationState<{
+    code: string;
+}, {
+    status: "authenticated";
+}>;
+export declare const usePasskeyAutofill: (client: AuthClient) => {
+    cancel: () => void;
+    data: {
+        status: "authenticated";
+    } | null;
+    error: AuthClientError | null;
+    isPending: boolean;
+    start: () => Promise<void>;
+};
+export declare const usePasswordReset: (client: AuthClient) => MutationState<{
+    email: string;
+}, {
+    ok: true;
+}>;
+export declare const useSessions: (client: AuthClient) => {
+    data: unknown[] | null;
+    error: AuthClientError | null;
+    isPending: boolean;
+    refetch: () => Promise<void>;
+    revoke: (sessionId: string) => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+};
+export declare const useSignIn: (client: AuthClient) => MutationState<{
+    email: string;
+    password: string;
+}, {
+    passwordCompromised?: boolean;
+    status: "authenticated" | "mfa_required";
+}>;
+export declare const useSignOut: (client: AuthClient) => MutationState<unknown, null>;
+export declare const useSignUp: (client: AuthClient) => MutationState<{
+    [extra: string]: unknown;
+    email: string;
+    password: string;
+}, {
+    status: "authenticated";
+} | {
+    status: "verification_required";
+}>;
+export declare const useUpgradeToPasskey: (client: AuthClient) => {
+    error: AuthClientError | null;
+    isPending: boolean;
+    passkeys: unknown[] | null;
+    refetch: () => Promise<void>;
+    register: () => Promise<{
+        data: null;
+        error: AuthClientError;
+    } | {
+        data: {
+            ok: true;
+        };
+        error: null;
+    }>;
+    shouldPrompt: boolean;
+};
+export { SignIn, type SignInProps } from './components/react/SignIn';
+export { SignUp, type SignUpProps } from './components/react/SignUp';
+export { UserButton, type UserButtonItem, type UserButtonProps, type UserButtonUser } from './components/react/UserButton';

package/dist/client/runtimeTransport.d.ts

@@ -0,0 +1,3 @@
+import type { AuthClientTransport } from './createAuthClient';
+export declare const getAuthClientRuntimeTransport: () => AuthClientTransport | undefined;
+export declare const installAuthClientRuntimeTransport: (transport: AuthClientTransport) => () => void;

package/dist/client/sessionExpiry.d.ts

@@ -0,0 +1,37 @@
+export type SessionExpiredContext = {
+    returnTo: string;
+    signInUrl: string;
+};
+export type SessionExpiryGuard = {
+    check: () => Promise<boolean>;
+    dispose: () => void;
+};
+export type SessionExpiryGuardConfig = {
+    checkIntervalMs?: number;
+    isProtectedRequest?: (url: URL) => boolean;
+    onExpired?: (context: SessionExpiredContext) => void;
+    protectedPaths?: readonly string[];
+    reason?: string;
+    reasonParam?: string;
+    returnUrlParam?: string;
+    signInPath?: string;
+    statusPath?: string;
+};
+export declare const buildSessionExpiredSignInUrl: ({ currentHref, reason, reasonParam, returnUrlParam, signInPath }: {
+    currentHref: string;
+    reason?: string;
+    reasonParam?: string;
+    returnUrlParam?: string;
+    signInPath?: string;
+}) => string;
+/**
+ * Installs one browser-wide session-expiry guard. It intercepts 401 responses
+ * only for explicitly protected same-origin requests and rechecks the auth
+ * status route when a backgrounded or bfcached page becomes active again.
+ */
+export declare const installSessionExpiryGuard: (config?: SessionExpiryGuardConfig) => SessionExpiryGuard;
+export declare const isProtectedSessionRequest: ({ input, origin, protectedPaths }: {
+    input: RequestInfo | URL;
+    origin: string;
+    protectedPaths: readonly string[];
+}) => boolean;