@codebit-programando-solucoes/codebit-web-antd 1.1.9 → 1.1.16

package/dist/contexts/CodebitConfigContext.d.ts

@@ -13,15 +13,15 @@ export interface MenuItem {
 }
 
 /** User object type */
-export interface UserType {
+export interface LoggedUser {
     /** User's full name */
-    name: string;
+    name?: string;
     /** User's email address */
-    email: string;
+    email?: string;
     /** Unique user identifier */
-    id: string;
+    id?: string;
     /** User roles/permissions */
-    roles: string[];
+    roles?: string[];
 }
 
 /** Context type for Codebit configuration */
@@ -29,7 +29,7 @@ export interface CodebitConfigContextType {
     /** Array of menu items */
     menuItems: MenuItem[];
     /** Current user object */
-    user: UserType;
+    user: LoggedUser;
     /** Logout handler */
     onLogout: () => void | Promise<void>;
     /** Function to toggle the theme */
@@ -40,17 +40,14 @@ export interface CodebitConfigContextType {
     version?: string;
     /** Show version in menu */
     showVersion?: boolean;
-    /** OAuth callback URL for authentication */
-    oauthCallbackUrl: string;
+    /** Internationalization instance */
+    i18n?: import('i18next').i18n;
     /** Optional secondary sidebar content */
     secondarySidebar?: React.ReactNode;
     /** Width of the secondary sidebar */
     secondarySidebarWidth?: number;
 }
 
-/** Context for Codebit configuration */
-export const CodebitConfigContext: React.Context<CodebitConfigContextType | null>;
-
 /** Props for the CodebitConfigProvider component */
 export interface CodebitConfigProviderProps {
     /** Child components */
@@ -58,15 +55,9 @@ export interface CodebitConfigProviderProps {
     /** Menu items configuration */
     menuItems: MenuItem[];
     /** Current user object */
-    user: UserType;
+    user: LoggedUser;
     /** Logout handler */
     onLogout: () => void | Promise<void>;
-    /** Function to toggle the theme */
-    toggleTheme: () => void;
-    /** Current dark mode state */
-    isDarkMode: boolean;
-    /** OAuth callback URL for authentication */
-    oauthCallbackUrl: string;
     /** Application version. Default is '1.0' */
     version?: string;
     /** Show version in menu. Default is true */
@@ -75,6 +66,8 @@ export interface CodebitConfigProviderProps {
     secondarySidebar?: React.ReactNode;
     /** Width of the secondary sidebar */
     secondarySidebarWidth?: number;
+    /** Controls theme persistence in localStorage. Default is `true` */
+    storeThemeInLocalStorage?: boolean;
 }
 
 /**
@@ -88,3 +81,6 @@ export interface CodebitConfigProviderProps {
 export function CodebitConfigProvider(
     props: CodebitConfigProviderProps,
 ): React.JSX.Element;
+
+/** Context for Codebit configuration */
+export const CodebitConfigContext: React.Context<CodebitConfigContextType | null>;

package/dist/index.cjs

@@ -296,14 +296,18 @@ var __webpack_exports__ = {};
         CssTokenBridge: ()=>CssTokenBridge,
         LoggedMainContainer: ()=>LoggedMainContainer,
         Login: ()=>Login,
-        FilterContainer: ()=>FilterContainer,
-        HandleError: ()=>HandleError,
         ErrorRetry: ()=>ErrorRetry,
-        CodebitConfigProvider: ()=>CodebitConfigProvider,
         CodebitConfigContext: ()=>CodebitConfigContext,
         ListCard: ()=>ListCard,
-        ThemeToggle: ()=>ThemeToggle,
-        LoginContainer: ()=>LoginContainer
+        ForgotPassword: ()=>ForgotPassword,
+        LoginContainer: ()=>LoginContainer,
+        CodebitTheme: ()=>CodebitTheme,
+        LocalLoginRecoveryPasswordResult: ()=>LocalLoginRecoveryPasswordResult,
+        FilterContainer: ()=>FilterContainer,
+        HandleError: ()=>HandleError,
+        LocalLoginAuthenticationResult: ()=>LocalLoginAuthenticationResult,
+        CodebitConfigProvider: ()=>CodebitConfigProvider,
+        ThemeToggle: ()=>ThemeToggle
     });
     var jsx_runtime = __webpack_require__("../../node_modules/.pnpm/react@19.2.0/node_modules/react/jsx-runtime.js");
     const icons_namespaceObject = require("@ant-design/icons");
@@ -346,7 +350,53 @@ var __webpack_exports__ = {};
             },
             Login: {
                 loginTitle: 'Entrar',
-                googleLogin: 'Entrar com o Google'
+                googleLogin: 'Entrar com o Google',
+                emailLabel: 'E-mail',
+                passwordLabel: 'Senha',
+                emailPlaceholder: 'Digite seu e-mail',
+                passwordPlaceholder: 'Digite sua senha',
+                forgotPassword: 'Esqueceu sua senha?',
+                loginButton: 'Entrar',
+                emailRequired: 'Por favor, insira seu e-mail!',
+                emailInvalid: 'Por favor, insira um e-mail válido!',
+                passwordRequired: 'Por favor, insira sua senha!',
+                separator: 'ou',
+                errorTitle: 'Erro ao autenticar',
+                genericError: 'Ocorreu um erro. Por favor, tente novamente.',
+                invalidPassword: 'A senha está incorreta.',
+                invalidEmailOrPassword: 'O e-mail ou senha estão incorretos.',
+                userDisabled: 'Sua conta foi desativada. Por favor, entre em contato com o suporte.',
+                authenticationFailed: 'Autenticação falhou'
+            },
+            ForgotPassword: {
+                title: 'Redefinição de senha',
+                instructions: 'Informe seu e-mail para receber as instruções de recuperação de senha.',
+                emailRequired: 'Por favor, insira seu e-mail!',
+                emailInvalid: 'Por favor, insira um e-mail válido!',
+                emailPlaceholder: 'E-mail',
+                submitButton: 'Recuperar senha',
+                backToLogin: 'Voltar para o login',
+                resetSuccessMessage: 'Se o endereço informado estiver correto, enviaremos um e-mail com instruções para redefinição de senha.'
+            },
+            ChangePassword: {
+                title: 'Alterar senha',
+                passwordInstructions: 'Defina uma nova senha para realizar seu login.',
+                newPassword: 'Nova senha',
+                confirmPassword: 'Confirmar senha',
+                submit: 'Enviar',
+                backToLogin: 'Voltar para o login',
+                passwordRequired: 'Por favor, insira sua nova senha!',
+                passwordLength: '8 caracteres',
+                passwordUpperCase: 'uma letra maiúscula',
+                passwordLowerCase: 'uma letra minúscula',
+                passwordNumbers: 'um número',
+                passwordSpecialChars: 'um caractere especial (!@#$%^&*)',
+                passwordWeak: 'Senha fraca: Deve ter pelo menos {requirements}',
+                passwordsNotMatch: 'As senhas digitadas não coincidem!',
+                tokenInvalidTitle: 'Token inválido',
+                tokenInvalidOrExpired: 'O token informado é inválido ou está expirado. Inicie o processo de recuperação de senha e tente novamente.',
+                passwordChangedSuccess: 'A senha foi alterada com sucesso. Você será redirecionado ao login após fechar essa janela.',
+                tokenInvalidRecovery: 'O token informado é inválido ou está expirado. Inicie o processo de recuperação de senha novamente.'
             },
             LoginContainer: {
                 theme: 'Tema',
@@ -360,6 +410,12 @@ var __webpack_exports__ = {};
             },
             ListCard: {
                 clearFilters: 'Limpar filtros'
+            },
+            Common: {
+                ok: 'Ok',
+                close: 'Fechar',
+                invalidEmail: 'O e-mail é inválido ou não está registrado.',
+                recaptchaFailed: 'Validação reCAPTCHA falhou. Por favor, tente novamente.'
             }
         }
     };
