@atlasauth/react 0.13.0 → 0.15.0

package/dist/compat.d.ts

@@ -0,0 +1,307 @@
+/**
+ * Drop-in compatibility helpers for apps moving to Atlas from Auth.js (NextAuth),
+ * Auth0 (auth0-react / nextjs-auth0), Supabase Auth and Better Auth.
+ *
+ * `atlas migrate code --from <vendor>` rewrites an app's imports onto these, so
+ * the migrated code keeps the shapes it was written against (`{ data, status }`
+ * from `useSession`, `{ isAuthenticated, user }` from `useAuth0`, …) and compiles
+ * and runs on day one. Each helper is a thin projection over the native hooks
+ * (`useUser`, `useAuth`); once migrated, move call sites to those at your own pace.
+ *
+ * The imperative helpers (`nextAuthSignOut()`, `getSupabaseUserCompat()`, …) work
+ * outside React components too: they act on the `<AtlasProvider>` mounted on the
+ * page. Calling one with no provider mounted throws a clear error.
+ */
+import { type ComponentType, type ReactNode } from 'react';
+import type { AtlasUser, SessionClaims } from './types';
+import { type ActiveAtlas } from './active-atlas';
+export { getActiveAtlas, type ActiveAtlas } from './active-atlas';
+/** The primary email address, else the first verified one, else any. */
+export declare function primaryEmail(user: AtlasUser | null): {
+    address: string;
+    verified: boolean;
+} | null;
+/** A display name: first + last, else the username, else null. */
+export declare function displayName(user: AtlasUser | null): string | null;
+/** Send the browser to your sign-in page, returning to `redirectUrl` afterwards. */
+export declare function signInRedirect(options?: {
+    signInUrl?: string;
+    redirectUrl?: string;
+}): void;
+/** The `session` object `next-auth`'s `useSession()` / `getSession()` resolve to. */
+export interface NextAuthCompatSession {
+    user: {
+        id: string;
+        name: string | null;
+        email: string | null;
+        image: string | null;
+    };
+    expires: string;
+}
+export type NextAuthCompatStatus = 'loading' | 'authenticated' | 'unauthenticated';
+/** Pure projection of the provider state onto next-auth's session shape. */
+export declare function nextAuthSessionFrom(state: Pick<ActiveAtlas, 'status' | 'user' | 'claims'>): {
+    data: NextAuthCompatSession | null;
+    status: NextAuthCompatStatus;
+};
+/** `useSession()` from `next-auth/react`, on Atlas: `{ data, status, update }`. */
+export declare function useNextAuthSession(): {
+    data: NextAuthCompatSession | null;
+    status: NextAuthCompatStatus;
+    update: () => Promise<NextAuthCompatSession | null>;
+};
+/** `getSession()` from `next-auth/react` (client side): the current session or null. */
+export declare function getNextAuthSession(): Promise<NextAuthCompatSession | null>;
+/**
+ * `signIn()` from `next-auth/react`: opens your Atlas sign-in page. The provider
+ * argument is accepted for compatibility; the sign-in page lists every enabled
+ * method (render `<SocialSignInButton provider="github" />` to go straight to one).
+ */
+export declare function nextAuthSignIn(_provider?: string, options?: {
+    callbackUrl?: string;
+    redirectTo?: string;
+    signInUrl?: string;
+}): Promise<void>;
+/** `signOut()` from `next-auth/react`: signs out, then goes to `callbackUrl` (default `/`). */
+export declare function nextAuthSignOut(options?: {
+    callbackUrl?: string;
+    redirectTo?: string;
+    redirect?: boolean;
+}): Promise<void>;
+/** The OIDC-profile user `useAuth0()` / nextjs-auth0's `useUser()` expose. */
+export interface Auth0CompatUser {
+    sub: string;
+    name?: string;
+    given_name?: string;
+    family_name?: string;
+    nickname?: string;
+    picture?: string;
+    email?: string;
+    email_verified?: boolean;
+    org_id?: string;
+    [claim: string]: unknown;
+}
+/** Project an Atlas user onto the OIDC profile shape Auth0 SDKs return. */
+export declare function auth0UserFrom(user: AtlasUser | null, claims?: SessionClaims | null): Auth0CompatUser | undefined;
+/** `loginWithRedirect()` options this helper understands (others are ignored). */
+export interface Auth0CompatLoginOptions {
+    appState?: {
+        returnTo?: string;
+        [key: string]: unknown;
+    };
+    /** Where your Atlas sign-in page lives (default `/sign-in`). */
+    signInUrl?: string;
+}
+export interface Auth0CompatLogoutOptions {
+    logoutParams?: {
+        returnTo?: string;
+        [key: string]: unknown;
+    };
+    /** `false` skips the redirect, like auth0-react's `openUrl: false`. */
+    openUrl?: false;
+}
+/** Thrown by `getAccessTokenSilently()` when nobody is signed in (Auth0's `login_required`). */
+export declare class LoginRequiredError extends Error {
+    readonly error = "login_required";
+    constructor();
+}
+/** `useAuth0()` from `@auth0/auth0-react`, on Atlas. */
+export declare function useAuth0Compat<TUser extends Auth0CompatUser = Auth0CompatUser>(): {
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    user: TUser | undefined;
+    error: undefined;
+    loginWithRedirect(options?: Auth0CompatLoginOptions): Promise<void>;
+    logout(options?: Auth0CompatLogoutOptions): Promise<void>;
+    getAccessTokenSilently(options?: {
+        template?: string;
+    }): Promise<string>;
+    getIdTokenClaims(): Promise<(SessionClaims & {
+        __raw?: string;
+    }) | undefined>;
+};
+/** `useUser()` from `@auth0/nextjs-auth0/client` (v3) or `@auth0/nextjs-auth0` (v4). */
+export declare function useAuth0UserCompat<TUser extends Auth0CompatUser = Auth0CompatUser>(): {
+    user: TUser | undefined;
+    error: undefined;
+    isLoading: boolean;
+    checkSession(): Promise<void>;
+    invalidate(): Promise<void>;
+};
+/**
+ * `withAuthenticationRequired(Component, options)` from `@auth0/auth0-react` (and
+ * nextjs-auth0's client `withPageAuthRequired`): renders the component only for a
+ * signed-in user and sends everyone else to your sign-in page.
+ */
+export declare function withAuthenticationRequiredCompat<P extends object>(Component: ComponentType<P>, options?: {
+    onRedirecting?: () => ReactNode;
+    returnTo?: string | (() => string);
+    signInUrl?: string;
+}): ComponentType<P>;
+/** The `User` object `supabase.auth.getUser()` resolves to (the fields apps read). */
+export interface SupabaseCompatUser {
+    id: string;
+    aud: 'authenticated';
+    role: 'authenticated';
+    email?: string;
+    email_confirmed_at?: string;
+    phone?: string;
+    user_metadata: Record<string, unknown>;
+    app_metadata: Record<string, unknown>;
+}
+export declare function supabaseUserFrom(user: AtlasUser | null): SupabaseCompatUser | null;
+type SupabaseResult<T> = {
+    data: T;
+    error: null;
+};
+/** `supabase.auth.getUser()` in the browser. */
+export declare function getSupabaseUserCompat(): Promise<SupabaseResult<{
+    user: SupabaseCompatUser | null;
+}>>;
+/** `supabase.auth.getSession()` in the browser; `access_token` is the Atlas session JWT. */
+export declare function getSupabaseSessionCompat(): Promise<SupabaseResult<{
+    session: {
+        access_token: string;
+        expires_at: number | undefined;
+        user: SupabaseCompatUser;
+    } | null;
+}>>;
+/** `useUser()` from `@supabase/auth-helpers-react`: the user, or null. */
+export declare function useSupabaseUserCompat(): SupabaseCompatUser | null;
+/** `useSession()` from `@supabase/auth-helpers-react`: `{ user, expires_at }`, or null. */
+export declare function useSupabaseSessionCompat(): {
+    user: SupabaseCompatUser;
+    expires_at: number | undefined;
+} | null;
+/** `supabase.auth.signOut()` in the browser. */
+export declare function supabaseSignOutCompat(): Promise<{
+    error: null;
+}>;
+/** `supabase.auth.signInWithOAuth({ provider, options: { redirectTo } })`: opens your sign-in page. */
+export declare function supabaseSignInWithOAuthCompat(credentials?: {
+    provider?: string;
+    options?: {
+        redirectTo?: string;
+        signInUrl?: string;
+    };
+}): Promise<{
+    data: {
+        provider?: string;
+        url: string;
+    };
+    error: null;
+}>;
+/**
+ * `supabase.auth.onAuthStateChange(callback)`: the callback fires with
+ * `SIGNED_IN` / `SIGNED_OUT` / `USER_UPDATED` as the Atlas session changes.
+ */
+export declare function onSupabaseAuthStateChangeCompat(callback: (event: 'INITIAL_SESSION' | 'SIGNED_IN' | 'SIGNED_OUT' | 'USER_UPDATED', session: {
+    user: SupabaseCompatUser;
+} | null) => void): {
+    data: {
+        subscription: {
+            unsubscribe(): void;
+        };
+    };
+};
+/** The `{ user, session }` pair Better Auth's `useSession()` / `getSession()` return. */
+export interface BetterAuthCompatSession {
+    user: {
+        id: string;
+        email: string | null;
+        emailVerified: boolean;
+        name: string | null;
+        image: string | null;
+    };
+    session: {
+        id: string;
+        userId: string;
+        expiresAt: Date;
+        activeOrganizationId: string | null;
+    };
+}
+export declare function betterAuthSessionFrom(state: Pick<ActiveAtlas, 'status' | 'user' | 'claims'>): BetterAuthCompatSession | null;
+export interface BetterAuthCompatClientOptions {
+    /** Where your Atlas sign-in page lives (default `/sign-in`). */
+    signInUrl?: string;
+    /** Where your Atlas sign-up page lives (default `/sign-up`). */
+    signUpUrl?: string;
+    /** Accepted (and ignored) so `createAuthClient({ baseURL })` call sites keep compiling. */
+    baseURL?: string;
+    [option: string]: unknown;
+}
+/**
+ * `createAuthClient()` from `better-auth/react`, on Atlas. The returned object has
+ * the same `useSession`, `getSession`, `signIn.social`, `signIn.email`, `signUp.email`
+ * and `signOut` members. The sign-in/up members open your Atlas pages (Atlas
+ * collects credentials on its own forms, never in app code).
+ */
+export declare function createBetterAuthCompatClient(options?: BetterAuthCompatClientOptions): {
+    /** Type-only, like Better Auth's `authClient.$Infer.Session`. */
+    $Infer: {
+        Session: BetterAuthCompatSession;
+    };
+    useSession(): {
+        data: BetterAuthCompatSession | null;
+        isPending: boolean;
+        error: null;
+        refetch: () => Promise<void>;
+    };
+    getSession(): Promise<{
+        data: BetterAuthCompatSession | null;
+        error: null;
+    }>;
+    signIn: {
+        social(input?: {
+            provider?: string;
+            callbackURL?: string;
+        }): Promise<{
+            data: {
+                redirect: boolean;
+            };
+            error: null;
+        }>;
+        email(input?: {
+            callbackURL?: string;
+        }): Promise<{
+            data: {
+                redirect: boolean;
+            };
+            error: null;
+        }>;
+        magicLink(input?: {
+            callbackURL?: string;
+        }): Promise<{
+            data: {
+                redirect: boolean;
+            };
+            error: null;
+        }>;
+        passkey(): Promise<{
+            data: {
+                redirect: boolean;
+            };
+            error: null;
+        }>;
+    };
+    signUp: {
+        email(input?: {
+            callbackURL?: string;
+        }): Promise<{
+            data: {
+                redirect: boolean;
+            };
+            error: null;
+        }>;
+    };
+    signOut(input?: {
+        fetchOptions?: {
+            onSuccess?: () => void;
+        };
+    }): Promise<{
+        data: {
+            success: boolean;
+        };
+        error: null;
+    }>;
+};

