@adonis-agora/authkit-react 0.12.0

package/build/src/components/sign_out_button.js

@@ -0,0 +1,16 @@
+import { createElement } from 'react';
+import { useSignOut } from '../hooks/use_sign_out.js';
+import { useAuth } from '../use_auth.js';
+export function SignOutButton({ children = 'Sair', returnTo, className, ...rest }) {
+    const { signOut } = useSignOut();
+    const { isAuthenticated } = useAuth();
+    if (!isAuthenticated)
+        return null;
+    const opts = returnTo ? { returnTo } : undefined;
+    return createElement('button', {
+        type: 'button',
+        className: ['authkit-button', 'authkit-button--ghost', className].filter(Boolean).join(' '),
+        onClick: () => signOut(opts),
+        ...rest,
+    }, children);
+}

package/build/src/components/user_button.d.ts

@@ -0,0 +1,8 @@
+export interface UserButtonProps {
+    profileLabel?: string;
+    signOutLabel?: string;
+    className?: string;
+}
+export declare function UserButton({ profileLabel, signOutLabel, className, }: UserButtonProps): import("react").DetailedReactHTMLElement<{
+    className: string;
+}, HTMLElement> | null;

package/build/src/components/user_button.js

@@ -0,0 +1,31 @@
+import { createElement, useState } from 'react';
+import { useAuth } from '../use_auth.js';
+import { useAuthkitConfig } from '../config.js';
+import { useSignOut } from '../hooks/use_sign_out.js';
+import { Avatar } from './avatar.js';
+export function UserButton({ profileLabel = 'Perfil', signOutLabel = 'Sair', className, }) {
+    const { user, isAuthenticated } = useAuth();
+    const config = useAuthkitConfig();
+    const { signOut } = useSignOut();
+    const [open, setOpen] = useState(false);
+    if (!isAuthenticated || !user)
+        return null;
+    const trigger = createElement('button', {
+        type: 'button',
+        className: 'authkit-userbutton__trigger',
+        'aria-haspopup': 'menu',
+        'aria-expanded': open,
+        onClick: () => setOpen((v) => !v),
+    }, createElement(Avatar, { user }));
+    const menu = open
+        ? createElement('div', { className: 'authkit-userbutton__menu', role: 'menu' }, createElement('div', { className: 'authkit-userbutton__header' }, createElement('div', { className: 'authkit-userbutton__name' }, user.name ?? user.email), user.name
+            ? createElement('div', { className: 'authkit-userbutton__email' }, user.email)
+            : null), createElement('a', { className: 'authkit-userbutton__item', role: 'menuitem', href: config.profileUrl }, profileLabel), createElement('button', {
+            type: 'button',
+            className: 'authkit-userbutton__item',
+            role: 'menuitem',
+            onClick: () => signOut(),
+        }, signOutLabel))
+        : null;
+    return createElement('div', { className: ['authkit-userbutton', className].filter(Boolean).join(' ') }, trigger, menu);
+}

package/build/src/components/user_profile.d.ts

@@ -0,0 +1,8 @@
+export interface UserProfileProps {
+    className?: string;
+}
+declare function UserProfileInner({ className }: UserProfileProps): import("react").DetailedReactHTMLElement<{
+    className: string;
+}, HTMLElement> | null;
+export declare function UserProfile(props: Parameters<typeof UserProfileInner>[0]): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/build/src/components/user_profile.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createElement, useState } from 'react';
+import { useAuthkitConfig } from '../config.js';
+import { useAuth } from '../use_auth.js';
+import { useProfile } from '../hooks/use_profile.js';
+import { Avatar } from './avatar.js';
+function UserProfileInner({ className }) {
+    const { user, isAuthenticated } = useAuth();
+    const { actions, loading, error } = useProfile();
+    const [name, setName] = useState(user?.name ?? '');
+    if (!isAuthenticated || !user)
+        return null;
+    const onSubmit = (e) => {
+        e.preventDefault();
+        void actions.update({ name });
+    };
+    return createElement('div', { className: ['authkit-card', 'authkit-profile', className].filter(Boolean).join(' ') }, createElement('div', { className: 'authkit-profile__header' }, createElement(Avatar, { user, size: 56 }), createElement('div', null, createElement('div', { className: 'authkit-profile__name' }, user.name ?? user.email), createElement('div', { className: 'authkit-profile__email' }, user.email))), createElement('form', { className: 'authkit-profile__form', onSubmit }, createElement('label', { className: 'authkit-label', htmlFor: 'authkit-profile-name' }, 'Nome'), createElement('input', {
+        id: 'authkit-profile-name',
+        className: 'authkit-input',
+        value: name,
+        onChange: (e) => setName(e.target.value),
+    }), error
+        ? createElement('p', { className: 'authkit-error', role: 'alert' }, error.message)
+        : null, createElement('button', {
+        type: 'submit',
+        className: 'authkit-button authkit-button--primary',
+        disabled: loading,
+    }, loading ? 'Salvando…' : 'Salvar')));
+}
+export function UserProfile(props) {
+    const { idp } = useAuthkitConfig();
+    if (idp === 'external')
+        return null;
+    return _jsx(UserProfileInner, { ...props });
+}