@@ -395,7 +451,52 @@ var __webpack_exports__ = {};
             },
             Login: {
                 loginTitle: 'Login',
-                googleLogin: 'Login with Google'
+                googleLogin: 'Login with Google',
+                emailLabel: 'Email',
+                passwordLabel: 'Password',
+                emailPlaceholder: 'Enter your email',
+                passwordPlaceholder: 'Enter your password',
+                forgotPassword: 'Forgot password?',
+                loginButton: 'Login',
+                emailRequired: 'Please enter your email!',
+                emailInvalid: 'Please enter a valid email!',
+                passwordRequired: 'Please enter your password!',
+                separator: 'or',
+                errorTitle: 'Login Error',
+                invalidPassword: 'The password is incorrect.',
+                invalidEmailOrPassword: 'The email or password is incorrect.',
+                authenticationFailed: 'Authentication failed',
+                userDisabled: 'Your account has been disabled. Please contact support.'
+            },
+            ForgotPassword: {
+                title: 'Password reset',
+                instructions: 'Enter your email to receive password reset instructions.',
+                emailRequired: 'Please enter your email!',
+                emailInvalid: 'Please enter a valid email!',
+                emailPlaceholder: 'Email',
+                submitButton: 'Reset password',
+                backToLogin: 'Back to login',
+                resetSuccessMessage: 'If the provided email is correct, we will send you an email with instructions to reset your password.'
+            },
+            ChangePassword: {
+                title: 'Change password',
+                passwordInstructions: 'Set a new password to log in.',
+                newPassword: 'New password',
+                confirmPassword: 'Confirm password',
+                submit: 'Send',
+                backToLogin: 'Back to login',
+                passwordRequired: 'Please enter your new password!',
+                passwordLength: '8 characters',
+                passwordUpperCase: 'an uppercase letter',
+                passwordLowerCase: 'a lowercase letter',
+                passwordNumbers: 'a number',
+                passwordSpecialChars: 'a special character (!@#$%^&*)',
+                passwordWeak: 'Weak password: Must have at least {requirements}',
+                passwordsNotMatch: 'The passwords do not match!',
+                tokenInvalidTitle: 'Invalid Token',
+                tokenInvalidOrExpired: 'The provided token is invalid or expired. Start the password recovery process and try again.',
+                passwordChangedSuccess: 'Your password has been changed successfully. You will be redirected to the login after closing this window.',
+                tokenInvalidRecovery: 'The provided token is invalid or expired. Start the password recovery process again.'
             },
             LoginContainer: {
                 theme: 'Theme',
@@ -409,6 +510,13 @@ var __webpack_exports__ = {};
             },
             ListCard: {
                 clearFilters: 'Clear filters'
+            },
+            Common: {
+                ok: 'Ok',
+                close: 'Close',
+                genericError: 'An error occurred. Please try again.',
+                invalidEmail: 'The email address is invalid or not registered.',
+                recaptchaFailed: 'reCAPTCHA validation failed. Please try again.'
             }
         }
     };