package/dist/compat.js

@@ -0,0 +1,387 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoginRequiredError = exports.getActiveAtlas = void 0;
+exports.primaryEmail = primaryEmail;
+exports.displayName = displayName;
+exports.signInRedirect = signInRedirect;
+exports.nextAuthSessionFrom = nextAuthSessionFrom;
+exports.useNextAuthSession = useNextAuthSession;
+exports.getNextAuthSession = getNextAuthSession;
+exports.nextAuthSignIn = nextAuthSignIn;
+exports.nextAuthSignOut = nextAuthSignOut;
+exports.auth0UserFrom = auth0UserFrom;
+exports.useAuth0Compat = useAuth0Compat;
+exports.useAuth0UserCompat = useAuth0UserCompat;
+exports.withAuthenticationRequiredCompat = withAuthenticationRequiredCompat;
+exports.supabaseUserFrom = supabaseUserFrom;
+exports.getSupabaseUserCompat = getSupabaseUserCompat;
+exports.getSupabaseSessionCompat = getSupabaseSessionCompat;
+exports.useSupabaseUserCompat = useSupabaseUserCompat;
+exports.useSupabaseSessionCompat = useSupabaseSessionCompat;
+exports.supabaseSignOutCompat = supabaseSignOutCompat;
+exports.supabaseSignInWithOAuthCompat = supabaseSignInWithOAuthCompat;
+exports.onSupabaseAuthStateChangeCompat = onSupabaseAuthStateChangeCompat;
+exports.betterAuthSessionFrom = betterAuthSessionFrom;
+exports.createBetterAuthCompatClient = createBetterAuthCompatClient;
+/**
+ * Drop-in compatibility helpers for apps moving to Atlas from Auth.js (NextAuth),
+ * Auth0 (auth0-react / nextjs-auth0), Supabase Auth and Better Auth.
+ *
+ * `atlas migrate code --from <vendor>` rewrites an app's imports onto these, so
+ * the migrated code keeps the shapes it was written against (`{ data, status }`
+ * from `useSession`, `{ isAuthenticated, user }` from `useAuth0`, …) and compiles
+ * and runs on day one. Each helper is a thin projection over the native hooks
+ * (`useUser`, `useAuth`); once migrated, move call sites to those at your own pace.
+ *
+ * The imperative helpers (`nextAuthSignOut()`, `getSupabaseUserCompat()`, …) work
+ * outside React components too: they act on the `<AtlasProvider>` mounted on the
+ * page. Calling one with no provider mounted throws a clear error.
+ */
+const react_1 = require("react");
+const AtlasProvider_1 = require("./AtlasProvider");
+const components_shared_1 = require("./components-shared");
+const active_atlas_1 = require("./active-atlas");
+var active_atlas_2 = require("./active-atlas");
+Object.defineProperty(exports, "getActiveAtlas", { enumerable: true, get: function () { return active_atlas_2.getActiveAtlas; } });
+// ---- shared user projection --------------------------------------------------
+/** The primary email address, else the first verified one, else any. */
+function primaryEmail(user) {
+    const list = user?.email_addresses ?? [];
+    const pick = list.find((e) => e.primary) ?? list.find((e) => e.verified) ?? list[0];
+    return pick ? { address: pick.email_address, verified: pick.verified } : null;
+}
+/** A display name: first + last, else the username, else null. */
+function displayName(user) {
+    if (!user)
+        return null;
+    const full = [user.first_name, user.last_name].filter(Boolean).join(' ').trim();
+    return full || user.username || null;
+}
+function expiresIso(claims) {
+    const exp = typeof claims?.exp === 'number' ? claims.exp * 1000 : Date.now() + 60_000;
+    return new Date(exp).toISOString();
+}
+function signInUrlWith(options = {}) {
+    return (0, components_shared_1.withRedirect)(options.signInUrl ?? '/sign-in', options.redirectUrl);
+}
+/** Send the browser to your sign-in page, returning to `redirectUrl` afterwards. */
+function signInRedirect(options = {}) {
+    (0, components_shared_1.navigateTo)(signInUrlWith(options));
+}
+async function signOutThenGo(helper, returnTo) {
+    await (0, active_atlas_1.requireActive)(helper).signOut();
+    if (returnTo !== false)
+        (0, components_shared_1.navigateTo)(returnTo ?? '/');
+}
+/** Pure projection of the provider state onto next-auth's session shape. */
+function nextAuthSessionFrom(state) {
+    if (state.status === 'loading')
+        return { data: null, status: 'loading' };
+    if (state.status !== 'signed_in' || !state.user)
+        return { data: null, status: 'unauthenticated' };
+    const email = primaryEmail(state.user);
+    return {
+        data: {
+            user: {
+                id: state.user.id,
+                name: displayName(state.user),
+                email: email?.address ?? null,
+                image: state.user.image_url,
+            },
+            expires: expiresIso(state.claims),
+        },
+        status: 'authenticated',
+    };
+}
+/** `useSession()` from `next-auth/react`, on Atlas: `{ data, status, update }`. */
+function useNextAuthSession() {
+    const atlas = (0, AtlasProvider_1.useAtlas)();
+    const projected = nextAuthSessionFrom(atlas);
+    return {
+        ...projected,
+        update: async () => {
+            await atlas.reload();
+            const now = (0, active_atlas_1.getActiveAtlas)() ?? atlas;
+            return nextAuthSessionFrom(now).data;
+        },
+    };
+}
+/** `getSession()` from `next-auth/react` (client side): the current session or null. */
+async function getNextAuthSession() {
+    return nextAuthSessionFrom((0, active_atlas_1.requireActive)('getNextAuthSession')).data;
+}
+/**
+ * `signIn()` from `next-auth/react`: opens your Atlas sign-in page. The provider
+ * argument is accepted for compatibility; the sign-in page lists every enabled
+ * method (render `<SocialSignInButton provider="github" />` to go straight to one).
+ */
+async function nextAuthSignIn(_provider, options = {}) {
+    signInRedirect({ signInUrl: options.signInUrl, redirectUrl: options.redirectTo ?? options.callbackUrl });
+}
+/** `signOut()` from `next-auth/react`: signs out, then goes to `callbackUrl` (default `/`). */
+async function nextAuthSignOut(options = {}) {
+    await signOutThenGo('nextAuthSignOut', options.redirect === false ? false : (options.redirectTo ?? options.callbackUrl));
+}
+/** Project an Atlas user onto the OIDC profile shape Auth0 SDKs return. */
+function auth0UserFrom(user, claims = null) {
+    if (!user)
+        return undefined;
+    const email = primaryEmail(user);
+    const out = { sub: user.id };
+    const name = displayName(user);
+    if (name)
+        out.name = name;
+    if (user.first_name)
+        out.given_name = user.first_name;
+    if (user.last_name)
+        out.family_name = user.last_name;
+    if (user.username)
+        out.nickname = user.username;
+    if (user.image_url)
+        out.picture = user.image_url;
+    if (email) {
+        out.email = email.address;
+        out.email_verified = email.verified;
+    }
+    if (claims?.org_id)
+        out.org_id = claims.org_id;
+    return out;
+}
+/** Thrown by `getAccessTokenSilently()` when nobody is signed in (Auth0's `login_required`). */
+class LoginRequiredError extends Error {
+    error = 'login_required';
+    constructor() {
+        super('Login required');
+        this.name = 'LoginRequiredError';
+    }
+}
+exports.LoginRequiredError = LoginRequiredError;
+/** `useAuth0()` from `@auth0/auth0-react`, on Atlas. */
+function useAuth0Compat() {
+    const atlas = (0, AtlasProvider_1.useAtlas)();
+    return {
+        isLoading: atlas.status === 'loading',
+        isAuthenticated: atlas.status === 'signed_in',
+        user: atlas.status === 'signed_in' ? auth0UserFrom(atlas.user, atlas.claims) : undefined,
+        error: undefined,
+        loginWithRedirect: async (options = {}) => signInRedirect({ signInUrl: options.signInUrl, redirectUrl: options.appState?.returnTo }),
+        logout: async (options = {}) => {
+            await atlas.signOut();
+            if (options.openUrl !== false)
+                (0, components_shared_1.navigateTo)(options.logoutParams?.returnTo ?? '/');
+        },
+        getAccessTokenSilently: async (options) => {
+            const token = await atlas.getToken(options);
+            if (!token)
+                throw new LoginRequiredError();
+            return token;
+        },
+        getIdTokenClaims: async () => atlas.claims ?? undefined,
+    };
+}
+/** `useUser()` from `@auth0/nextjs-auth0/client` (v3) or `@auth0/nextjs-auth0` (v4). */
+function useAuth0UserCompat() {
+    const atlas = (0, AtlasProvider_1.useAtlas)();
+    const refresh = async () => {
+        await atlas.reload();
+    };
+    return {
+        user: atlas.status === 'signed_in' ? auth0UserFrom(atlas.user, atlas.claims) : undefined,
+        error: undefined,
+        isLoading: atlas.status === 'loading',
+        checkSession: refresh,
+        invalidate: refresh,
+    };
+}
+/**
+ * `withAuthenticationRequired(Component, options)` from `@auth0/auth0-react` (and
+ * nextjs-auth0's client `withPageAuthRequired`): renders the component only for a
+ * signed-in user and sends everyone else to your sign-in page.
+ */
+function withAuthenticationRequiredCompat(Component, options = {}) {
+    function Guarded(props) {
+        const { status } = (0, AtlasProvider_1.useAtlas)();
+        (0, react_1.useEffect)(() => {
+            if (status !== 'signed_out')
+                return;
+            const returnTo = typeof options.returnTo === 'function'
+                ? options.returnTo()
+                : (options.returnTo ?? (typeof window === 'undefined' ? undefined : window.location.href));
+            signInRedirect({ signInUrl: options.signInUrl, redirectUrl: returnTo });
+        }, [status]);
+        if (status === 'signed_in')
+            return (0, react_1.createElement)(Component, props);
+        return (0, react_1.createElement)(react_1.Fragment, null, options.onRedirecting?.() ?? null);
+    }
+    Guarded.displayName = `withAuthenticationRequired(${Component.displayName ?? Component.name ?? 'Component'})`;
+    return Guarded;
+}
+function supabaseUserFrom(user) {
+    if (!user)
+        return null;
+    const email = primaryEmail(user);
+    const phone = (user.phone_numbers ?? []).find((p) => p.primary) ?? user.phone_numbers?.[0];
+    const name = displayName(user);
+    return {
+        id: user.id,
+        aud: 'authenticated',
+        role: 'authenticated',
+        ...(email ? { email: email.address } : {}),
+        ...(email?.verified ? { email_confirmed_at: new Date(0).toISOString() } : {}),
+        ...(phone ? { phone: phone.phone_number } : {}),
+        user_metadata: {
+            ...user.unsafe_metadata,
+            ...(name ? { full_name: name, name } : {}),
+            ...(user.image_url ? { avatar_url: user.image_url } : {}),
+        },
+        app_metadata: { ...user.public_metadata },
+    };
+}
+/** `supabase.auth.getUser()` in the browser. */
+async function getSupabaseUserCompat() {
+    const atlas = (0, active_atlas_1.requireActive)('getSupabaseUserCompat');
+    return { data: { user: atlas.status === 'signed_in' ? supabaseUserFrom(atlas.user) : null }, error: null };
+}
+/** `supabase.auth.getSession()` in the browser; `access_token` is the Atlas session JWT. */
+async function getSupabaseSessionCompat() {
+    const atlas = (0, active_atlas_1.requireActive)('getSupabaseSessionCompat');
+    const user = atlas.status === 'signed_in' ? supabaseUserFrom(atlas.user) : null;
+    const token = user ? await atlas.getToken() : null;
+    if (!user || !token)
+        return { data: { session: null }, error: null };
+    return { data: { session: { access_token: token, expires_at: atlas.claims?.exp, user } }, error: null };
+}
+/** `useUser()` from `@supabase/auth-helpers-react`: the user, or null. */
+function useSupabaseUserCompat() {
+    const atlas = (0, AtlasProvider_1.useAtlas)();
+    return atlas.status === 'signed_in' ? supabaseUserFrom(atlas.user) : null;
+}
+/** `useSession()` from `@supabase/auth-helpers-react`: `{ user, expires_at }`, or null. */
+function useSupabaseSessionCompat() {
+    const atlas = (0, AtlasProvider_1.useAtlas)();
+    const user = atlas.status === 'signed_in' ? supabaseUserFrom(atlas.user) : null;
+    return user ? { user, expires_at: atlas.claims?.exp } : null;
+}
+/** `supabase.auth.signOut()` in the browser. */
+async function supabaseSignOutCompat() {
+    await (0, active_atlas_1.requireActive)('supabaseSignOutCompat').signOut();
+    return { error: null };
+}
+/** `supabase.auth.signInWithOAuth({ provider, options: { redirectTo } })`: opens your sign-in page. */
+async function supabaseSignInWithOAuthCompat(credentials = {}) {
+    const url = signInUrlWith({ signInUrl: credentials.options?.signInUrl, redirectUrl: credentials.options?.redirectTo });
+    (0, components_shared_1.navigateTo)(url);
+    return { data: { provider: credentials.provider, url }, error: null };
+}
+/**
+ * `supabase.auth.onAuthStateChange(callback)`: the callback fires with
+ * `SIGNED_IN` / `SIGNED_OUT` / `USER_UPDATED` as the Atlas session changes.
+ */
+function onSupabaseAuthStateChangeCompat(callback) {
+    let last = { status: null, user: null };
+    const listener = (atlas) => {
+        const status = atlas?.status ?? null;
+        if (status === 'loading' || status === null)
+            return;
+        const current = status === 'signed_in' ? (atlas.user ?? null) : null;
+        let event = null;
+        if (last.status === null)
+            event = 'INITIAL_SESSION';
+        else if (status === 'signed_out')
+            event = last.status === 'signed_in' ? 'SIGNED_OUT' : null;
+        else if (last.status !== 'signed_in' || last.user?.id !== current?.id)
+            event = 'SIGNED_IN';
+        // Same user, new profile object: the provider reloaded the user.
+        else if (current !== last.user)
+            event = 'USER_UPDATED';
+        last = { status, user: current };
+        const mapped = supabaseUserFrom(current);
+        if (event)
+            callback(event, mapped ? { user: mapped } : null);
+    };
+    const unsubscribe = (0, active_atlas_1.onActiveAtlasChange)(listener);
+    const current = (0, active_atlas_1.getActiveAtlas)();
+    if (current)
+        listener(current);
+    return { data: { subscription: { unsubscribe } } };
+}
+function betterAuthSessionFrom(state) {
+    if (state.status !== 'signed_in' || !state.user)
+        return null;
+    const email = primaryEmail(state.user);
+    return {
+        user: {
+            id: state.user.id,
+            email: email?.address ?? null,
+            emailVerified: email?.verified ?? false,
+            name: displayName(state.user),
+            image: state.user.image_url,
+        },
+        session: {
+            id: state.claims?.sid ?? '',
+            userId: state.user.id,
+            expiresAt: new Date(expiresIso(state.claims)),
+            activeOrganizationId: state.claims?.org_id ?? null,
+        },
+    };
+}
+/**
+ * `createAuthClient()` from `better-auth/react`, on Atlas. The returned object has
+ * the same `useSession`, `getSession`, `signIn.social`, `signIn.email`, `signUp.email`
+ * and `signOut` members. The sign-in/up members open your Atlas pages (Atlas
+ * collects credentials on its own forms, never in app code).
+ */
+function createBetterAuthCompatClient(options = {}) {
+    const goSignIn = (callbackURL) => (0, components_shared_1.navigateTo)((0, components_shared_1.withRedirect)(options.signInUrl ?? '/sign-in', callbackURL));
+    const goSignUp = (callbackURL) => (0, components_shared_1.navigateTo)((0, components_shared_1.withRedirect)(options.signUpUrl ?? '/sign-up', callbackURL));
+    const ok = (data) => ({ data, error: null });
+    return {
+        /** Type-only, like Better Auth's `authClient.$Infer.Session`. */
+        $Infer: {},
+        useSession() {
+            const atlas = (0, AtlasProvider_1.useAtlas)();
+            return {
+                data: betterAuthSessionFrom(atlas),
+                isPending: atlas.status === 'loading',
+                error: null,
+                refetch: async () => {
+                    await atlas.reload();
+                },
+            };
+        },
+        async getSession() {
+            return ok(betterAuthSessionFrom((0, active_atlas_1.requireActive)('authClient.getSession')));
+        },
+        signIn: {
+            async social(input = {}) {
+                goSignIn(input.callbackURL);
+                return ok({ redirect: true });
+            },
+            async email(input = {}) {
+                goSignIn(input.callbackURL);
+                return ok({ redirect: true });
+            },
+            async magicLink(input = {}) {
+                goSignIn(input.callbackURL);
+                return ok({ redirect: true });
+            },
+            async passkey() {
+                goSignIn();
+                return ok({ redirect: true });
+            },
+        },
+        signUp: {
+            async email(input = {}) {
+                goSignUp(input.callbackURL);
+                return ok({ redirect: true });
+            },
+        },
+        async signOut(input = {}) {
+            await (0, active_atlas_1.requireActive)('authClient.signOut').signOut();
+            input.fetchOptions?.onSuccess?.();
+            return ok({ success: true });
+        },
+    };
+}
+//# sourceMappingURL=compat.js.map