package/build/src/config.d.ts

@@ -0,0 +1,30 @@
+export interface AuthkitEndpoints {
+    profile: string;
+    sessions: string;
+    apps: string;
+    passkeys: string;
+    orgs: string;
+    orgInvitations: string;
+}
+export type AuthkitIdpMode = 'authkit' | 'external';
+export interface AuthkitConfig {
+    loginUrl?: string;
+    logoutUrl?: string;
+    profileUrl?: string;
+    endpoints?: Partial<AuthkitEndpoints>;
+    csrfToken?: string;
+    idp?: AuthkitIdpMode;
+}
+export interface ResolvedAuthkitConfig {
+    loginUrl: string;
+    logoutUrl: string;
+    profileUrl: string;
+    endpoints: AuthkitEndpoints;
+    csrfToken?: string;
+    idp: AuthkitIdpMode;
+}
+export declare const DEFAULT_CONFIG: ResolvedAuthkitConfig;
+export declare function resolveConfig(config?: AuthkitConfig): ResolvedAuthkitConfig;
+export declare function buildAuthUrl(base: string, returnTo?: string): string;
+export declare const AuthkitConfigContext: import("react").Context<ResolvedAuthkitConfig>;
+export declare function useAuthkitConfig(): ResolvedAuthkitConfig;

package/build/src/config.js

@@ -0,0 +1,42 @@
+import { createContext, useContext } from 'react';
+export const DEFAULT_CONFIG = {
+    idp: 'authkit',
+    loginUrl: '/auth/login',
+    logoutUrl: '/account/logout',
+    profileUrl: '/account/security',
+    endpoints: {
+        profile: '/account/security/profile',
+        sessions: '/account/security',
+        apps: '/account/apps',
+        passkeys: '/account/mfa/passkeys',
+        orgs: '/account/orgs/json',
+        orgInvitations: '/account/orgs/invitations/json',
+    },
+};
+export function resolveConfig(config) {
+    return {
+        loginUrl: config?.loginUrl ?? DEFAULT_CONFIG.loginUrl,
+        logoutUrl: config?.logoutUrl ?? DEFAULT_CONFIG.logoutUrl,
+        profileUrl: config?.profileUrl ?? DEFAULT_CONFIG.profileUrl,
+        endpoints: {
+            profile: config?.endpoints?.profile ?? DEFAULT_CONFIG.endpoints.profile,
+            sessions: config?.endpoints?.sessions ?? DEFAULT_CONFIG.endpoints.sessions,
+            apps: config?.endpoints?.apps ?? DEFAULT_CONFIG.endpoints.apps,
+            passkeys: config?.endpoints?.passkeys ?? DEFAULT_CONFIG.endpoints.passkeys,
+            orgs: config?.endpoints?.orgs ?? DEFAULT_CONFIG.endpoints.orgs,
+            orgInvitations: config?.endpoints?.orgInvitations ?? DEFAULT_CONFIG.endpoints.orgInvitations,
+        },
+        csrfToken: config?.csrfToken,
+        idp: config?.idp ?? 'authkit',
+    };
+}
+export function buildAuthUrl(base, returnTo) {
+    if (!returnTo)
+        return base;
+    const sep = base.includes('?') ? '&' : '?';
+    return `${base}${sep}returnTo=${encodeURIComponent(returnTo)}`;
+}
+export const AuthkitConfigContext = createContext(DEFAULT_CONFIG);
+export function useAuthkitConfig() {
+    return useContext(AuthkitConfigContext);
+}