@@ -430,30 +538,61 @@ var __webpack_exports__ = {};
     });
     const i18n = i18nLib;
     const CodebitConfigContext = /*#__PURE__*/ (0, external_react_.createContext)(null);
-    function CodebitConfigProvider({ children, menuItems, user, onLogout, toggleTheme, isDarkMode, oauthCallbackUrl, version = '1.0', showVersion = true, secondarySidebar, secondarySidebarWidth = 280 }) {
+    function CodebitConfigProvider({ children, menuItems, user, onLogout, version = '1.0', showVersion = true, secondarySidebar, secondarySidebarWidth = 280, storeThemeInLocalStorage = true }) {
+        const getSystemTheme = ()=>globalThis.matchMedia?.('(prefers-color-scheme: dark)')?.matches ?? false;
+        const [isDarkMode, setIsDarkMode] = (0, external_react_.useState)(()=>{
+            if (storeThemeInLocalStorage) {
+                const savedTheme = localStorage.getItem('theme');
+                if (null !== savedTheme) return 'dark' === savedTheme;
+            }
+            return getSystemTheme();
+        });
+        (0, external_react_.useEffect)(()=>{
+            const mediaQuery = globalThis.matchMedia('(prefers-color-scheme: dark)');
+            const handleThemeChange = (e)=>{
+                if (!storeThemeInLocalStorage) return void setIsDarkMode(e.matches);
+                const savedTheme = localStorage.getItem('theme');
+                if (null === savedTheme) setIsDarkMode(e.matches);
+            };
+            mediaQuery.addEventListener('change', handleThemeChange);
+            return ()=>{
+                mediaQuery.removeEventListener('change', handleThemeChange);
+            };
+        }, [
+            storeThemeInLocalStorage
+        ]);
+        const toggleTheme = ()=>{
+            const newTheme = !isDarkMode;
+            setIsDarkMode(newTheme);
+            if (storeThemeInLocalStorage) localStorage.setItem('theme', newTheme ? 'dark' : 'light');
+        };
+        const resetToSystemTheme = ()=>{
+            if (storeThemeInLocalStorage) localStorage.removeItem('theme');
+            setIsDarkMode(getSystemTheme());
+        };
         const contextValue = (0, external_react_.useMemo)(()=>({
                 menuItems,
                 user,
                 onLogout,
-                toggleTheme,
-                isDarkMode,
-                oauthCallbackUrl,
                 version,
                 showVersion,
                 i18n: i18n,
                 secondarySidebar,
-                secondarySidebarWidth
+                secondarySidebarWidth,
+                isDarkMode,
+                setIsDarkMode,
+                toggleTheme,
+                resetToSystemTheme
             }), [
             menuItems,
             user,
             onLogout,
-            toggleTheme,
-            isDarkMode,
             version,
             showVersion,
-            oauthCallbackUrl,
             secondarySidebar,
-            secondarySidebarWidth
+            secondarySidebarWidth,
+            isDarkMode,
+            storeThemeInLocalStorage
         ]);
         return /*#__PURE__*/ (0, jsx_runtime.jsxs)(CodebitConfigContext.Provider, {
             value: contextValue,
@@ -480,11 +619,9 @@ var __webpack_exports__ = {};
         onLogout: external_prop_types_default().func.isRequired,
         version: external_prop_types_default().string,
         showVersion: external_prop_types_default().bool,
-        toggleTheme: external_prop_types_default().func.isRequired,
-        isDarkMode: external_prop_types_default().bool.isRequired,
-        oauthCallbackUrl: external_prop_types_default().string.isRequired,
         secondarySidebar: external_prop_types_default().node,
-        secondarySidebarWidth: external_prop_types_default().number
+        secondarySidebarWidth: external_prop_types_default().number,
+        storeThemeInLocalStorage: external_prop_types_default().bool
     };
     const ThemeToggle = ()=>{
         const config = (0, external_react_.useContext)(CodebitConfigContext);
@@ -1022,21 +1159,16 @@ var __webpack_exports__ = {};
                                 justify: 'center',
                                 className: Login_module.titleRow,
                                 children: [
-                                    'string' == typeof title ? /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Title, {
+                                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Title, {
                                         level: 3,
                                         className: Login_module.appTitle,
                                         children: title
-                                    }) : title,
+                                    }),
                                     /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Divider, {
                                         className: Login_module.divider
                                     })
                                 ]
                             }),
