@pagamio/frontend-commons-lib 0.8.175 → 0.8.183

package/lib/auth/components/LoginPage.js

@@ -0,0 +1,115 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Generic Login Page component that works with different authentication configurations.
+ * Provides a customizable login interface with support for different branding and text options.
+ *
+ * @template T - Type extending CustomAuthConfig that defines the shape of authentication data
+ *
+ * @example
+ * ```tsx
+ * // Usage with Pagamio configuration
+ * <PagamioLoginPage<PagamioAuthConfig>
+ *   logo={{
+ *     src: "/logo.svg",
+ *     alt: "Company Logo",
+ *     width: 280,
+ *     height: 250
+ *   }}
+ *   onLoginSuccess={(response) => {
+ *     // Handle successful login
+ *   }}
+ * />
+ * ```
+ */
+import { useRef, useState } from 'react';
+import { useToast } from '../../context';
+import { FormEngine } from '../../form-engine';
+import { AuthenticatorFactory } from '../authenticators';
+import { useAuth } from '../context';
+import { createFormSubmissionHandler } from './AuthFormUtils';
+import { AuthPageLayout } from './AuthPageLayout';
+export const loginPageDefaultText = {
+    welcomeTitle: 'Welcome Back!',
+    welcomeSubtitle: 'Sign in to your account to continue',
+    usernameLabel: 'Username',
+    passwordLabel: 'Password',
+    rememberMeLabel: 'Remember me',
+    loginButtonLabel: 'Login',
+    loadingButtonLabel: 'Logging in...',
+    forgotPasswordLabel: 'Forgot Password?',
+    createAccountLabel: 'Create Account',
+};
+/**
+ * Generic Login Page component
+ * @template T - Authentication configuration type
+ */
+export function PagamioLoginPage({ logo, text = loginPageDefaultText, appLabel, onForgotPassword, onLoginSuccess, onLoginError, hasCreateAccount = false, createAccountRoute, onCreateAccount, transformLoginData, authenticatorType, className = '', }) {
+    const { login, error: authError } = useAuth();
+    const { addToast } = useToast();
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const formRef = useRef();
+    const loginFields = [
+        {
+            name: 'username',
+            label: text.usernameLabel,
+            type: 'text',
+            placeholder: 'Enter username',
+            gridSpan: 12,
+            validation: {
+                required: 'Username is required',
+                validate: (value) => !/\s/.test(value) || 'Username should not contain spaces',
+            },
+        },
+        {
+            name: 'password',
+            label: text.passwordLabel,
+            type: 'password',
+            placeholder: 'Enter password',
+            gridSpan: 12,
+            validation: {
+                required: 'Password is required',
+            },
+        },
+        {
+            name: 'rememberMe',
+            label: text.rememberMeLabel,
+            type: 'checkbox',
+            gridSpan: 12,
+        },
+    ];
+    const handleSubmit = createFormSubmissionHandler({
+        setIsLoading,
+        setError,
+        addToast,
+        formRef,
+        onSuccess: (response) => onLoginSuccess?.(response),
+        onError: onLoginError,
+    }, async (data) => {
+        // Get the appropriate authenticator processor from the factory
+        const authenticator = AuthenticatorFactory.getProcessor(authenticatorType);
+        // Prepare credentials data
+        let credentials;
+        if (transformLoginData) {
+            // Use the custom transform function if provided
+            credentials = transformLoginData(data);
+        }
+        else {
+            // Default behavior - extract username and password
+            const { username, password } = data;
+            credentials = { username, password };
+        }
+        // Process the login with the selected authenticator
+        return authenticator.processLogin(credentials, data.rememberMe ?? false, login);
+    }, 'Logged in successfully', 'Login failed. Please check your credentials and try again.');
+    const handleCreateAccount = () => {
+        if (onCreateAccount) {
+            onCreateAccount();
+        }
+        else if (createAccountRoute) {
+            window.location.href = createAccountRoute;
+        }
+    };
+    return (_jsx(AuthPageLayout, { appLabel: appLabel, title: text.welcomeTitle, subtitle: text.welcomeSubtitle, errorMessage: error ?? authError?.message, logo: logo, className: className, horizontal: false, children: _jsxs("div", { className: "mt-8", children: [_jsx(FormEngine, { fields: loginFields, onSubmit: handleSubmit, layout: "vertical", className: "mb-0 px-0", submitButtonClass: "w-full", submitButtonText: isLoading ? text.loadingButtonLabel : text.loginButtonLabel, onCancel: () => { }, showCancelButton: false, showSubmittingText: false, formRef: formRef }), _jsxs("div", { className: "flex items-center justify-center gap-x-4 mt-4", children: [onForgotPassword && (_jsx("button", { type: "button", onClick: onForgotPassword, className: "text-sm text-primary-500 hover:underline dark:text-primary-500", children: text.forgotPasswordLabel })), hasCreateAccount && (_jsxs(_Fragment, { children: [onForgotPassword && _jsx("span", { className: "text-gray-500", children: "|" }), _jsx("button", { type: "button", onClick: handleCreateAccount, className: "text-sm text-primary-500 hover:underline dark:text-primary-500", children: text.createAccountLabel })] }))] })] }) }));
+}
+export default PagamioLoginPage;