package/build/src/hooks/use_authorized_apps.d.ts

@@ -0,0 +1,16 @@
+import { type ResourceState } from './use_resource.js';
+export interface AuthorizedApp {
+    clientId: string;
+    name?: string;
+    logoUrl?: string;
+    scopes?: string[];
+    authorizedAt?: string;
+    [key: string]: unknown;
+}
+export interface UseAuthorizedAppsResult extends ResourceState<AuthorizedApp[]> {
+    actions: {
+        refetch(): Promise<void>;
+        revoke(clientId: string): Promise<void>;
+    };
+}
+export declare function useAuthorizedApps(): UseAuthorizedAppsResult;

package/build/src/hooks/use_authorized_apps.js

@@ -0,0 +1,15 @@
+import { useCallback } from 'react';
+import { useAuthkitConfig } from '../config.js';
+import { jsonRequest, useResource } from './use_resource.js';
+export function useAuthorizedApps() {
+    const config = useAuthkitConfig();
+    const { data, loading, error, refetch } = useResource(config.endpoints.apps, config.csrfToken);
+    const revoke = useCallback(async (clientId) => {
+        await jsonRequest(`${config.endpoints.apps}/${encodeURIComponent(clientId)}/revoke`, {
+            method: 'POST',
+            csrfToken: config.csrfToken,
+        });
+        await refetch();
+    }, [config.endpoints.apps, config.csrfToken, refetch]);
+    return { data, loading, error, actions: { refetch, revoke } };
+}

package/build/src/hooks/use_org_invitations.d.ts

@@ -0,0 +1,19 @@
+import { type ResourceState } from './use_resource.js';
+export interface OrgInvitationEntry {
+    id: string;
+    organizationId: string;
+    orgName: string;
+    orgSlug: string;
+    email: string;
+    role: string;
+    expiresAt: string;
+    createdAt: string;
+    [key: string]: unknown;
+}
+export interface UseOrgInvitationsResult extends ResourceState<OrgInvitationEntry[]> {
+    actions: {
+        refetch(): Promise<void>;
+        accept(token: string): Promise<void>;
+    };
+}
+export declare function useOrgInvitations(): UseOrgInvitationsResult;

package/build/src/hooks/use_org_invitations.js

@@ -0,0 +1,20 @@
+import { useCallback } from 'react';
+import { useAuthkitConfig } from '../config.js';
+import { jsonRequest, useResource } from './use_resource.js';
+export function useOrgInvitations() {
+    const config = useAuthkitConfig();
+    const { data, loading, error, refetch } = useResource(config.endpoints.orgInvitations, config.csrfToken);
+    const accept = useCallback(async (token) => {
+        await jsonRequest(`/account/orgs/invitations/${encodeURIComponent(token)}/accept`, {
+            method: 'POST',
+            csrfToken: config.csrfToken,
+        });
+        await refetch();
+    }, [config.csrfToken, refetch]);
+    return {
+        data: data?.invitations ?? null,
+        loading,
+        error,
+        actions: { refetch, accept },
+    };
+}

package/build/src/hooks/use_organization.d.ts

@@ -0,0 +1,23 @@
+import { type ResourceState } from './use_resource.js';
+export interface OrgMemberEntry {
+    accountId: string;
+    email: string | null;
+    role: string;
+    joinedAt: string;
+}
+export interface ActiveOrgDetail {
+    id: string;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    role: string;
+    canManage: boolean;
+    members: OrgMemberEntry[];
+    [key: string]: unknown;
+}
+export interface UseOrganizationResult extends ResourceState<ActiveOrgDetail> {
+    actions: {
+        refetch(): Promise<void>;
+    };
+}
+export declare function useOrganization(orgId: string | null): UseOrganizationResult;

package/build/src/hooks/use_organization.js

@@ -0,0 +1,8 @@
+import { useAuthkitConfig } from '../config.js';
+import { useResource } from './use_resource.js';
+export function useOrganization(orgId) {
+    const config = useAuthkitConfig();
+    const url = orgId ? `${config.endpoints.orgs.replace('/json', '')}/${encodeURIComponent(orgId)}/json` : '';
+    const { data, loading, error, refetch } = useResource(url, config.csrfToken);
+    return { data, loading: url ? loading : false, error, actions: { refetch } };
+}