-                            /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Title, {
-                                level: 4,
-                                className: `login-header ${Login_module.loginHeader}`,
-                                children: t('LoginContainer.signIn')
-                            }),
                             children
                         ]
                     })
@@ -1051,42 +1183,227 @@ var __webpack_exports__ = {};
         ]).isRequired,
         children: external_prop_types_default().node
     };
-    function Login({ title }) {
-        const [loading, setLoading] = (0, external_react_.useState)(false);
-        const config = (0, external_react_.useContext)(CodebitConfigContext);
-        if (!config) throw new Error('Login must be used within CodebitConfigProvider');
-        const { oauthCallbackUrl } = config;
+    const logger = new codebit_web_namespaceObject.Logger('Login');
+    const LocalLoginAuthenticationResult = Object.freeze({
+        INVALID_EMAIL: 'INVALID_EMAIL',
+        INVALID_PASSWORD: 'INVALID_PASSWORD',
+        INVALID_EMAIL_OR_PASSWORD: 'INVALID_EMAIL_OR_PASSWORD',
+        RECAPTCHA_VALIDATION_FAIL: 'RECAPTCHA_VALIDATION_FAIL',
+        USER_DISABLED: 'USER_DISABLED',
+        SUCCESS: 'SUCCESS'
+    });
+    function Login({ title, oauthCallbackUrl, navigateToForgotPassword, submitAuthenticateLocalUser }) {
+        const [localLoading, setLocalLoading] = (0, external_react_.useState)(false);
+        const [googleLoading, setGoogleLoading] = (0, external_react_.useState)(false);
+        const [form] = external_antd_namespaceObject.Form.useForm();
         const { t } = useCodebitWebAntdTranslation();
+        const { modal } = external_antd_namespaceObject.App.useApp();
+        const navigate = (0, external_react_router_namespaceObject.useNavigate)();
+        const context = {
+            navigate
+        };
         const handleGoogleLogin = ()=>{
-            setLoading(true);
+            setGoogleLoading(true);
             setTimeout(()=>{
-                console.debug('Redirecting to Google Login...');
                 globalThis.location.assign(oauthCallbackUrl);
+                setGoogleLoading(false);
             }, 1000);
         };
-        return /*#__PURE__*/ (0, jsx_runtime.jsx)(LoginContainer, {
+        const handleLocalLogin = async (values)=>{
+            setLocalLoading(true);
+            try {
+                const { email, password } = values;
+                const result = await submitAuthenticateLocalUser(email, password, context);
+                switch(result){
+                    case LocalLoginAuthenticationResult.SUCCESS:
+                        break;
+                    case LocalLoginAuthenticationResult.INVALID_EMAIL:
+                        form.setFields([
+                            {
+                                name: 'email',
+                                errors: [
+                                    t('Common.invalidEmail')
+                                ]
+                            }
+                        ]);
+                        break;
+                    case LocalLoginAuthenticationResult.INVALID_PASSWORD:
+                        form.setFields([
+                            {
+                                name: 'password',
+                                errors: [
+                                    t('Login.invalidPassword')
+                                ]
+                            }
+                        ]);
+                        break;
+                    case LocalLoginAuthenticationResult.INVALID_EMAIL_OR_PASSWORD:
+                        form.setFields([
+                            {
+                                name: 'email',
+                                errors: [
+                                    t('Login.invalidEmailOrPassword')
+                                ]
+                            },
+                            {
+                                name: 'password',
+                                errors: [
+                                    t('Login.invalidEmailOrPassword')
+                                ]
+                            }
+                        ]);
+                        break;
+                    case LocalLoginAuthenticationResult.RECAPTCHA_VALIDATION_FAIL:
+                        modal.error({
+                            title: t('Login.authenticationFailed'),
+                            content: t('Common.recaptchaFailed'),
+                            okText: t('Common.ok')
+                        });
+                        break;
+                    case LocalLoginAuthenticationResult.USER_DISABLED:
+                        modal.error({
+                            title: t('Login.authenticationFailed'),
+                            content: t('Login.userDisabled'),
+                            okText: t('Common.ok')
+                        });
+                        break;
+                    default:
+                        logger.warn('Unhandled authentication result:', result);
+                        modal.error({
+                            title: t('Login.authenticationFailed'),
+                            content: t('Common.genericError'),
+                            okText: t('Common.ok')
+                        });
+                }
+            } catch (error) {
+                logger.error(error);
+                react_namespaceObject.captureException(error);
+                modal.error({
+                    title: t('Login.errorTitle'),
+                    content: t('Common.genericError'),
+                    okText: t('Common.ok')
+                });
+            } finally{
+                setLocalLoading(false);
+            }
+        };
+        const handleNavigateToForgotPassword = async ()=>{
+            await navigateToForgotPassword(context);
+        };
+        return /*#__PURE__*/ (0, jsx_runtime.jsxs)(LoginContainer, {
             title: title || t('Login.loginTitle'),
-            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Flex, {
-                vertical: true,
-                align: 'center',
-                gap: 20,
-                children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
-                    type: 'primary',
+            children: [
+                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Title, {
+                    level: 4,
+                    className: `${Login_module.loginHeader}`,
+                    children: t('LoginContainer.signIn')
+                }),
+                /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Space, {
+                    direction: 'vertical',
                     size: 'large',
-                    icon: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.GoogleOutlined, {}),
-                    loading: loading,
-                    onClick: handleGoogleLogin,
-                    block: true,
-                    children: t('Login.googleLogin')
+                    style: {
+                        width: '100%'
+                    },
+                    children: [
+                        submitAuthenticateLocalUser && /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Form, {
+                            name: 'login-form',
+                            layout: 'vertical',
+                            onFinish: handleLocalLogin,
+                            children: [
+                                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                                    name: 'email',
+                                    label: t('Login.emailLabel'),
+                                    rules: [
+                                        {
+                                            required: true,
+                                            message: t('Login.emailRequired')
+                                        },
+                                        {
+                                            type: 'email',
+                                            message: t('Login.emailInvalid')
+                                        }
+                                    ],
+                                    children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Input, {
+                                        prefix: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.MailOutlined, {}),
+                                        placeholder: t('Login.emailPlaceholder'),
+                                        size: 'large'
+                                    })
+                                }),
+                                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                                    name: 'password',
+                                    label: t('Login.passwordLabel'),
+                                    rules: [
+                                        {
+                                            required: true,
+                                            message: t('Login.passwordRequired')
+                                        }
+                                    ],
+                                    children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Input.Password, {
+                                        prefix: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.LockOutlined, {}),
+                                        placeholder: t('Login.passwordPlaceholder'),
+                                        size: 'large'
+                                    })
+                                }),
+                                navigateToForgotPassword && /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                                    children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Row, {
+                                        justify: 'end',
+                                        children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Col, {
+                                            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Link, {
+                                                onClick: handleNavigateToForgotPassword,
+                                                children: t('Login.forgotPassword')
+                                            })
+                                        })
+                                    })
+                                }),
+                                /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                                    style: {
+                                        marginBottom: 0
+                                    },
+                                    children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                                        type: 'primary',
+                                        htmlType: 'submit',
+                                        size: 'large',
+                                        loading: localLoading,
+                                        disabled: googleLoading,
+                                        block: true,
+                                        children: t('Login.loginButton')
+                                    })
+                                })
+                            ]
+                        }),
+                        submitAuthenticateLocalUser && oauthCallbackUrl && /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Divider, {
+                            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Text, {
+                                type: 'secondary',
+                                children: t('Login.separator')
+                            })
+                        }),
+                        oauthCallbackUrl && /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Flex, {
+                            vertical: true,
+                            align: 'center',
+                            children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                                type: 'primary',
+                                size: 'large',
+                                icon: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.GoogleOutlined, {}),
+                                loading: googleLoading,
+                                onClick: handleGoogleLogin,
+                                disabled: localLoading,
+                                block: true,
+                                children: t('Login.googleLogin')
+                            })
+                        })
+                    ]
                 })