package/lib/auth/components/LogoutButton.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Props for LogoutButton component
+ */
+interface LogoutButtonProps {
+    /** Additional class names to apply to the button */
+    className?: string;
+    /** Button variant from the UI component library */
+    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
+    /** Callback function called after successful logout */
+    onLogoutSuccess?: () => void;
+    /** Callback function called when logout fails */
+    onLogoutError?: (error: Error) => void;
+}
+/**
+ * LogoutButton Component
+ *
+ * A reusable button component that handles user logout with loading state
+ * and error handling.
+ *
+ * @example
+ * ```tsx
+ * <LogoutButton
+ *   variant="destructive"
+ *   onLogoutSuccess={() => navigate('/login')}
+ *   onLogoutError={(error) => console.error('Logout failed:', error)}
+ * />
+ * ```
+ */
+declare const LogoutButton: ({ className, variant, onLogoutSuccess, onLogoutError }: LogoutButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default LogoutButton;

package/lib/auth/components/LogoutButton.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @fileoverview Reusable logout button component with loading state
+ * and callback handlers
+ */
+import { useState } from 'react';
+import { Button } from '../../components';
+import { cn } from '../../helpers';
+import { useAuth } from '../context';
+/**
+ * LogoutButton Component
+ *
+ * A reusable button component that handles user logout with loading state
+ * and error handling.
+ *
+ * @example
+ * ```tsx
+ * <LogoutButton
+ *   variant="destructive"
+ *   onLogoutSuccess={() => navigate('/login')}
+ *   onLogoutError={(error) => console.error('Logout failed:', error)}
+ * />
+ * ```
+ */
+const LogoutButton = ({ className = '', variant = 'default', onLogoutSuccess, onLogoutError }) => {
+    const { logout } = useAuth();
+    const [isLoggingOut, setIsLoggingOut] = useState(false);
+    const handleLogout = async () => {
+        if (isLoggingOut)
+            return; // Prevent multiple clicks
+        setIsLoggingOut(true);
+        try {
+            await logout();
+            onLogoutSuccess?.();
+        }
+        catch (error) {
+            const logoutError = error instanceof Error ? error : new Error('Logout failed');
+            console.error('Logout failed:', logoutError);
+            onLogoutError?.(logoutError);
+        }
+        finally {
+            setIsLoggingOut(false);
+        }
+    };
+    return (_jsx(Button, { onClick: handleLogout, disabled: isLoggingOut, variant: variant, className: cn('mt-4', className), children: isLoggingOut ? 'Logging out...' : 'Logout' }));
+};
+export default LogoutButton;

package/lib/auth/components/ResetPasswordPage.d.ts

@@ -0,0 +1,42 @@
+import type { CustomAuthConfig } from '../types';
+import type { BaseAuthPageProps } from './AuthFormUtils';
+/**
+ * Props for the PagamioResetPasswordPage component
+ * @template T - Authentication configuration type
+ */
+interface PagamioResetPasswordPageProps<T extends CustomAuthConfig> extends BaseAuthPageProps {
+    /** Reset token from URL or other source */
+    token: string;
+    /** Customizable text content */
+    text?: {
+        title: string;
+        subtitle: string;
+        passwordLabel: string;
+        confirmPasswordLabel: string;
+        submitButtonLabel: string;
+        loadingButtonLabel: string;
+        backToLoginLabel: string;
+        successMessage: string;
+    };
+    /** Callback handlers */
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+    onBackToLogin?: () => void;
+}
+export declare const resetPasswordDefaultText: {
+    title: string;
+    subtitle: string;
+    passwordLabel: string;
+    confirmPasswordLabel: string;
+    submitButtonLabel: string;
+    loadingButtonLabel: string;
+    backToLoginLabel: string;
+    successMessage: string;
+};
+/**
+ * Generic Reset Password Page component
+ * @template T - Authentication configuration type
+ */
+export declare function PagamioResetPasswordPage<T extends CustomAuthConfig>({ logo, text, appLabel, token, onSuccess, onError, onBackToLogin, className, }: Readonly<PagamioResetPasswordPageProps<T>>): import("react/jsx-runtime").JSX.Element;
+export default PagamioResetPasswordPage;
+export type { PagamioResetPasswordPageProps };

package/lib/auth/components/ResetPasswordPage.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Generic Reset Password Page component that works with different authentication configurations.
+ * Provides a customizable interface for users to reset their password after receiving a reset token.
+ *
+ * @template T - Type extending CustomAuthConfig that defines the shape of authentication data
+ *
+ * @example
+ * ```tsx
+ * // Usage with Pagamio configuration
+ * <PagamioResetPasswordPage<PagamioAuthConfig>
+ *   logo={{
+ *     src: "/logo.svg",
+ *     alt: "Company Logo",
+ *     width: 280,
+ *     height: 250
+ *   }}
+ *   token="reset-token-from-url"
+ *   onSuccess={() => {
+ *     // Handle successful password reset
+ *   }}
+ * />
+ * ```
+ */
+import { useRef, useState } from 'react';
+import { useToast } from '../../context';
+import { FormEngine } from '../../form-engine';
+import { useAuth } from '../context';
+import { BackToLoginButton, createFormSubmissionHandler, passwordValidation } from './AuthFormUtils';
+import { AuthPageLayout } from './AuthPageLayout';
+export const resetPasswordDefaultText = {
+    title: 'Reset Your Password',
+    subtitle: 'Enter your new password to regain access to your account.',
+    passwordLabel: 'New Password',
+    confirmPasswordLabel: 'Confirm New Password',
+    submitButtonLabel: 'Reset Password',
+    loadingButtonLabel: 'Resetting...',
+    backToLoginLabel: 'Back to Login',
+    successMessage: 'Password has been reset successfully.',
+};
+/**
+ * Generic Reset Password Page component
+ * @template T - Authentication configuration type
+ */
+export function PagamioResetPasswordPage({ logo, text = resetPasswordDefaultText, appLabel, token, onSuccess, onError, onBackToLogin, className = '', }) {
+    const { authService } = useAuth();
+    const { addToast } = useToast();
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const formRef = useRef();
+    const resetPasswordFields = [
+        {
+            name: 'password',
+            label: text.passwordLabel,
+            type: 'password',
+            placeholder: 'Enter new password',
+            gridSpan: 12,
+            validation: passwordValidation,
+        },
+        {
+            name: 'confirmPassword',
+            label: text.confirmPasswordLabel,
+            type: 'password',
+            placeholder: 'Confirm new password',
+            gridSpan: 12,
+            validation: {
+                required: 'Please confirm your password',
+            },
+        },
+    ];
+    const handleSubmit = createFormSubmissionHandler({
+        setIsLoading,
+        setError,
+        addToast,
+        formRef,
+        onSuccess,
+        onError,
+    }, async (data) => {
+        const { password, confirmPassword } = data;
+        await authService.resetPassword({
+            token,
+            newPassword: password,
+            newPasswordConfirm: confirmPassword,
+        });
+    }, text.successMessage, 'Reset password failed. Please try again.');
+    return (_jsx(AuthPageLayout, { appLabel: appLabel, title: text.title, subtitle: text.subtitle, errorMessage: error, logo: logo, className: className, horizontal: false, children: _jsxs("div", { className: "mt-8", children: [_jsx(FormEngine, { fields: resetPasswordFields, onSubmit: handleSubmit, layout: "vertical", className: "mb-0 p-0", submitButtonClass: "w-full", submitButtonText: isLoading ? text.loadingButtonLabel : text.submitButtonLabel, onCancel: () => { }, showCancelButton: false, showSubmittingText: false, formRef: formRef }), onBackToLogin && _jsx(BackToLoginButton, { onBackToLogin: onBackToLogin, label: text.backToLoginLabel })] }) }));
+}
+export default PagamioResetPasswordPage;

package/lib/auth/components/hooks/useChangeUserPassword.d.ts

@@ -0,0 +1,26 @@
+export interface PostDataProps {
+    oldPassword: string;
+    newPassword: string;
+    confirmationPassword: string;
+}
+interface UseChangeUserPasswordProps {
+    onSuccess: () => void;
+    onError: (error: Error) => void;
+    handleUpdatePassword: (data: PostDataProps) => Promise<void>;
+}
+declare const useChangeUserPassword: ({ onSuccess, onError, handleUpdatePassword }: UseChangeUserPasswordProps) => {
+    form: {
+        passwordMatchError: string | null;
+        showTextFieldError: boolean;
+        oldPassword: string;
+        newPassword: string;
+        confirmationPassword: string;
+        setOldPassword: import("react").Dispatch<import("react").SetStateAction<string>>;
+        setNewPassword: import("react").Dispatch<import("react").SetStateAction<string>>;
+        setConfirmationPassword: import("react").Dispatch<import("react").SetStateAction<string>>;
+    };
+    isLoading: boolean;
+    error: string | null;
+    handleSubmit: (e: React.FormEvent) => Promise<void>;
+};
+export default useChangeUserPassword;

package/lib/auth/components/hooks/useChangeUserPassword.js

@@ -0,0 +1,63 @@
+import { useState } from 'react';
+import { useAuth } from '../../context';
+const useChangeUserPassword = ({ onSuccess, onError, handleUpdatePassword }) => {
+    const { logout } = useAuth();
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [oldPassword, setOldPassword] = useState('');
+    const [newPassword, setNewPassword] = useState('');
+    const [showTextFieldError, setShowTextFieldError] = useState(false);
+    const [passwordMatchError, setPasswordMatchError] = useState(null);
+    const [confirmationPassword, setConfirmationPassword] = useState('');
+    const handleResetFields = () => {
+        setOldPassword('');
+        setNewPassword('');
+        setConfirmationPassword('');
+    };
+    const handleSubmit = async (e) => {
+        e.preventDefault();
+        setError(null);
+        setPasswordMatchError(null);
+        setShowTextFieldError(false);
+        if (newPassword !== confirmationPassword) {
+            setShowTextFieldError(true);
+            setPasswordMatchError('New password and confirm password do not match.');
+            return;
+        }
+        const postData = {
+            oldPassword,
+            newPassword,
+            confirmationPassword,
+        };
+        setIsLoading(true);
+        try {
+            await handleUpdatePassword(postData);
+            handleResetFields();
+            onSuccess();
+            logout();
+        }
+        catch (error) {
+            onError(error);
+            setError(error.message);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return {
+        form: {
+            passwordMatchError,
+            showTextFieldError,
+            oldPassword,
+            newPassword,
+            confirmationPassword,
+            setOldPassword,
+            setNewPassword,
+            setConfirmationPassword,
+        },
+        isLoading,
+        error,
+        handleSubmit,
+    };
+};
+export default useChangeUserPassword;

package/lib/auth/components/index.d.ts

@@ -0,0 +1,8 @@
+export { default as LogoutButton } from './LogoutButton';
+export { default as PagamioLoginPage, loginPageDefaultText, type PagamioLoginCredentials, type PagamioLoginPageProps, } from './LoginPage';
+export { default as ChangePasswordPage, type ChangePasswordPageProps } from './ChangePasswordPage';
+export { type PostDataProps } from './hooks/useChangeUserPassword';
+export { default as PagamioCustomerRegistrationPage, customerRegistrationPageDefaultText, type PagamioCustomerRegistrationPageProps, } from './CustomerRegistrationPage';
+export { default as PagamioForgotPasswordPage, forgotPasswordDefaultText, type PagamioForgotPasswordPageProps, } from './ForgotPasswordPage';
+export { default as PagamioResetPasswordPage, resetPasswordDefaultText, type PagamioResetPasswordPageProps, } from './ResetPasswordPage';
+export { AuthPageLayout as PagamioAuthPageLayout } from './AuthPageLayout';

package/lib/auth/components/index.js

@@ -0,0 +1,7 @@
+export { default as LogoutButton } from './LogoutButton';
+export { default as PagamioLoginPage, loginPageDefaultText, } from './LoginPage';
+export { default as ChangePasswordPage } from './ChangePasswordPage';
+export { default as PagamioCustomerRegistrationPage, customerRegistrationPageDefaultText, } from './CustomerRegistrationPage';
+export { default as PagamioForgotPasswordPage, forgotPasswordDefaultText, } from './ForgotPasswordPage';
+export { default as PagamioResetPasswordPage, resetPasswordDefaultText, } from './ResetPasswordPage';
+export { AuthPageLayout as PagamioAuthPageLayout } from './AuthPageLayout';

package/lib/auth/context/AuthContext.d.ts

@@ -0,0 +1,65 @@
+import React, { type ReactNode } from 'react';
+import { type AuthService } from '../services';
+import type { AuthResponse, CustomAuthConfig } from '../types';
+/**
+ * Base auth configuration interface that can be extended
+ */
+export interface AppAuthConfig extends CustomAuthConfig {
+    UserInfo: {
+        id: string | number;
+        userName: string;
+        roles: string[];
+        [key: string]: unknown;
+    };
+    TokenInfo: {
+        token: string;
+        expiresIn: number;
+    };
+    Credentials: {
+        username: string;
+        password: string;
+    };
+    Error: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Authentication context state with generic type parameter
+ */
+type AuthContextState<T extends AppAuthConfig> = {
+    user: T['UserInfo'] | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: T['Error'] | null;
+};
+/**
+ * Authentication context actions with generic type parameter
+ */
+interface AuthContextActions<T extends AppAuthConfig> {
+    login: (response: T['Credentials'], rememberMe?: boolean) => Promise<AuthResponse<T>>;
+    logout: () => Promise<void>;
+    updateUser: (userData: Partial<T['UserInfo']>) => void;
+    clearError: () => void;
+}
+type AuthContextValue<T extends AppAuthConfig> = AuthContextState<T> & AuthContextActions<T> & {
+    authService: AuthService<T>;
+};
+/**
+ * Authentication context with generic type parameter
+ */
+export declare const AuthContext: React.Context<AuthContextValue<AppAuthConfig>>;
+interface AuthProviderProps<T extends AppAuthConfig> {
+    children: ReactNode;
+    authService: AuthService<T>;
+    validateOnInit?: boolean;
+}
+/**
+ * Authentication context provider component with generic type parameter
+ */
+export declare function AuthProvider<T extends AppAuthConfig>({ children, authService, validateOnInit, }: Readonly<AuthProviderProps<T>>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Custom hook for using auth context with generic type parameter
+ */
+export declare function useAuth<T extends AppAuthConfig>(): AuthContextValue<T>;
+export {};

package/lib/auth/context/AuthContext.js

@@ -0,0 +1,150 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+function createInitialState() {
+    return {
+        user: null,
+        isAuthenticated: false,
+        isLoading: true,
+        error: null,
+    };
+}
+/**
+ * Authentication context with generic type parameter
+ */
+export const AuthContext = createContext({
+    ...createInitialState(),
+    login: async () => {
+        return {};
+    },
+    logout: async () => { },
+    updateUser: () => { },
+    clearError: () => { },
+    authService: {},
+});
+/**
+ * Authentication context provider component with generic type parameter
+ */
+export function AuthProvider({ children, authService, validateOnInit = false, }) {
+    const [state, setState] = useState(() => createInitialState());
+    const setPartialState = useCallback((newState) => {
+        setState((prev) => ({ ...prev, ...newState }));
+    }, []);
+    // Initialize auth state from service
+    useEffect(() => {
+        const initializeAuth = async () => {
+            try {
+                const user = authService.getUser();
+                if (!user) {
+                    setPartialState({
+                        isAuthenticated: false,
+                        isLoading: false,
+                    });
+                    return;
+                }
+                if (validateOnInit) {
+                    const isValid = await authService.validateSession();
+                    if (!isValid) {
+                        await authService.logout();
+                        setPartialState({
+                            user: null,
+                            isAuthenticated: false,
+                            isLoading: false,
+                        });
+                        return;
+                    }
+                }
+                setPartialState({
+                    user,
+                    isAuthenticated: true,
+                    isLoading: false,
+                });
+            }
+            catch (error) {
+                setPartialState({
+                    error: {
+                        code: 'AUTH_INIT_ERROR',
+                        message: 'Failed to initialize authentication',
+                    },
+                    isLoading: false,
+                });
+            }
+        };
+        initializeAuth().then();
+    }, [authService, setPartialState, validateOnInit]);
+    const login = useCallback(async (credentials, rememberMe = false) => {
+        try {
+            const response = await authService.login(credentials, rememberMe);
+            setPartialState({
+                user: response.user,
+                isAuthenticated: true,
+                error: null,
+            });
+            return response;
+        }
+        catch (error) {
+            setPartialState({
+                error: {
+                    code: 'LOGIN_ERROR',
+                    message: 'Failed to process login response',
+                },
+            });
+            throw error;
+        }
+    }, [authService, setPartialState]);
+    const logout = useCallback(async () => {
+        try {
+            await authService.logout();
+            setPartialState({
+                user: null,
+                isAuthenticated: false,
+                error: null,
+            });
+        }
+        catch (error) {
+            setPartialState({
+                error: {
+                    code: 'LOGOUT_ERROR',
+                    message: 'Failed to logout properly',
+                },
+            });
+        }
+    }, [authService, setPartialState]);
+    const updateUser = useCallback(async (userData) => {
+        try {
+            const updatedUser = await authService.updateProfile(userData);
+            setPartialState({
+                user: updatedUser,
+            });
+        }
+        catch (error) {
+            setPartialState({
+                error: {
+                    code: 'UPDATE_USER_ERROR',
+                    message: 'Failed to update user profile',
+                },
+            });
+        }
+    }, [authService, setPartialState]);
+    const clearError = useCallback(() => {
+        setPartialState({ error: null });
+    }, [setPartialState]);
+    const contextValue = useMemo(() => ({
+        ...state,
+        authService,
+        login,
+        logout,
+        updateUser,
+        clearError,
+    }), [state, login, logout, updateUser, clearError, authService]);
+    return _jsx(AuthContext.Provider, { value: contextValue, children: children });
+}
+/**
+ * Custom hook for using auth context with generic type parameter
+ */
+export function useAuth() {
+    const context = useContext(AuthContext);
+    if (!context) {
+        throw new Error('useAuth must be used within an AuthProvider');
+    }
+    return context;
+}

package/lib/auth/context/index.d.ts

@@ -0,0 +1 @@
+export * from './AuthContext';

package/lib/auth/context/index.js

@@ -0,0 +1 @@
+export * from './AuthContext';

package/lib/auth/index.d.ts

@@ -0,0 +1,7 @@
+export * from './context';
+export * from './components';
+export * from './services';
+export * from './utils';
+export * from './types';
+export * from './shared';
+export * from './authenticators';

package/lib/auth/index.js

@@ -0,0 +1,7 @@
+export * from './context';
+export * from './components';
+export * from './services';
+export * from './utils';
+export * from './types';
+export * from './shared';
+export * from './authenticators';