package/build/src/hooks/use_organizations.d.ts

@@ -0,0 +1,18 @@
+import { type ResourceState } from './use_resource.js';
+export interface OrgEntry {
+    id: string;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    role: string;
+    isActive: boolean;
+    [key: string]: unknown;
+}
+export interface UseOrganizationsResult extends ResourceState<OrgEntry[]> {
+    activeOrgId: string | null;
+    supported: boolean;
+    actions: {
+        refetch(): Promise<void>;
+    };
+}
+export declare function useOrganizations(): UseOrganizationsResult;

package/build/src/hooks/use_organizations.js

@@ -0,0 +1,14 @@
+import { useAuthkitConfig } from '../config.js';
+import { useResource } from './use_resource.js';
+export function useOrganizations() {
+    const config = useAuthkitConfig();
+    const { data, loading, error, refetch } = useResource(config.endpoints.orgs, config.csrfToken);
+    return {
+        data: data?.orgs ?? null,
+        loading,
+        error,
+        activeOrgId: data?.activeOrgId ?? null,
+        supported: data?.supported ?? true,
+        actions: { refetch },
+    };
+}

package/build/src/hooks/use_passkey_autofill.d.ts

@@ -0,0 +1,8 @@
+export interface UsePasskeyAutofillOptions {
+    optionsUrl: string;
+    verifyUrl: string;
+    onSuccess: (assertion: string) => void;
+    csrfToken?: string;
+    enabled?: boolean;
+}
+export declare function usePasskeyAutofill(options: UsePasskeyAutofillOptions): void;

package/build/src/hooks/use_passkey_autofill.js

@@ -0,0 +1,76 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { useEffect, useRef } from 'react';
+export function usePasskeyAutofill(options) {
+    const { optionsUrl, verifyUrl, onSuccess, csrfToken, enabled = true } = options;
+    const abortRef = useRef(null);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        if (typeof window === 'undefined' || typeof navigator === 'undefined')
+            return;
+        if (!window.PublicKeyCredential)
+            return;
+        let cancelled = false;
+        const ac = new AbortController();
+        abortRef.current = ac;
+        const run = async () => {
+            try {
+                const supported = typeof PublicKeyCredential.isConditionalMediationAvailable === 'function'
+                    ? await PublicKeyCredential.isConditionalMediationAvailable()
+                    : false;
+                if (!supported || cancelled)
+                    return;
+                let startAuthentication;
+                try {
+                    const mod = await import(__rewriteRelativeImportExtension('@simplewebauthn/browser'));
+                    startAuthentication = mod.startAuthentication;
+                }
+                catch {
+                    try {
+                        const mod = await import(__rewriteRelativeImportExtension('https://cdn.jsdelivr.net/npm/@simplewebauthn/browser@13/dist/bundle/index.js'));
+                        startAuthentication = mod.startAuthentication;
+                    }
+                    catch {
+                        return;
+                    }
+                }
+                if (!startAuthentication || cancelled)
+                    return;
+                const headers = { 'content-type': 'application/json' };
+                if (csrfToken)
+                    headers['x-csrf-token'] = csrfToken;
+                const optRes = await fetch(optionsUrl, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({}),
+                    signal: ac.signal,
+                });
+                if (!optRes.ok || cancelled)
+                    return;
+                const optionsJSON = await optRes.json();
+                delete optionsJSON._discoverable;
+                if (cancelled)
+                    return;
+                const assertion = await startAuthentication({ optionsJSON, useBrowserAutofill: true, verifyBrowserAutofillInput: true }, ac.signal);
+                if (cancelled)
+                    return;
+                onSuccess(JSON.stringify(assertion));
+            }
+            catch {
+            }
+        };
+        void run();
+        return () => {
+            cancelled = true;
+            ac.abort();
+            abortRef.current = null;
+        };
+    }, [enabled, optionsUrl, verifyUrl, csrfToken]);
+}

package/build/src/hooks/use_password_strength.d.ts

@@ -0,0 +1,11 @@
+export type PasswordStrengthScore = 0 | 1 | 2 | 3 | 4;
+export interface PasswordStrengthResult {
+    score: PasswordStrengthScore;
+    feedback?: string[];
+}
+export type PasswordScorer = (password: string) => PasswordStrengthResult;
+export interface UsePasswordStrengthOptions {
+    scorer?: PasswordScorer;
+}
+export declare function heuristicScorer(password: string): PasswordStrengthResult;
+export declare function usePasswordStrength(password: string, options?: UsePasswordStrengthOptions): PasswordStrengthResult;