-            })
+            ]
         });
     }
     Login.propTypes = {
         title: external_prop_types_default().oneOfType([
             external_prop_types_default().string,
             external_prop_types_default().node
-        ])
+        ]),
+        oauthCallbackUrl: external_prop_types_default().string,
+        navigateToForgotPassword: external_prop_types_default().func,
+        submitAuthenticateLocalUser: external_prop_types_default().func
     };
     const HandleError_module = {
         container: "container-A_JXAc",
@@ -1152,14 +1469,199 @@ var __webpack_exports__ = {};
     HandleError.propTypes = {
         title: external_prop_types_default().string
     };
+    const ForgotPassword_logger = new codebit_web_namespaceObject.Logger('ForgotPassword');
+    const LocalLoginRecoveryPasswordResult = Object.freeze({
+        INVALID_EMAIL: 'INVALID_EMAIL',
+        RECAPTCHA_VALIDATION_FAIL: 'RECAPTCHA_VALIDATION_FAIL',
+        SUCCESS: 'SUCCESS'
+    });
+    const ForgotPassword = ({ navigateToLogin, submitRecoveryPassword })=>{
+        const [form] = external_antd_namespaceObject.Form.useForm();
+        const { modal } = external_antd_namespaceObject.App.useApp();
+        const [loading, setLoading] = (0, external_react_.useState)(false);
+        const { t } = useCodebitWebAntdTranslation();
+        const navigate = (0, external_react_router_namespaceObject.useNavigate)();
+        const context = {
+            navigate
+        };
+        const handleNavigateToLogin = async ()=>{
+            await navigateToLogin(context);
+        };
+        const handleRecoveryPassword = async (values)=>{
+            setLoading(true);
+            try {
+                setLoading(true);
+                const result = await submitRecoveryPassword(values.email, context);
+                switch(result){
+                    case LocalLoginRecoveryPasswordResult.SUCCESS:
+                        modal.success({
+                            title: t('ForgotPassword.title'),
+                            content: t('ForgotPassword.resetSuccessMessage'),
+                            onOk: handleNavigateToLogin,
+                            okText: t('Common.ok')
+                        });
+                        break;
+                    case LocalLoginRecoveryPasswordResult.INVALID_EMAIL:
+                        form.setFields([
+                            {
+                                name: 'email',
+                                errors: [
+                                    t('Common.invalidEmail')
+                                ]
+                            }
+                        ]);
+                        break;
+                    case LocalLoginRecoveryPasswordResult.RECAPTCHA_VALIDATION_FAIL:
+                        modal.error({
+                            title: t('ForgotPassword.title'),
+                            content: t('Common.recaptchaFailed'),
+                            okText: t('Common.ok')
+                        });
+                        break;
+                }
+            } catch (error) {
+                ForgotPassword_logger.error(error);
+                react_namespaceObject.captureException(error);
+                modal.error({
+                    title: t('ForgotPassword.title'),
+                    content: t('Common.genericError'),
+                    okText: t('Common.ok')
+                });
+            } finally{
+                setLoading(false);
+            }
+        };
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)(LoginContainer, {
+            title: t('ForgotPassword.title'),
+            children: /*#__PURE__*/ (0, jsx_runtime.jsxs)(external_antd_namespaceObject.Form, {
+                form: form,
+                name: 'forgot-password-form',
+                onFinish: handleRecoveryPassword,
+                initialValues: {
+                    email: ''
+                },
+                style: {
+                    width: '100%'
+                },
+                children: [
+                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Paragraph, {
+                        style: {
+                            textAlign: 'center'
+                        },
+                        children: t('ForgotPassword.instructions')
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                        name: 'email',
+                        rules: [
+                            {
+                                required: true,
+                                message: t('ForgotPassword.emailRequired')
+                            },
+                            {
+                                type: 'email',
+                                message: t('ForgotPassword.emailInvalid')
+                            }
+                        ],
+                        children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Input, {
+                            prefix: /*#__PURE__*/ (0, jsx_runtime.jsx)(icons_namespaceObject.MailOutlined, {}),
+                            placeholder: t('ForgotPassword.emailPlaceholder'),
+                            size: 'large'
+                        })
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Form.Item, {
+                        children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Button, {
+                            type: 'primary',
+                            htmlType: 'submit',
+                            size: 'large',
+                            loading: loading,
+                            style: {
+                                width: '100%'
+                            },
+                            children: t('ForgotPassword.submitButton')
+                        })
+                    }),
+                    navigateToLogin && /*#__PURE__*/ (0, jsx_runtime.jsx)("div", {
+                        style: {
+                            textAlign: 'center'
+                        },
+                        children: /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.Typography.Link, {
+                            onClick: handleNavigateToLogin,
+                            children: t('ForgotPassword.backToLogin')
+                        })
+                    })
+                ]
+            })
+        });
+    };
+    ForgotPassword.propTypes = {
+        navigateToLogin: external_prop_types_default().func,
+        submitRecoveryPassword: external_prop_types_default().func.isRequired
+    };
+    const CodebitTheme = (props)=>{
+        const { token } = external_antd_namespaceObject.theme.useToken();
+        const config = (0, external_react_.useContext)(CodebitConfigContext);
+        if (!config) throw new Error('CodebitTheme must be used within CodebitConfigProvider');
+        const { isDarkMode } = config;
+        (0, external_react_.useEffect)(()=>{
+            const rootElement = document.getElementById('root');
+            if (isDarkMode) {
+                document.body.classList.add('dark-theme');
+                rootElement.classList.add('dark-theme');
+            } else {
+                document.body.classList.remove('dark-theme');
+                rootElement.classList.remove('dark-theme');
+            }
+            document.documentElement.style.setProperty('--color-primary', isDarkMode ? '#589C75' : '#29D266');
+        }, [
+            isDarkMode,
+            token.colorBgContainer
+        ]);
+        return /*#__PURE__*/ (0, jsx_runtime.jsx)(external_antd_namespaceObject.ConfigProvider, {
+            theme: {
+                algorithm: isDarkMode ? external_antd_namespaceObject.theme.darkAlgorithm : external_antd_namespaceObject.theme.defaultAlgorithm,
+                token: {
+                    colorPrimary: isDarkMode ? '#589C75' : '#29D266',
+                    colorInfo: isDarkMode ? '#589C75' : '#29D266',
+                    colorLink: isDarkMode ? '#589C75' : '#29D266'
+                },
+                components: {
+                    Menu: {
+                        itemSelectedBg: isDarkMode ? '#589C75' : '#29D266',
+                        itemSelectedColor: '#FAFAFA',
+                        darkItemSelectedBg: isDarkMode ? '#589C75' : '#29D266',
+                        darkItemSelectedColor: '#FAFAFA'
+                    },
+                    Button: {
+                        colorPrimary: isDarkMode ? '#589C75' : '#29D266',
+                        colorPrimaryHover: isDarkMode ? '#6DB589' : '#3FE67F',
+                        colorPrimaryActive: isDarkMode ? '#4A8361' : '#1FBF4D'
+                    },
+                    Layout: {
+                        siderBg: isDarkMode ? '#1a1a1a' : '#001529',
+                        triggerBg: isDarkMode ? '#589C75' : '#29D266',
+                        triggerColor: '#FAFAFA'
+                    },
+                    Header: {
+                        colorPrimary: isDarkMode ? '#589C75' : '#29D266'
+                    }
+                }
+            },
+            ...props
+        });
+    };
+    CodebitTheme.propTypes = {};
 })();
 exports.CodebitConfigContext = __webpack_exports__.CodebitConfigContext;
 exports.CodebitConfigProvider = __webpack_exports__.CodebitConfigProvider;