package/build/src/hooks/use_password_strength.js

@@ -0,0 +1,34 @@
+import { useMemo } from 'react';
+export function heuristicScorer(password) {
+    if (!password)
+        return { score: 0, feedback: ['Enter a password.'] };
+    const feedback = [];
+    const classes = [/[a-z]/, /[A-Z]/, /[0-9]/, /[^A-Za-z0-9]/];
+    const variety = classes.filter((re) => re.test(password)).length;
+    const length = password.length;
+    let points = 0;
+    if (length >= 8)
+        points += 1;
+    if (length >= 12)
+        points += 1;
+    if (length >= 16)
+        points += 1;
+    if (variety >= 2)
+        points += 1;
+    if (variety >= 3)
+        points += 1;
+    if (length < 12)
+        feedback.push('Use at least 12 characters.');
+    if (!/[A-Z]/.test(password))
+        feedback.push('Add an uppercase letter.');
+    if (!/[0-9]/.test(password))
+        feedback.push('Add a number.');
+    if (!/[^A-Za-z0-9]/.test(password))
+        feedback.push('Add a symbol.');
+    const score = Math.max(0, Math.min(4, points));
+    return { score, feedback: feedback.length ? feedback : undefined };
+}
+export function usePasswordStrength(password, options = {}) {
+    const scorer = options.scorer ?? heuristicScorer;
+    return useMemo(() => scorer(password), [password, scorer]);
+}

package/build/src/hooks/use_profile.d.ts

@@ -0,0 +1,13 @@
+import { type ResourceState } from './use_resource.js';
+import type { AuthUser } from '../types.js';
+export interface ProfileUpdate {
+    name?: string;
+    avatarUrl?: string;
+    [key: string]: unknown;
+}
+export interface UseProfileResult extends ResourceState<AuthUser> {
+    actions: {
+        update(data: ProfileUpdate): Promise<void>;
+    };
+}
+export declare function useProfile(): UseProfileResult;

package/build/src/hooks/use_profile.js

@@ -0,0 +1,28 @@
+import { useCallback, useState } from 'react';
+import { useAuthkitConfig } from '../config.js';
+import { useAuth } from '../use_auth.js';
+import { jsonRequest } from './use_resource.js';
+export function useProfile() {
+    const config = useAuthkitConfig();
+    const { user } = useAuth();
+    const [state, setState] = useState({
+        data: user,
+        loading: false,
+        error: null,
+    });
+    const update = useCallback(async (data) => {
+        setState((s) => ({ ...s, loading: true, error: null }));
+        try {
+            const updated = await jsonRequest(config.endpoints.profile, {
+                method: 'POST',
+                body: JSON.stringify(data),
+                csrfToken: config.csrfToken,
+            });
+            setState({ data: updated ?? { ...user, ...data }, loading: false, error: null });
+        }
+        catch (err) {
+            setState((s) => ({ ...s, loading: false, error: err }));
+        }
+    }, [config.endpoints.profile, config.csrfToken, user]);
+    return { ...state, actions: { update } };
+}

package/build/src/hooks/use_resource.d.ts

@@ -0,0 +1,11 @@
+export interface ResourceState<T> {
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+}
+export declare function jsonRequest<T>(url: string, init?: RequestInit & {
+    csrfToken?: string;
+}): Promise<T>;
+export declare function useResource<T>(url: string, csrfToken?: string): ResourceState<T> & {
+    refetch: () => Promise<void>;
+};

package/build/src/hooks/use_resource.js

@@ -0,0 +1,48 @@
+import { useCallback, useEffect, useState } from 'react';
+export async function jsonRequest(url, init = {}) {
+    const { csrfToken, headers, ...rest } = init;
+    const res = await fetch(url, {
+        credentials: 'same-origin',
+        headers: {
+            'Accept': 'application/json',
+            ...(rest.body ? { 'Content-Type': 'application/json' } : {}),
+            ...(csrfToken ? { 'X-CSRF-TOKEN': csrfToken } : {}),
+            ...headers,
+        },
+        ...rest,
+    });
+    if (!res.ok) {
+        let message = `Request failed (${res.status})`;
+        try {
+            const body = await res.json();
+            if (body && typeof body.message === 'string')
+                message = body.message;
+        }
+        catch {
+        }
+        throw new Error(message);
+    }
+    const text = await res.text();
+    return (text ? JSON.parse(text) : null);
+}
+export function useResource(url, csrfToken) {
+    const [state, setState] = useState({
+        data: null,
+        loading: true,
+        error: null,
+    });
+    const refetch = useCallback(async () => {
+        setState((s) => ({ ...s, loading: true, error: null }));
+        try {
+            const data = await jsonRequest(url, { csrfToken });
+            setState({ data, loading: false, error: null });
+        }
+        catch (err) {
+            setState({ data: null, loading: false, error: err });
+        }
+    }, [url, csrfToken]);
+    useEffect(() => {
+        void refetch();
+    }, [refetch]);
+    return { ...state, refetch };
+}

package/build/src/hooks/use_sessions.d.ts

@@ -0,0 +1,16 @@
+import { type ResourceState } from './use_resource.js';
+export interface AuthSession {
+    id: string;
+    device?: string;
+    ip?: string;
+    lastSeenAt?: string;
+    current?: boolean;
+    [key: string]: unknown;
+}
+export interface UseSessionsResult extends ResourceState<AuthSession[]> {
+    actions: {
+        refetch(): Promise<void>;
+        revoke(id: string): Promise<void>;
+    };
+}
+export declare function useSessions(): UseSessionsResult;

package/build/src/hooks/use_sessions.js

@@ -0,0 +1,15 @@
+import { useCallback } from 'react';
+import { useAuthkitConfig } from '../config.js';
+import { jsonRequest, useResource } from './use_resource.js';
+export function useSessions() {
+    const config = useAuthkitConfig();
+    const { data, loading, error, refetch } = useResource(config.endpoints.sessions, config.csrfToken);
+    const revoke = useCallback(async (id) => {
+        await jsonRequest(`${config.endpoints.sessions}/${encodeURIComponent(id)}/revoke`, {
+            method: 'POST',
+            csrfToken: config.csrfToken,
+        });
+        await refetch();
+    }, [config.endpoints.sessions, config.csrfToken, refetch]);
+    return { data, loading, error, actions: { refetch, revoke } };
+}

package/build/src/hooks/use_sign_in.d.ts

@@ -0,0 +1,6 @@
+export interface SignInOptions {
+    returnTo?: string;
+}
+export declare function useSignIn(): {
+    signIn: (opts?: SignInOptions) => void;
+};

package/build/src/hooks/use_sign_in.js

@@ -0,0 +1,13 @@
+import { useCallback } from 'react';
+import { useAuthkitConfig, buildAuthUrl } from '../config.js';
+import { currentUrl } from '../utils.js';
+export function useSignIn() {
+    const config = useAuthkitConfig();
+    const signIn = useCallback((opts) => {
+        const returnTo = opts?.returnTo ?? currentUrl();
+        const url = buildAuthUrl(config.loginUrl, returnTo);
+        if (typeof window !== 'undefined')
+            window.location.assign(url);
+    }, [config.loginUrl]);
+    return { signIn };
+}

package/build/src/hooks/use_sign_out.d.ts

@@ -0,0 +1,6 @@
+export interface SignOutOptions {
+    returnTo?: string;
+}
+export declare function useSignOut(): {
+    signOut: (opts?: SignOutOptions) => void;
+};

package/build/src/hooks/use_sign_out.js

@@ -0,0 +1,11 @@
+import { useCallback } from 'react';
+import { useAuthkitConfig, buildAuthUrl } from '../config.js';
+export function useSignOut() {
+    const config = useAuthkitConfig();
+    const signOut = useCallback((opts) => {
+        const url = buildAuthUrl(config.logoutUrl, opts?.returnTo);
+        if (typeof window !== 'undefined')
+            window.location.assign(url);
+    }, [config.logoutUrl]);
+    return { signOut };
+}

package/build/src/hooks/use_switch_organization.d.ts

@@ -0,0 +1,7 @@
+export interface UseSwitchOrganizationResult {
+    loading: boolean;
+    error: Error | null;
+    activate(orgId: string): Promise<void>;
+    deactivate(): Promise<void>;
+}
+export declare function useSwitchOrganization(): UseSwitchOrganizationResult;