+exports.CodebitTheme = __webpack_exports__.CodebitTheme;
 exports.CssTokenBridge = __webpack_exports__.CssTokenBridge;
 exports.ErrorRetry = __webpack_exports__.ErrorRetry;
 exports.FilterContainer = __webpack_exports__.FilterContainer;
+exports.ForgotPassword = __webpack_exports__.ForgotPassword;
 exports.HandleError = __webpack_exports__.HandleError;
 exports.ListCard = __webpack_exports__.ListCard;
+exports.LocalLoginAuthenticationResult = __webpack_exports__.LocalLoginAuthenticationResult;
+exports.LocalLoginRecoveryPasswordResult = __webpack_exports__.LocalLoginRecoveryPasswordResult;
 exports.LoggedMainContainer = __webpack_exports__.LoggedMainContainer;
 exports.Login = __webpack_exports__.Login;
 exports.LoginContainer = __webpack_exports__.LoginContainer;
@@ -1168,11 +1670,15 @@ exports.ThemeToggle = __webpack_exports__.ThemeToggle;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "CodebitConfigContext",
     "CodebitConfigProvider",
+    "CodebitTheme",
     "CssTokenBridge",
     "ErrorRetry",
     "FilterContainer",
+    "ForgotPassword",
     "HandleError",
     "ListCard",
+    "LocalLoginAuthenticationResult",
+    "LocalLoginRecoveryPasswordResult",
     "LoggedMainContainer",
     "Login",
     "LoginContainer",

package/dist/index.css

@@ -178,7 +178,7 @@
 }
 
 .themeRow-ZhL0jS {
-  margin-bottom: 16px;
+  margin-bottom: var(--antd-margin);
 }
 
 .loginCard-k07Wjb {
@@ -190,7 +190,7 @@
 }
 
 .titleRow-XMkFzo {
-  margin-bottom: 20px;
+  margin-bottom: var(--antd-margin-sm);
 }
 
 .appTitle-tL41k9 {
@@ -198,12 +198,13 @@
 }
 
 .divider-oJpEKR {
-  margin: 12px 0;
+  margin: var(--antd-margin-xs) 0;
 }
 
 .loginHeader-bBGO5B {
   text-align: center;
-  margin-bottom: 24px;
+  margin-top: 0;
+  margin-bottom: var(--antd-margin);
   font-weight: normal;
 }
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export * from './locales';
 export * from './components/index';
 export * from './contexts/index';
 export * from './public-pages/index';
+export * from './theme';

package/dist/public-pages/ChangePassword.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { LocalLoginConfContext } from './Login';
+
+/** Props for the ChangePassword component (none required) */
+export interface ChangePasswordProps {
+    /** Validates password reset token in the current context */
+    checkToken: (context: LocalLoginConfContext) => Promise<Boolean>;
+
+    /** Submits new password using validated token from context */
+    submitChangePassword?: (
+        password: string,
+        context: LocalLoginConfContext,
+    ) => Promise<LocalLoginChangePasswordResult>;
+}
+
+export enum LocalLoginChangePasswordResult {
+    INVALID_TOKEN = 'INVALID_TOKEN',
+    SUCCESS = 'SUCCESS',
+}
+
+/**
+ * React component for password change functionality.
+ *
+ * Handles the complete password reset workflow including:
+ *
+ * - Token validation
+ * - Password strength validation
+ * - Form submission
+ * - Success/error messaging
+ *
+ * @param props - Component props (none required)
+ * @returns JSX element with password change interface
+ * @throws Error if used outside CodebitConfigProvider context
+ */
+export function ChangePassword(props: ChangePasswordProps): React.JSX.Element;

package/dist/public-pages/ForgotPassword.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { LocalLoginConfContext } from './Login';
+
+/** Props for the ForgotPassword component */
+export interface ForgotPasswordProps {
+    /** Navigates to the login screen when authentication is required */
+    navigateToLogin: (context: LocalLoginConfContext) => Promise<void>;
+
+    /** Submits password recovery request for the specified email */
+    submitRecoveryPassword?: (
+        email: string,
+        context: LocalLoginConfContext,
+    ) => Promise<LocalLoginRecoveryPasswordResult>;
+}
+
+export enum LocalLoginRecoveryPasswordResult {
+    INVALID_EMAIL = 'INVALID_EMAIL',
+    RECAPTCHA_VALIDATION_FAIL = 'RECAPTCHA_VALIDATION_FAIL',
+    SUCCESS = 'SUCCESS',
+}
+
+/**
+ * Password reset component for initiating account recovery.
+ *
+ * Handles the complete password reset workflow:
+ *
+ * - Email address input
+ * - Reset link request
+ * - Success/error messaging
+ *
+ * Requires usage within `CodebitConfigProvider` context to access authentication settings.
+ *
+ * @param props - Component props
+ * @returns JSX element with password reset interface
+ * @throws Error if used outside CodebitConfigProvider context
+ */
+export function ForgotPassword(props: ForgotPasswordProps): React.JSX.Element;

package/dist/public-pages/Login.d.ts

@@ -1,19 +1,54 @@
 import * as React from 'react';
+import { NavigateFunction, Params } from 'react-router';
+
+export enum LocalLoginAuthenticationResult {
+    /** Email is invalid or not registered */
+    INVALID_EMAIL = 'INVALID_EMAIL',
+    /** Password is incorrect */
+    INVALID_PASSWORD = 'INVALID_PASSWORD',
+    /** Email or password combination is invalid */
+    INVALID_EMAIL_OR_PASSWORD = 'INVALID_EMAIL_OR_PASSWORD',
+    /** ReCAPTCHA validation failed */
+    RECAPTCHA_VALIDATION_FAIL = 'RECAPTCHA_VALIDATION_FAIL',
+    /** User account is disabled */
+    USER_DISABLED = 'USER_DISABLED',
+    /** Authentication was successful */
+    SUCCESS = 'SUCCESS',
+}
+
+/** Context for local login configuration */
+export type LocalLoginConfContext = {
+    navigate: NavigateFunction;
+    params?: Readonly<Params<string>>;
+};
 
 /** Props for the Login component */
 export interface LoginProps {
-    /** Title for the login screen */
+    /** Optional title for the login screen (overrides localized default) */
     title?: string | React.ReactNode;
+
+    /** OAuth callback URL for authentication */
+    oauthCallbackUrl?: string;
+
+    /** Function to authenticate a local user */
+    submitAuthenticateLocalUser?: (
+        email: string,
+        password: string,
+        context: LocalLoginConfContext,
+    ) => Promise<LocalLoginAuthenticationResult>;
+
+    /** Optional function to initiate password recovery process. When omitted, password reset functionality will be disabled. */
+    navigateToForgotPassword?: (
+        context: LocalLoginConfContext,
+    ) => Promise<void>;
 }
 
 /**
- * Login component that renders a login screen with Google OAuth integration.
+ * Login component that renders both Google OAuth and email/password login options.
  *
- * This component displays a login button that redirects to the configured OAuth callback URL. It must be used within a CodebitConfigProvider context to access the OAuth
- * configuration.
+ * This component displays both Google login button and local authentication form (when configured), requiring usage within CodebitConfigProvider to access authentication settings.
  *
  * @param props - Component props
- * @returns Login screen with Google login button
- * @throws Error if used outside CodebitConfigProvider context
+ * @returns JSX element with complete login interface
  */
 export function Login(props: LoginProps): React.JSX.Element;

package/dist/public-pages/index.d.ts

@@ -1,3 +1,4 @@
 export * from './Login';
 export * from './LoginContainer';
 export * from './HandleError';
+export * from './ForgotPassword';

package/dist/theme/CodebitTheme.d.ts

@@ -0,0 +1,5 @@
+import { ConfigProviderProps } from 'antd';
+import { FC } from 'react';
+
+/** A theme provider component that configures Ant Design with Codebit's custom theme Handles both light and dark mode variants */
+export declare const CodebitTheme: FC<ConfigProviderProps>;

package/dist/theme/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebit-programando-solucoes/codebit-web-antd",
-  "version": "1.1.9",
+  "version": "1.1.16",
   "main": "./dist/index.cjs",
   "type": "module",
   "types": "./src/index.d.ts",
@@ -26,18 +26,18 @@
     "antd": "^5.28.1",
     "i18next": "^25.6.2",
     "prop-types": "^15.8.1",
-    "react": "^19.1.1",
-    "react-dom": "^19.2.0",
-    "react-i18next": "^16.3.3",
-    "react-router": "^7.9.6",
+    "react-i18next": "^16.3.5",
+    "react-router": "7.12.0",
     "sass": "^1.94.0"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.1",
-    "@rsbuild/plugin-react": "^1.4.1",
-    "@rsbuild/plugin-sass": "^1.4.0",
+    "@eslint/js": "^9.39.2",
+    "@rsbuild/plugin-react": "1.4.3",
+    "@rsbuild/plugin-sass": "1.4.1",
     "@rslib/core": "^0.18.0",
     "@swc/core": "^1.13.5",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
     "cross-env": "^10.0.0",
     "css-loader": "^7.1.2",
     "del-cli": "^6.0.0",