@nocios/crudify-ui 3.0.10 → 3.0.14

package/dist/index.mjs

@@ -390,1910 +390,1920 @@ var useLoginState = () => {
   return context;
 };
 
-// src/components/CrudifyLogin/Forms/LoginForm.tsx
-import { useEffect as useEffect4, useRef } from "react";
-import { Typography, TextField, Button, Box, CircularProgress, Alert, Link } from "@mui/material";
+// src/providers/SessionProvider.tsx
+import { createContext as createContext4, useContext as useContext4, useMemo as useMemo2 } from "react";
 
-// src/utils/errorHandler.ts
-var ERROR_CODES = {
-  // Authentication Errors
-  INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
-  UNAUTHORIZED: "UNAUTHORIZED",
-  INVALID_API_KEY: "INVALID_API_KEY",
-  USER_NOT_FOUND: "USER_NOT_FOUND",
-  USER_NOT_ACTIVE: "USER_NOT_ACTIVE",
-  NO_PERMISSION: "NO_PERMISSION",
-  // Data Errors
-  ITEM_NOT_FOUND: "ITEM_NOT_FOUND",
-  NOT_FOUND: "NOT_FOUND",
-  IN_USE: "IN_USE",
-  // Validation Errors
-  FIELD_ERROR: "FIELD_ERROR",
-  BAD_REQUEST: "BAD_REQUEST",
-  INVALID_EMAIL: "INVALID_EMAIL",
-  INVALID_CODE: "INVALID_CODE",
-  // System Errors
-  INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
-  DATABASE_CONNECTION_ERROR: "DATABASE_CONNECTION_ERROR",
-  INVALID_CONFIGURATION: "INVALID_CONFIGURATION",
-  UNKNOWN_OPERATION: "UNKNOWN_OPERATION",
-  // Rate Limiting
-  TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS",
-  // Network Errors
-  NETWORK_ERROR: "NETWORK_ERROR",
-  TIMEOUT_ERROR: "TIMEOUT_ERROR"
-};
-var ERROR_SEVERITY_MAP = {
-  // Authentication - warning (user can fix)
-  [ERROR_CODES.INVALID_CREDENTIALS]: "warning",
-  [ERROR_CODES.UNAUTHORIZED]: "warning",
-  [ERROR_CODES.INVALID_API_KEY]: "error",
-  [ERROR_CODES.USER_NOT_FOUND]: "warning",
-  [ERROR_CODES.USER_NOT_ACTIVE]: "warning",
-  [ERROR_CODES.NO_PERMISSION]: "warning",
-  // Data - info (might be expected)
-  [ERROR_CODES.ITEM_NOT_FOUND]: "info",
-  [ERROR_CODES.NOT_FOUND]: "info",
-  [ERROR_CODES.IN_USE]: "warning",
-  // Validation - warning (user input issue)
-  [ERROR_CODES.FIELD_ERROR]: "warning",
-  [ERROR_CODES.BAD_REQUEST]: "warning",
-  [ERROR_CODES.INVALID_EMAIL]: "warning",
-  [ERROR_CODES.INVALID_CODE]: "warning",
-  // System - error (server issue)
-  [ERROR_CODES.INTERNAL_SERVER_ERROR]: "error",
-  [ERROR_CODES.DATABASE_CONNECTION_ERROR]: "error",
-  [ERROR_CODES.INVALID_CONFIGURATION]: "error",
-  [ERROR_CODES.UNKNOWN_OPERATION]: "error",
-  // Rate limiting - warning with higher duration
-  [ERROR_CODES.TOO_MANY_REQUESTS]: "warning",
-  // Network - error
-  [ERROR_CODES.NETWORK_ERROR]: "error",
-  [ERROR_CODES.TIMEOUT_ERROR]: "error"
-};
-function parseApiError(response) {
-  const errors = [];
-  try {
-    const apiResponse = response;
-    if (apiResponse.data && typeof apiResponse.data === "object") {
-      const responseData = apiResponse.data;
-      if (responseData.response) {
-        const { status, fieldsWarning } = responseData.response;
-        if (fieldsWarning && typeof fieldsWarning === "object") {
-          Object.entries(fieldsWarning).forEach(([field, messages]) => {
-            if (Array.isArray(messages) && messages.length > 0) {
-              errors.push({
-                code: ERROR_CODES.FIELD_ERROR,
-                message: messages[0],
-                severity: "warning",
-                field
-              });
-            }
-          });
-        }
-        if (status && typeof status === "string") {
-          const errorCode = status;
-          if (ERROR_SEVERITY_MAP[errorCode]) {
-            errors.push({
-              code: errorCode,
-              message: getErrorMessage(errorCode),
-              severity: ERROR_SEVERITY_MAP[errorCode]
-            });
-          }
-        }
-      }
-    }
-    if (apiResponse.errors) {
-      if (typeof apiResponse.errors === "string") {
-        errors.push({
-          code: ERROR_CODES.BAD_REQUEST,
-          message: apiResponse.errors,
-          severity: "warning"
-        });
-      } else if (typeof apiResponse.errors === "object") {
-        const errorObj = apiResponse.errors;
-        Object.entries(errorObj).forEach(([field, messages]) => {
-          if (Array.isArray(messages) && messages.length > 0) {
-            if (field === "_error") {
-              messages.forEach((msg) => {
-                const errorCode = typeof msg === "string" && isValidErrorCode(msg) ? msg : ERROR_CODES.BAD_REQUEST;
-                errors.push({
-                  code: errorCode,
-                  message: typeof msg === "string" ? msg : getErrorMessage(errorCode),
-                  severity: ERROR_SEVERITY_MAP[errorCode] || "warning"
-                });
-              });
-            } else if (field === "_graphql") {
-              messages.forEach((msg) => {
-                if (typeof msg === "string") {
-                  const errorCode = isValidErrorCode(msg) ? msg : ERROR_CODES.BAD_REQUEST;
-                  errors.push({
-                    code: errorCode,
-                    message: getErrorMessage(errorCode),
-                    severity: ERROR_SEVERITY_MAP[errorCode] || "warning"
-                  });
-                }
-              });
-            } else {
-              errors.push({
-                code: ERROR_CODES.FIELD_ERROR,
-                message: typeof messages[0] === "string" ? messages[0] : "Validation error",
-                severity: "warning",
-                field
-              });
-            }
-          }
-        });
-      }
+// src/hooks/useSession.ts
+import { useState as useState3, useEffect as useEffect4, useCallback } from "react";
+
+// src/core/SessionManager.ts
+import crudify2 from "@nocios/crudify-browser";
+
+// src/utils/tokenStorage.ts
+import CryptoJS from "crypto-js";
+var _TokenStorage = class _TokenStorage {
+  /**
+   * Configurar tipo de almacenamiento
+   */
+  static setStorageType(type) {
+    _TokenStorage.storageType = type;
+  }
+  /**
+   * Verificar si el storage está disponible
+   */
+  static isStorageAvailable(type) {
+    try {
+      const storage = window[type];
+      const testKey = "__storage_test__";
+      storage.setItem(testKey, "test");
+      storage.removeItem(testKey);
+      return true;
+    } catch {
+      return false;
     }
-    if (errors.length === 0 && apiResponse.success === false) {
-      errors.push({
-        code: ERROR_CODES.BAD_REQUEST,
-        message: "Request failed",
-        severity: "warning"
-      });
+  }
+  /**
+   * Obtener instancia de storage
+   */
+  static getStorage() {
+    if (_TokenStorage.storageType === "none") return null;
+    if (!_TokenStorage.isStorageAvailable(_TokenStorage.storageType)) {
+      console.warn(`Crudify: ${_TokenStorage.storageType} not available, tokens won't persist`);
+      return null;
     }
-  } catch (error) {
-    errors.push({
-      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-      message: "Failed to parse error response",
-      severity: "error",
-      details: { originalError: error }
-    });
+    return window[_TokenStorage.storageType];
   }
-  return errors.length > 0 ? errors : [
-    {
-      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-      message: "Unknown error occurred",
-      severity: "error"
+  /**
+   * Encriptar datos sensibles
+   */
+  static encrypt(data) {
+    try {
+      return CryptoJS.AES.encrypt(data, _TokenStorage.ENCRYPTION_KEY).toString();
+    } catch (error) {
+      console.error("Crudify: Encryption failed", error);
+      return data;
     }
-  ];
-}
-function parseTransactionError(response) {
-  try {
-    const transactionResponse = response;
-    if (transactionResponse.data && Array.isArray(transactionResponse.data)) {
-      const errors = [];
-      transactionResponse.data.forEach((item, index) => {
-        if (item.response?.status === "TOO_MANY_REQUESTS") {
-          errors.push({
-            code: ERROR_CODES.TOO_MANY_REQUESTS,
-            message: getErrorMessage(ERROR_CODES.TOO_MANY_REQUESTS),
-            severity: "warning",
-            details: { transactionIndex: index }
-          });
-        } else if (!item.response || item.response.status !== "OK") {
-          errors.push({
-            code: ERROR_CODES.BAD_REQUEST,
-            message: "Transaction failed",
-            severity: "warning",
-            details: { transactionIndex: index, response: item.response }
-          });
-        }
-      });
-      return errors;
+  }
+  /**
+   * Desencriptar datos
+   */
+  static decrypt(encryptedData) {
+    try {
+      const bytes = CryptoJS.AES.decrypt(encryptedData, _TokenStorage.ENCRYPTION_KEY);
+      const decrypted = bytes.toString(CryptoJS.enc.Utf8);
+      return decrypted || encryptedData;
+    } catch (error) {
+      console.error("Crudify: Decryption failed", error);
+      return encryptedData;
     }
-    return parseApiError(response);
-  } catch (error) {
-    return [
-      {
-        code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-        message: "Failed to parse transaction error",
-        severity: "error",
-        details: { originalError: error }
-      }
-    ];
   }
-}
-function isValidErrorCode(code) {
-  return Object.values(ERROR_CODES).includes(code);
-}
-function getErrorMessage(code) {
-  const messages = {
-    [ERROR_CODES.INVALID_CREDENTIALS]: "Invalid email or password",
-    [ERROR_CODES.UNAUTHORIZED]: "You are not authorized to perform this action",
-    [ERROR_CODES.INVALID_API_KEY]: "Invalid API key",
-    [ERROR_CODES.USER_NOT_FOUND]: "User not found",
-    [ERROR_CODES.USER_NOT_ACTIVE]: "User account is not active",
-    [ERROR_CODES.NO_PERMISSION]: "You do not have permission to perform this action",
-    [ERROR_CODES.ITEM_NOT_FOUND]: "Item not found",
-    [ERROR_CODES.NOT_FOUND]: "Resource not found",
-    [ERROR_CODES.IN_USE]: "Resource is currently in use",
-    [ERROR_CODES.FIELD_ERROR]: "Validation error",
-    [ERROR_CODES.BAD_REQUEST]: "Invalid request",
-    [ERROR_CODES.INVALID_EMAIL]: "Please enter a valid email address",
-    [ERROR_CODES.INVALID_CODE]: "Invalid or expired code",
-    [ERROR_CODES.INTERNAL_SERVER_ERROR]: "Internal server error",
-    [ERROR_CODES.DATABASE_CONNECTION_ERROR]: "Database connection error",
-    [ERROR_CODES.INVALID_CONFIGURATION]: "Invalid configuration",
-    [ERROR_CODES.UNKNOWN_OPERATION]: "Unknown operation",
-    [ERROR_CODES.TOO_MANY_REQUESTS]: "Too many requests. Please try again later.",
-    [ERROR_CODES.NETWORK_ERROR]: "Network error. Please check your connection.",
-    [ERROR_CODES.TIMEOUT_ERROR]: "Request timed out. Please try again."
-  };
-  return messages[code] || "An unknown error occurred";
-}
-function parseJavaScriptError(error) {
-  if (error instanceof Error) {
-    if (error.name === "AbortError") {
-      return {
-        code: ERROR_CODES.TIMEOUT_ERROR,
-        message: "Request was cancelled",
-        severity: "info"
+  /**
+   * Guardar tokens de forma segura
+   */
+  static saveTokens(tokens) {
+    const storage = _TokenStorage.getStorage();
+    if (!storage) return;
+    try {
+      const tokenData = {
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        expiresAt: tokens.expiresAt,
+        refreshExpiresAt: tokens.refreshExpiresAt,
+        savedAt: Date.now()
       };
+      const encrypted = _TokenStorage.encrypt(JSON.stringify(tokenData));
+      storage.setItem(_TokenStorage.TOKEN_KEY, encrypted);
+      console.debug("Crudify: Tokens saved successfully");
+    } catch (error) {
+      console.error("Crudify: Failed to save tokens", error);
     }
-    if (error.message.includes("NetworkError") || error.message.includes("Failed to fetch")) {
+  }
+  /**
+   * Obtener tokens guardados
+   */
+  static getTokens() {
+    const storage = _TokenStorage.getStorage();
+    if (!storage) return null;
+    try {
+      const encrypted = storage.getItem(_TokenStorage.TOKEN_KEY);
+      if (!encrypted) return null;
+      const decrypted = _TokenStorage.decrypt(encrypted);
+      const tokenData = JSON.parse(decrypted);
+      if (!tokenData.accessToken || !tokenData.refreshToken || !tokenData.expiresAt || !tokenData.refreshExpiresAt) {
+        console.warn("Crudify: Incomplete token data found, clearing storage");
+        _TokenStorage.clearTokens();
+        return null;
+      }
+      if (Date.now() >= tokenData.refreshExpiresAt) {
+        console.info("Crudify: Refresh token expired, clearing storage");
+        _TokenStorage.clearTokens();
+        return null;
+      }
       return {
-        code: ERROR_CODES.NETWORK_ERROR,
-        message: getErrorMessage(ERROR_CODES.NETWORK_ERROR),
-        severity: "error"
+        accessToken: tokenData.accessToken,
+        refreshToken: tokenData.refreshToken,
+        expiresAt: tokenData.expiresAt,
+        refreshExpiresAt: tokenData.refreshExpiresAt
       };
+    } catch (error) {
+      console.error("Crudify: Failed to retrieve tokens", error);
+      _TokenStorage.clearTokens();
+      return null;
+    }
+  }
+  /**
+   * Limpiar tokens almacenados
+   */
+  static clearTokens() {
+    const storage = _TokenStorage.getStorage();
+    if (!storage) return;
+    try {
+      storage.removeItem(_TokenStorage.TOKEN_KEY);
+      console.debug("Crudify: Tokens cleared from storage");
+    } catch (error) {
+      console.error("Crudify: Failed to clear tokens", error);
     }
+  }
+  /**
+   * Verificar si hay tokens válidos guardados
+   */
+  static hasValidTokens() {
+    const tokens = _TokenStorage.getTokens();
+    return tokens !== null;
+  }
+  /**
+   * Obtener información de expiración
+   */
+  static getExpirationInfo() {
+    const tokens = _TokenStorage.getTokens();
+    if (!tokens) return null;
+    const now = Date.now();
     return {
-      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-      message: error.message || "An unexpected error occurred",
-      severity: "error",
-      details: { originalError: error }
+      accessExpired: now >= tokens.expiresAt,
+      refreshExpired: now >= tokens.refreshExpiresAt,
+      accessExpiresIn: Math.max(0, tokens.expiresAt - now),
+      refreshExpiresIn: Math.max(0, tokens.refreshExpiresAt - now)
     };
   }
-  return {
-    code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-    message: "An unknown error occurred",
-    severity: "error",
-    details: { originalError: error }
-  };
-}
-function handleCrudifyError(error) {
-  if (error instanceof Error) {
-    return [parseJavaScriptError(error)];
-  }
-  if (typeof error === "object" && error !== null) {
-    const response = error;
-    if (response.data && Array.isArray(response.data)) {
-      return parseTransactionError(error);
+  /**
+   * Actualizar solo el access token (después de refresh)
+   */
+  static updateAccessToken(newAccessToken, newExpiresAt) {
+    const existingTokens = _TokenStorage.getTokens();
+    if (!existingTokens) {
+      console.warn("Crudify: Cannot update access token, no existing tokens found");
+      return;
     }
-    return parseApiError(error);
+    _TokenStorage.saveTokens({
+      ...existingTokens,
+      accessToken: newAccessToken,
+      expiresAt: newExpiresAt
+    });
   }
-  return [
-    {
-      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-      message: "An unknown error occurred",
-      severity: "error",
-      details: { originalError: error }
-    }
-  ];
-}
+};
+_TokenStorage.TOKEN_KEY = "crudify_tokens";
+_TokenStorage.ENCRYPTION_KEY = "crudify_secure_key_v1";
+_TokenStorage.storageType = "localStorage";
+var TokenStorage = _TokenStorage;
 
-// src/components/CrudifyLogin/Forms/LoginForm.tsx
-import { Fragment, jsx as jsx4, jsxs } from "react/jsx-runtime";
-var LoginForm = ({ onScreenChange, onExternalNavigate, onLoginSuccess, onError, redirectUrl = "/" }) => {
-  const { crudify: crudify6 } = useCrudify();
-  const { state, updateFormData, setFieldError, clearErrors, setLoading } = useLoginState();
-  const { t } = useTranslation();
-  const usernameInputRef = useRef(null);
-  const getRedirectUrl = () => {
-    if (state.searchParams.redirect) {
-      try {
-        const decodedPath = decodeURIComponent(state.searchParams.redirect);
-        if (decodedPath.startsWith("/") && !decodedPath.startsWith("//")) {
-          return decodedPath;
-        }
-      } catch (error) {
-      }
-    }
-    return redirectUrl || "/";
-  };
-  useEffect4(() => {
-    const timer = setTimeout(() => {
-      if (usernameInputRef.current) usernameInputRef.current.focus();
-    }, 100);
-    return () => clearTimeout(timer);
-  }, []);
-  const translateError = (parsedError) => {
-    const possibleKeys = [
-      `errors.auth.${parsedError.code}`,
-      `errors.data.${parsedError.code}`,
-      `errors.system.${parsedError.code}`,
-      `errors.${parsedError.code}`,
-      `login.${parsedError.code.toLowerCase()}`
-    ];
-    for (const key of possibleKeys) {
-      const translated = t(key);
-      if (translated !== key) {
-        return translated;
-      }
+// src/core/SessionManager.ts
+var SessionManager = class _SessionManager {
+  constructor() {
+    this.config = {};
+    this.initialized = false;
+  }
+  static getInstance() {
+    if (!_SessionManager.instance) {
+      _SessionManager.instance = new _SessionManager();
     }
-    return parsedError.message || t("error.unknown");
-  };
-  const handleLogin = async () => {
-    if (state.loading) return;
-    if (!state.formData.username.trim()) {
-      setFieldError("username", t("login.usernameRequired"));
+    return _SessionManager.instance;
+  }
+  /**
+   * Inicializar el SessionManager
+   */
+  async initialize(config = {}) {
+    if (this.initialized) {
+      console.warn("SessionManager: Already initialized");
       return;
     }
-    if (!state.formData.password.trim()) {
-      setFieldError("password", t("login.passwordRequired"));
-      return;
+    this.config = {
+      storageType: "localStorage",
+      autoRestore: true,
+      enableLogging: false,
+      ...config
+    };
+    TokenStorage.setStorageType(this.config.storageType || "localStorage");
+    if (this.config.enableLogging) {
     }
-    clearErrors();
-    setLoading(true);
+    if (this.config.autoRestore) {
+      await this.restoreSession();
+    }
+    this.initialized = true;
+    this.log("SessionManager initialized successfully");
+  }
+  /**
+   * Login con persistencia automática
+   */
+  async login(email, password) {
     try {
-      if (!crudify6) {
-        throw new Error("Crudify not initialized");
-      }
-      const response = await crudify6.login(state.formData.username, state.formData.password);
-      setLoading(false);
-      if (response.success) {
-        console.log("\u{1F510} LoginForm - Login successful, calling onLoginSuccess");
-        const finalRedirectUrl = getRedirectUrl();
-        if (onLoginSuccess) {
-          onLoginSuccess(response.data, finalRedirectUrl);
-        }
-      } else {
-        handleLoginError(response);
+      this.log("Attempting login...");
+      const response = await crudify2.login(email, password);
+      if (!response.success) {
+        this.log("Login failed:", response.errors);
+        return {
+          success: false,
+          error: this.formatError(response.errors)
+        };
       }
+      const tokens = {
+        accessToken: response.data.token,
+        refreshToken: response.data.refreshToken,
+        expiresAt: response.data.expiresAt,
+        refreshExpiresAt: response.data.refreshExpiresAt
+      };
+      TokenStorage.saveTokens(tokens);
+      this.log("Login successful, tokens saved");
+      this.config.onLoginSuccess?.(tokens);
+      return {
+        success: true,
+        tokens
+      };
     } catch (error) {
-      setLoading(false);
-      const parsedErrors = handleCrudifyError(error);
-      const translatedErrors = parsedErrors.map(translateError);
-      setFieldError("global", translatedErrors);
-      if (onError) {
-        onError(translatedErrors.join(", "));
-      }
-    }
-  };
-  const handleLoginError = (response) => {
-    const parsedErrors = handleCrudifyError(response);
-    parsedErrors.forEach((error) => {
-      if (error.field) {
-        setFieldError(error.field, translateError(error));
-      } else {
-        const currentGlobalErrors = state.errors.global || [];
-        setFieldError("global", [...currentGlobalErrors, translateError(error)]);
-      }
-    });
-  };
-  const handleSubmit = (e) => {
-    e.preventDefault();
-    handleLogin();
-  };
-  const handleKeyDown = (e) => {
-    if (e.key === "Enter" && !state.loading) {
-      e.preventDefault();
-      handleLogin();
-    }
-  };
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsxs(
-      Box,
-      {
-        component: "form",
-        noValidate: true,
-        onSubmit: handleSubmit,
-        onKeyDown: handleKeyDown,
-        sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2 },
-        children: [
-          /* @__PURE__ */ jsxs(Box, { sx: { mb: 1 }, children: [
-            /* @__PURE__ */ jsx4(
-              Typography,
-              {
-                variant: "body2",
-                component: "label",
-                htmlFor: "email",
-                sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
-                children: t("login.usernameOrEmailLabel")
-              }
-            ),
-            /* @__PURE__ */ jsx4(
-              TextField,
-              {
-                fullWidth: true,
-                id: "email",
-                name: "email",
-                type: "email",
-                value: state.formData.username,
-                disabled: state.loading,
-                onChange: (e) => updateFormData({ username: e.target.value }),
-                error: !!state.errors.username,
-                helperText: state.errors.username,
-                autoComplete: "email",
-                placeholder: t("login.usernameOrEmailPlaceholder"),
-                inputRef: usernameInputRef,
-                required: true
-              }
-            )
-          ] }),
-          /* @__PURE__ */ jsxs(Box, { sx: { mb: 1 }, children: [
-            /* @__PURE__ */ jsx4(
-              Typography,
-              {
-                variant: "body2",
-                component: "label",
-                htmlFor: "password",
-                sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
-                children: t("login.passwordLabel")
-              }
-            ),
-            /* @__PURE__ */ jsx4(
-              TextField,
-              {
-                fullWidth: true,
-                id: "password",
-                name: "password",
-                type: "password",
-                value: state.formData.password,
-                disabled: state.loading,
-                onChange: (e) => updateFormData({ password: e.target.value }),
-                error: !!state.errors.password,
-                helperText: state.errors.password,
-                autoComplete: "current-password",
-                placeholder: t("login.passwordPlaceholder"),
-                required: true
-              }
-            )
-          ] }),
-          state.config.loginActions?.includes("forgotPassword") && /* @__PURE__ */ jsx4(Box, { sx: { display: "flex", justifyContent: "flex-end", alignItems: "center" }, children: /* @__PURE__ */ jsx4(
-            Link,
-            {
-              sx: { cursor: "pointer" },
-              onClick: () => {
-                onScreenChange?.("forgotPassword", state.searchParams);
-              },
-              variant: "body2",
-              color: "secondary",
-              children: t("login.forgotPasswordLink")
-            }
-          ) }),
-          /* @__PURE__ */ jsx4(Button, { disabled: state.loading, type: "submit", fullWidth: true, variant: "contained", color: "primary", sx: { mt: 1, mb: 2 }, children: state.loading ? /* @__PURE__ */ jsx4(CircularProgress, { size: 20 }) : t("login.loginButton") })
-        ]
-      }
-    ),
-    /* @__PURE__ */ jsx4(Box, { children: state.errors.global && state.errors.global.length > 0 && state.errors.global.map((error, index) => /* @__PURE__ */ jsx4(Alert, { variant: "filled", sx: { mt: 2 }, severity: "error", children: /* @__PURE__ */ jsx4("div", { children: error }) }, index)) }),
-    state.config.loginActions?.includes("createUser") && /* @__PURE__ */ jsxs(Typography, { variant: "body2", align: "center", sx: { color: "text.secondary", mt: 3 }, children: [
-      t("login.noAccountPrompt"),
-      " ",
-      /* @__PURE__ */ jsx4(
-        Link,
-        {
-          sx: { cursor: "pointer" },
-          onClick: () => {
-            const searchString = Object.keys(state.searchParams).length > 0 ? `?${new URLSearchParams(state.searchParams).toString()}` : "";
-            const signupUrl = `/public/users/create${searchString}`;
-            onExternalNavigate?.(signupUrl);
-          },
-          fontWeight: "medium",
-          color: "secondary",
-          children: t("login.signUpLink")
-        }
-      )
-    ] })
-  ] });
-};
-var LoginForm_default = LoginForm;
-
-// src/components/CrudifyLogin/Forms/ForgotPasswordForm.tsx
-import { useState as useState3 } from "react";
-import { Typography as Typography2, TextField as TextField2, Button as Button2, Box as Box2, CircularProgress as CircularProgress2, Alert as Alert2, Link as Link2 } from "@mui/material";
-import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
-var ForgotPasswordForm = ({ onScreenChange, onError }) => {
-  const { crudify: crudify6 } = useCrudify();
-  const [email, setEmail] = useState3("");
-  const [loading, setLoading] = useState3(false);
-  const [errors, setErrors] = useState3([]);
-  const [helperTextEmail, setHelperTextEmail] = useState3(null);
-  const [emailSent, setEmailSent] = useState3(false);
-  const [codeAlreadyExists, setCodeAlreadyExists] = useState3(false);
-  const { t } = useTranslation();
-  const translateError = (parsedError) => {
-    const possibleKeys = [
-      `errors.auth.${parsedError.code}`,
-      `errors.data.${parsedError.code}`,
-      `errors.system.${parsedError.code}`,
-      `errors.${parsedError.code}`,
-      `forgotPassword.${parsedError.code.toLowerCase()}`
-    ];
-    for (const key of possibleKeys) {
-      const translated = t(key);
-      if (translated !== key) {
-        return translated;
-      }
-    }
-    return parsedError.message || t("error.unknown");
-  };
-  const validateEmail = (email2) => {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return emailRegex.test(email2);
-  };
-  const handleSubmit = async () => {
-    if (loading || !crudify6) return;
-    setErrors([]);
-    setHelperTextEmail(null);
-    if (!email) {
-      setHelperTextEmail(t("forgotPassword.emailRequired"));
-      return;
+      this.log("Login error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
     }
-    if (!validateEmail(email)) {
-      setHelperTextEmail(t("forgotPassword.invalidEmail"));
-      return;
+  }
+  /**
+   * Logout con limpieza de tokens
+   */
+  async logout() {
+    try {
+      this.log("Logging out...");
+      await crudify2.logout();
+      TokenStorage.clearTokens();
+      this.log("Logout successful");
+      this.config.onLogout?.();
+    } catch (error) {
+      this.log("Logout error:", error);
+      TokenStorage.clearTokens();
     }
-    setLoading(true);
+  }
+  /**
+   * Restaurar sesión desde storage
+   */
+  async restoreSession() {
     try {
-      const data = [{ operation: "requestPasswordReset", data: { email } }];
-      const response = await crudify6.transaction(data);
-      if (response.success) {
-        if (response.data && response.data.existingCodeValid) {
-          setCodeAlreadyExists(true);
-        } else {
-          setEmailSent(true);
+      this.log("Attempting to restore session...");
+      const savedTokens = TokenStorage.getTokens();
+      if (!savedTokens) {
+        this.log("No valid tokens found in storage");
+        return false;
+      }
+      crudify2.setTokens({
+        accessToken: savedTokens.accessToken,
+        refreshToken: savedTokens.refreshToken,
+        expiresAt: savedTokens.expiresAt,
+        refreshExpiresAt: savedTokens.refreshExpiresAt
+      });
+      try {
+        const isValid = crudify2.isLogin();
+        if (!isValid) {
+          this.log("Restored tokens are invalid, clearing storage");
+          TokenStorage.clearTokens();
+          return false;
         }
-      } else {
-        const parsedErrors = handleCrudifyError(response);
-        const translatedErrors = parsedErrors.map(translateError);
-        setErrors(translatedErrors);
+      } catch (validationError) {
+        this.log("Token validation failed:", validationError);
+        TokenStorage.clearTokens();
+        return false;
       }
+      this.log("Session restored successfully");
+      this.config.onSessionRestored?.(savedTokens);
+      return true;
     } catch (error) {
-      const parsedErrors = handleCrudifyError(error);
-      const translatedErrors = parsedErrors.map(translateError);
-      setErrors(translatedErrors);
-      if (onError) {
-        onError(translatedErrors.join(", "));
-      }
-    } finally {
-      setLoading(false);
-    }
-  };
-  const handleBack = () => {
-    onScreenChange?.("login");
-  };
-  const handleGoToCheckCode = () => {
-    if (emailSent || codeAlreadyExists) {
-      onScreenChange?.("checkCode", { email });
-      return;
-    }
-    if (!email) {
-      setHelperTextEmail(t("forgotPassword.emailRequired"));
-      return;
+      this.log("Session restore error:", error);
+      TokenStorage.clearTokens();
+      return false;
     }
-    if (!validateEmail(email)) {
-      setHelperTextEmail(t("forgotPassword.invalidEmail"));
-      return;
-    }
-    onScreenChange?.("checkCode", { email });
-  };
-  if (emailSent || codeAlreadyExists) {
-    return /* @__PURE__ */ jsx5(Fragment2, { children: /* @__PURE__ */ jsxs2(Box2, { sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2, textAlign: "center" }, children: [
-      /* @__PURE__ */ jsxs2(Box2, { sx: { mb: 2 }, children: [
-        /* @__PURE__ */ jsx5(Typography2, { variant: "h5", component: "h1", sx: { mb: 1, fontWeight: 600 }, children: codeAlreadyExists ? t("forgotPassword.codeAlreadyExistsMessage") : t("forgotPassword.emailSentMessage") }),
-        /* @__PURE__ */ jsx5(Typography2, { variant: "body2", sx: { color: codeAlreadyExists ? "success.main" : "grey.600" }, children: codeAlreadyExists ? t("forgotPassword.checkEmailInstructions") : t("forgotPassword.checkEmailInstructions") })
-      ] }),
-      /* @__PURE__ */ jsx5(Button2, { type: "button", onClick: handleGoToCheckCode, fullWidth: true, variant: "contained", color: "primary", sx: { mt: 2, mb: 2 }, children: t("forgotPassword.enterCodeLink") }),
-      /* @__PURE__ */ jsx5(Box2, { sx: { display: "flex", justifyContent: "center", alignItems: "center" }, children: /* @__PURE__ */ jsx5(Link2, { sx: { cursor: "pointer" }, onClick: handleBack, variant: "body2", color: "secondary", children: t("common.back") }) })
-    ] }) });
   }
-  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
-    /* @__PURE__ */ jsxs2(Box2, { component: "form", noValidate: true, sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2 }, children: [
-      /* @__PURE__ */ jsxs2(Box2, { sx: { mb: 2 }, children: [
-        /* @__PURE__ */ jsx5(Typography2, { variant: "h5", component: "h1", sx: { mb: 1, fontWeight: 600 }, children: t("forgotPassword.title") }),
-        /* @__PURE__ */ jsx5(Typography2, { variant: "body2", sx: { color: "grey.600" }, children: t("forgotPassword.instructions") })
-      ] }),
-      /* @__PURE__ */ jsxs2(Box2, { sx: { mb: 1 }, children: [
-        /* @__PURE__ */ jsx5(
-          Typography2,
-          {
-            variant: "body2",
-            component: "label",
-            htmlFor: "email",
-            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
-            children: t("forgotPassword.emailLabel")
-          }
-        ),
-        /* @__PURE__ */ jsx5(
-          TextField2,
-          {
-            fullWidth: true,
-            id: "email",
-            name: "email",
-            type: "email",
-            value: email,
-            disabled: loading,
-            onChange: (e) => setEmail(e.target.value),
-            error: !!helperTextEmail,
-            helperText: helperTextEmail,
-            autoComplete: "email",
-            placeholder: t("forgotPassword.emailPlaceholder"),
-            required: true
-          }
-        )
-      ] }),
-      /* @__PURE__ */ jsx5(Button2, { disabled: loading, type: "button", onClick: handleSubmit, fullWidth: true, variant: "contained", color: "primary", sx: { mt: 2, mb: 2 }, children: loading ? /* @__PURE__ */ jsx5(CircularProgress2, { size: 20 }) : t("forgotPassword.sendCodeButton") }),
-      /* @__PURE__ */ jsxs2(Box2, { sx: { display: "flex", justifyContent: "center", alignItems: "center", gap: 2 }, children: [
-        /* @__PURE__ */ jsx5(Link2, { sx: { cursor: "pointer" }, onClick: handleBack, variant: "body2", color: "secondary", children: t("common.back") }),
-        /* @__PURE__ */ jsx5(Typography2, { variant: "body2", sx: { color: "grey.400" }, children: "\u2022" }),
-        /* @__PURE__ */ jsx5(Link2, { sx: { cursor: "pointer" }, onClick: handleGoToCheckCode, variant: "body2", color: "secondary", children: t("login.alreadyHaveCodeLink") })
-      ] })
-    ] }),
-    /* @__PURE__ */ jsx5(Box2, { children: errors.length > 0 && errors.map((error, index) => /* @__PURE__ */ jsx5(Alert2, { variant: "filled", sx: { mt: 2 }, severity: "error", children: error }, index)) })
-  ] });
-};
-var ForgotPasswordForm_default = ForgotPasswordForm;
-
-// src/components/CrudifyLogin/Forms/ResetPasswordForm.tsx
-import { useState as useState4, useEffect as useEffect5 } from "react";
-import { Typography as Typography3, TextField as TextField3, Button as Button3, Box as Box3, CircularProgress as CircularProgress3, Alert as Alert3, Link as Link3 } from "@mui/material";
-import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
-var ResetPasswordForm = ({ onScreenChange, onError, searchParams, onResetSuccess }) => {
-  const { crudify: crudify6 } = useCrudify();
-  const [newPassword, setNewPassword] = useState4("");
-  const [confirmPassword, setConfirmPassword] = useState4("");
-  const [loading, setLoading] = useState4(false);
-  const [errors, setErrors] = useState4([]);
-  const [helperTextNewPassword, setHelperTextNewPassword] = useState4(null);
-  const [helperTextConfirmPassword, setHelperTextConfirmPassword] = useState4(null);
-  const [email, setEmail] = useState4("");
-  const [code, setCode] = useState4("");
-  const [fromCodeVerification, setFromCodeVerification] = useState4(false);
-  const [validatingCode, setValidatingCode] = useState4(true);
-  const [codeValidated, setCodeValidated] = useState4(false);
-  const [pendingValidation, setPendingValidation] = useState4(null);
-  const [isValidating, setIsValidating] = useState4(false);
-  const { t } = useTranslation();
-  const translateError = (parsedError) => {
-    const possibleKeys = [
-      `errors.auth.${parsedError.code}`,
-      `errors.data.${parsedError.code}`,
-      `errors.system.${parsedError.code}`,
-      `errors.${parsedError.code}`,
-      `resetPassword.${parsedError.code.toLowerCase()}`
-    ];
-    for (const key of possibleKeys) {
-      const translated = t(key);
-      if (translated !== key) {
-        return translated;
+  /**
+   * Verificar si el usuario está autenticado
+   */
+  isAuthenticated() {
+    return crudify2.isLogin() || TokenStorage.hasValidTokens();
+  }
+  /**
+   * Obtener información de tokens actuales
+   */
+  getTokenInfo() {
+    const crudifyTokens = crudify2.getTokenData();
+    const storageInfo = TokenStorage.getExpirationInfo();
+    return {
+      isLoggedIn: this.isAuthenticated(),
+      crudifyTokens,
+      storageInfo,
+      hasValidTokens: TokenStorage.hasValidTokens()
+    };
+  }
+  /**
+   * Refrescar tokens manualmente
+   */
+  async refreshTokens() {
+    try {
+      this.log("Manually refreshing tokens...");
+      const response = await crudify2.refreshAccessToken();
+      if (!response.success) {
+        this.log("Token refresh failed:", response.errors);
+        TokenStorage.clearTokens();
+        this.config.onSessionExpired?.();
+        return false;
       }
+      const newTokens = {
+        accessToken: response.data.token,
+        refreshToken: response.data.refreshToken,
+        expiresAt: response.data.expiresAt,
+        refreshExpiresAt: response.data.refreshExpiresAt
+      };
+      TokenStorage.saveTokens(newTokens);
+      this.log("Tokens refreshed and saved successfully");
+      return true;
+    } catch (error) {
+      this.log("Token refresh error:", error);
+      TokenStorage.clearTokens();
+      this.config.onSessionExpired?.();
+      return false;
     }
-    return parsedError.message || t("error.unknown");
-  };
-  const getParam = (key) => {
-    if (!searchParams) return null;
-    if (searchParams instanceof URLSearchParams) {
-      return searchParams.get(key);
-    }
-    return searchParams[key] || null;
-  };
-  useEffect5(() => {
-    if (!searchParams) {
-      return;
-    }
-    if (searchParams) {
-      const fromCodeVerificationParam = getParam("fromCodeVerification");
-      const emailParam = getParam("email");
-      const codeParam = getParam("code");
-      if (fromCodeVerificationParam === "true" && emailParam && codeParam) {
-        setEmail(emailParam);
-        setCode(codeParam);
-        setFromCodeVerification(true);
-        setCodeValidated(true);
-        setValidatingCode(false);
-        return;
-      }
-      const linkParam = getParam("link");
-      if (linkParam) {
-        try {
-          const decodedLink = decodeURIComponent(linkParam);
-          const [linkCode, linkEmail] = decodedLink.split("/");
-          if (linkCode && linkEmail && linkCode.length === 6) {
-            setCode(linkCode);
-            setEmail(linkEmail);
-            setFromCodeVerification(false);
-            setPendingValidation({ email: linkEmail, code: linkCode });
-            return;
+  }
+  /**
+   * Configurar interceptor de respuesta para manejo automático de errores
+   */
+  setupResponseInterceptor() {
+    crudify2.setResponseInterceptor(async (response) => {
+      if (response.errors) {
+        const hasAuthError = response.errors.some(
+          (error) => error.message?.includes("Unauthorized") || error.message?.includes("Token") || error.extensions?.code === "UNAUTHENTICATED"
+        );
+        if (hasAuthError && TokenStorage.hasValidTokens()) {
+          this.log("Auth error detected, attempting token refresh...");
+          const refreshSuccess = await this.refreshTokens();
+          if (!refreshSuccess) {
+            this.log("Session expired, triggering callback");
+            this.config.onSessionExpired?.();
           }
-        } catch (error) {
         }
       }
-      if (emailParam && codeParam) {
-        setEmail(emailParam);
-        setCode(codeParam);
-        setFromCodeVerification(false);
-        setPendingValidation({ email: emailParam, code: codeParam });
-        return;
-      }
-    }
-    setErrors([t("resetPassword.invalidCode")]);
-    setValidatingCode(false);
-    setTimeout(() => onScreenChange?.("forgotPassword"), 3e3);
-  }, [searchParams, crudify6, t, onScreenChange]);
-  useEffect5(() => {
-    if (crudify6 && pendingValidation && !isValidating) {
-      setIsValidating(true);
-      const validateCode = async (emailToValidate, codeToValidate) => {
-        try {
-          const data = [
-            {
-              operation: "validatePasswordResetCode",
-              data: { email: emailToValidate, codePassword: codeToValidate }
-            }
-          ];
-          const response = await crudify6.transaction(data);
-          if (response.data && Array.isArray(response.data)) {
-            const validationResult = response.data[0];
-            if (validationResult && validationResult.response && validationResult.response.status === "OK") {
-              setCodeValidated(true);
-              return;
-            }
-          }
-          if (response.success) {
-            setCodeValidated(true);
-          } else {
-            const parsedErrors = handleCrudifyError(response);
-            const translatedErrors = parsedErrors.map(translateError);
-            setErrors(translatedErrors);
-            setTimeout(() => onScreenChange?.("forgotPassword"), 3e3);
-          }
-        } catch (error) {
-          const parsedErrors = handleCrudifyError(error);
-          const translatedErrors = parsedErrors.map(translateError);
-          setErrors(translatedErrors);
-          setTimeout(() => onScreenChange?.("forgotPassword"), 3e3);
-        } finally {
-          setValidatingCode(false);
-          setPendingValidation(null);
-          setIsValidating(false);
-        }
-      };
-      validateCode(pendingValidation.email, pendingValidation.code);
-    }
-  }, [crudify6, pendingValidation, t, onScreenChange]);
-  const validatePassword = (password) => {
-    if (password.length < 8) {
-      return t("resetPassword.passwordTooShort");
+      return response;
+    });
+    this.log("Response interceptor configured");
+  }
+  /**
+   * Limpiar sesión completamente
+   */
+  clearSession() {
+    TokenStorage.clearTokens();
+    crudify2.logout();
+    this.log("Session cleared completely");
+  }
+  // Métodos privados
+  log(message, ...args) {
+    if (this.config.enableLogging) {
+      console.log(`[SessionManager] ${message}`, ...args);
     }
-    return null;
-  };
-  const handleSubmit = async () => {
-    if (loading || !crudify6) return;
-    setErrors([]);
-    setHelperTextNewPassword(null);
-    setHelperTextConfirmPassword(null);
-    let hasErrors = false;
-    if (!newPassword) {
-      setHelperTextNewPassword(t("resetPassword.newPasswordRequired"));
-      hasErrors = true;
-    } else {
-      const passwordError = validatePassword(newPassword);
-      if (passwordError) {
-        setHelperTextNewPassword(passwordError);
-        hasErrors = true;
-      }
+  }
+  formatError(errors) {
+    if (!errors) return "Unknown error";
+    if (typeof errors === "string") return errors;
+    if (typeof errors === "object") {
+      const errorMessages = Object.values(errors).flat();
+      return errorMessages.join(", ");
     }
-    if (!confirmPassword) {
-      setHelperTextConfirmPassword(t("resetPassword.confirmPasswordRequired"));
-      hasErrors = true;
-    } else if (newPassword !== confirmPassword) {
-      setHelperTextConfirmPassword(t("resetPassword.passwordsDoNotMatch"));
-      hasErrors = true;
-    }
-    if (hasErrors) return;
-    setLoading(true);
+    return "Authentication failed";
+  }
+};
+
+// src/hooks/useSession.ts
+function useSession(options = {}) {
+  const [state, setState] = useState3({
+    isAuthenticated: false,
+    isLoading: true,
+    isInitialized: false,
+    tokens: null,
+    error: null
+  });
+  const sessionManager = SessionManager.getInstance();
+  const initialize = useCallback(async () => {
     try {
-      const data = [
-        {
-          operation: "validateAndResetPassword",
-          data: { email, codePassword: code, newPassword }
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+      const config = {
+        autoRestore: options.autoRestore ?? true,
+        enableLogging: options.enableLogging ?? false,
+        onSessionExpired: () => {
+          setState((prev) => ({
+            ...prev,
+            isAuthenticated: false,
+            tokens: null,
+            error: "Session expired"
+          }));
+          options.onSessionExpired?.();
+        },
+        onSessionRestored: (tokens) => {
+          setState((prev) => ({
+            ...prev,
+            isAuthenticated: true,
+            tokens,
+            error: null
+          }));
+          options.onSessionRestored?.(tokens);
+        },
+        onLoginSuccess: (tokens) => {
+          setState((prev) => ({
+            ...prev,
+            isAuthenticated: true,
+            tokens,
+            error: null
+          }));
+        },
+        onLogout: () => {
+          setState((prev) => ({
+            ...prev,
+            isAuthenticated: false,
+            tokens: null,
+            error: null
+          }));
         }
-      ];
-      const response = await crudify6.transaction(data);
-      if (response.success) {
-        setErrors([]);
-        setTimeout(() => {
-          onResetSuccess?.();
-        }, 1e3);
+      };
+      await sessionManager.initialize(config);
+      sessionManager.setupResponseInterceptor();
+      const isAuth = sessionManager.isAuthenticated();
+      const tokenInfo = sessionManager.getTokenInfo();
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: isAuth,
+        isInitialized: true,
+        isLoading: false,
+        tokens: tokenInfo.crudifyTokens.accessToken ? {
+          accessToken: tokenInfo.crudifyTokens.accessToken,
+          refreshToken: tokenInfo.crudifyTokens.refreshToken,
+          expiresAt: tokenInfo.crudifyTokens.expiresAt,
+          refreshExpiresAt: tokenInfo.crudifyTokens.refreshExpiresAt
+        } : null
+      }));
+    } catch (error) {
+      setState((prev) => ({
+        ...prev,
+        isLoading: false,
+        isInitialized: true,
+        error: error instanceof Error ? error.message : "Initialization failed"
+      }));
+    }
+  }, [options.autoRestore, options.enableLogging, options.onSessionExpired, options.onSessionRestored]);
+  const login = useCallback(async (email, password) => {
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    try {
+      const result = await sessionManager.login(email, password);
+      if (result.success && result.tokens) {
+        setState((prev) => ({
+          ...prev,
+          isAuthenticated: true,
+          tokens: result.tokens,
+          isLoading: false,
+          error: null
+        }));
       } else {
-        const parsedErrors = handleCrudifyError(response);
-        const translatedErrors = parsedErrors.map(translateError);
-        setErrors(translatedErrors);
+        setState((prev) => ({
+          ...prev,
+          isAuthenticated: false,
+          tokens: null,
+          isLoading: false,
+          error: result.error || "Login failed"
+        }));
       }
+      return result;
     } catch (error) {
-      const parsedErrors = handleCrudifyError(error);
-      const translatedErrors = parsedErrors.map(translateError);
-      setErrors(translatedErrors);
-      if (onError) {
-        onError(translatedErrors.join(", "));
+      const errorMsg = error instanceof Error ? error.message : "Login failed";
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: false,
+        tokens: null,
+        isLoading: false,
+        error: errorMsg
+      }));
+      return {
+        success: false,
+        error: errorMsg
+      };
+    }
+  }, [sessionManager]);
+  const logout = useCallback(async () => {
+    setState((prev) => ({ ...prev, isLoading: true }));
+    try {
+      await sessionManager.logout();
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: false,
+        tokens: null,
+        isLoading: false,
+        error: null
+      }));
+    } catch (error) {
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: false,
+        tokens: null,
+        isLoading: false,
+        error: error instanceof Error ? error.message : "Logout error"
+      }));
+    }
+  }, [sessionManager]);
+  const refreshTokens = useCallback(async () => {
+    try {
+      const success = await sessionManager.refreshTokens();
+      if (success) {
+        const tokenInfo = sessionManager.getTokenInfo();
+        setState((prev) => ({
+          ...prev,
+          tokens: tokenInfo.crudifyTokens.accessToken ? {
+            accessToken: tokenInfo.crudifyTokens.accessToken,
+            refreshToken: tokenInfo.crudifyTokens.refreshToken,
+            expiresAt: tokenInfo.crudifyTokens.expiresAt,
+            refreshExpiresAt: tokenInfo.crudifyTokens.refreshExpiresAt
+          } : null,
+          error: null
+        }));
+      } else {
+        setState((prev) => ({
+          ...prev,
+          isAuthenticated: false,
+          tokens: null,
+          error: "Token refresh failed"
+        }));
       }
+      return success;
+    } catch (error) {
+      setState((prev) => ({
+        ...prev,
+        isAuthenticated: false,
+        tokens: null,
+        error: error instanceof Error ? error.message : "Token refresh failed"
+      }));
+      return false;
     }
-    setLoading(false);
+  }, [sessionManager]);
+  const clearError = useCallback(() => {
+    setState((prev) => ({ ...prev, error: null }));
+  }, []);
+  const getTokenInfo = useCallback(() => {
+    return sessionManager.getTokenInfo();
+  }, [sessionManager]);
+  useEffect4(() => {
+    initialize();
+  }, [initialize]);
+  return {
+    // Estado
+    ...state,
+    // Acciones
+    login,
+    logout,
+    refreshTokens,
+    clearError,
+    getTokenInfo,
+    // Utilidades
+    isExpiringSoon: state.tokens ? state.tokens.expiresAt - Date.now() < 5 * 60 * 1e3 : false,
+    // 5 minutos
+    expiresIn: state.tokens ? Math.max(0, state.tokens.expiresAt - Date.now()) : 0,
+    refreshExpiresIn: state.tokens ? Math.max(0, state.tokens.refreshExpiresAt - Date.now()) : 0
   };
-  const handleBack = () => {
-    if (fromCodeVerification) {
-      onScreenChange?.("checkCode", { email });
-    } else {
-      onScreenChange?.("forgotPassword");
+}
+
+// src/utils/jwtUtils.ts
+var decodeJwtSafely = (token) => {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      console.warn("Invalid JWT format: token must have 3 parts");
+      return null;
     }
-  };
-  if (validatingCode) {
-    return /* @__PURE__ */ jsx6(Box3, { sx: { display: "flex", justifyContent: "center", alignItems: "center", minHeight: "300px" }, children: /* @__PURE__ */ jsx6(CircularProgress3, {}) });
-  }
-  if (!codeValidated) {
-    return /* @__PURE__ */ jsx6(Box3, { children: errors.length > 0 && errors.map((error, index) => /* @__PURE__ */ jsx6(Alert3, { variant: "filled", sx: { mt: 2 }, severity: "error", children: error }, index)) });
+    const payload = parts[1];
+    const paddedPayload = payload + "=".repeat((4 - payload.length % 4) % 4);
+    const decodedPayload = JSON.parse(atob(paddedPayload));
+    return decodedPayload;
+  } catch (error) {
+    console.warn("Failed to decode JWT token:", error);
+    return null;
+  }
+};
+var getCurrentUserEmail = () => {
+  try {
+    let token = null;
+    token = sessionStorage.getItem("authToken");
+    console.log("\u{1F50D} getCurrentUserEmail - authToken:", token ? `${token.substring(0, 20)}...` : null);
+    if (!token) {
+      token = sessionStorage.getItem("token");
+      console.log("\u{1F50D} getCurrentUserEmail - token:", token ? `${token.substring(0, 20)}...` : null);
+    }
+    if (!token) {
+      token = localStorage.getItem("authToken") || localStorage.getItem("token");
+      console.log("\u{1F50D} getCurrentUserEmail - localStorage:", token ? `${token.substring(0, 20)}...` : null);
+    }
+    if (!token) {
+      console.warn("\u{1F50D} getCurrentUserEmail - No token found in any storage");
+      return null;
+    }
+    const payload = decodeJwtSafely(token);
+    if (!payload) {
+      console.warn("\u{1F50D} getCurrentUserEmail - Failed to decode token");
+      return null;
+    }
+    const email = payload.email || payload["cognito:username"] || null;
+    console.log("\u{1F50D} getCurrentUserEmail - Extracted email:", email);
+    return email;
+  } catch (error) {
+    console.warn("Failed to get current user email:", error);
+    return null;
+  }
+};
+var isTokenExpired = (token) => {
+  try {
+    const payload = decodeJwtSafely(token);
+    if (!payload || !payload.exp) return true;
+    const currentTime = Math.floor(Date.now() / 1e3);
+    return payload.exp < currentTime;
+  } catch {
+    return true;
   }
-  return /* @__PURE__ */ jsxs3(Fragment3, { children: [
-    /* @__PURE__ */ jsxs3(Box3, { component: "form", noValidate: true, sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2 }, children: [
-      /* @__PURE__ */ jsxs3(Box3, { sx: { mb: 2 }, children: [
-        /* @__PURE__ */ jsx6(Typography3, { variant: "h5", component: "h1", sx: { mb: 1, fontWeight: 600 }, children: t("resetPassword.title") }),
-        /* @__PURE__ */ jsx6(Typography3, { variant: "body2", sx: { color: "grey.600" }, children: t("resetPassword.instructions") })
-      ] }),
-      /* @__PURE__ */ jsxs3(Box3, { sx: { mb: 1 }, children: [
-        /* @__PURE__ */ jsx6(
-          Typography3,
-          {
-            variant: "body2",
-            component: "label",
-            htmlFor: "newPassword",
-            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
-            children: t("resetPassword.newPasswordLabel")
-          }
-        ),
-        /* @__PURE__ */ jsx6(
-          TextField3,
-          {
-            fullWidth: true,
-            id: "newPassword",
-            name: "newPassword",
-            type: "password",
-            value: newPassword,
-            disabled: loading,
-            onChange: (e) => setNewPassword(e.target.value),
-            error: !!helperTextNewPassword,
-            helperText: helperTextNewPassword,
-            autoComplete: "new-password",
-            placeholder: t("resetPassword.newPasswordPlaceholder"),
-            required: true
-          }
-        )
-      ] }),
-      /* @__PURE__ */ jsxs3(Box3, { sx: { mb: 1 }, children: [
-        /* @__PURE__ */ jsx6(
-          Typography3,
-          {
-            variant: "body2",
-            component: "label",
-            htmlFor: "confirmPassword",
-            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
-            children: t("resetPassword.confirmPasswordLabel")
-          }
-        ),
-        /* @__PURE__ */ jsx6(
-          TextField3,
-          {
-            fullWidth: true,
-            id: "confirmPassword",
-            name: "confirmPassword",
-            type: "password",
-            value: confirmPassword,
-            disabled: loading,
-            onChange: (e) => setConfirmPassword(e.target.value),
-            error: !!helperTextConfirmPassword,
-            helperText: helperTextConfirmPassword,
-            autoComplete: "new-password",
-            placeholder: t("resetPassword.confirmPasswordPlaceholder"),
-            required: true
-          }
-        )
-      ] }),
-      /* @__PURE__ */ jsx6(Button3, { disabled: loading, type: "button", onClick: handleSubmit, fullWidth: true, variant: "contained", color: "primary", sx: { mt: 2, mb: 2 }, children: loading ? /* @__PURE__ */ jsx6(CircularProgress3, { size: 20 }) : t("resetPassword.resetPasswordButton") }),
-      /* @__PURE__ */ jsx6(Box3, { sx: { display: "flex", justifyContent: "center", alignItems: "center" }, children: /* @__PURE__ */ jsx6(Link3, { sx: { cursor: "pointer" }, onClick: handleBack, variant: "body2", color: "secondary", children: t("common.back") }) })
-    ] }),
-    /* @__PURE__ */ jsx6(Box3, { children: errors.length > 0 && errors.map((error, index) => /* @__PURE__ */ jsx6(Alert3, { variant: "filled", sx: { mt: 2 }, severity: "error", children: error }, index)) })
-  ] });
 };
-var ResetPasswordForm_default = ResetPasswordForm;
 
-// src/components/CrudifyLogin/Forms/CheckCodeForm.tsx
-import { useState as useState5, useEffect as useEffect6 } from "react";
-import { Typography as Typography4, TextField as TextField4, Button as Button4, Box as Box4, CircularProgress as CircularProgress4, Alert as Alert4, Link as Link4 } from "@mui/material";
-import { Fragment as Fragment4, jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
-var CheckCodeForm = ({ onScreenChange, onError, searchParams }) => {
-  const { crudify: crudify6 } = useCrudify();
-  const [code, setCode] = useState5("");
-  const [loading, setLoading] = useState5(false);
-  const [errors, setErrors] = useState5([]);
-  const [helperTextCode, setHelperTextCode] = useState5(null);
-  const [email, setEmail] = useState5("");
-  const { t } = useTranslation();
-  const getParam = (key) => {
-    if (!searchParams) return null;
-    if (searchParams instanceof URLSearchParams) {
-      return searchParams.get(key);
+// src/providers/SessionProvider.tsx
+import { Fragment, jsx as jsx4, jsxs } from "react/jsx-runtime";
+var SessionContext = createContext4(void 0);
+function SessionProvider({ children, options = {}, config: propConfig }) {
+  const sessionHook = useSession(options);
+  const resolvedConfig = useMemo2(() => {
+    let publicApiKey;
+    let env;
+    let appName;
+    let loginActions;
+    let logo;
+    let colors;
+    let configSource = "unknown";
+    if (propConfig?.publicApiKey) {
+      publicApiKey = propConfig.publicApiKey;
+      configSource = "props";
     }
-    return searchParams[key] || null;
-  };
-  const translateError = (parsedError) => {
-    const possibleKeys = [
-      `errors.auth.${parsedError.code}`,
-      `errors.data.${parsedError.code}`,
-      `errors.system.${parsedError.code}`,
-      `errors.${parsedError.code}`,
-      `checkCode.${parsedError.code.toLowerCase()}`
-    ];
-    for (const key of possibleKeys) {
-      const translated = t(key);
-      if (translated !== key) {
-        return translated;
-      }
+    if (propConfig?.env) {
+      env = propConfig.env;
     }
-    return parsedError.message || t("error.unknown");
-  };
-  useEffect6(() => {
-    const emailParam = getParam("email");
-    if (emailParam) {
-      setEmail(emailParam);
-    } else {
-      onScreenChange?.("forgotPassword");
+    if (propConfig?.appName) {
+      appName = propConfig.appName;
     }
-  }, [searchParams, onScreenChange]);
-  const handleSubmit = async () => {
-    if (loading || !crudify6) return;
-    setErrors([]);
-    setHelperTextCode(null);
-    if (!code) {
-      setHelperTextCode(t("checkCode.codeRequired"));
-      return;
+    if (propConfig?.loginActions) {
+      loginActions = propConfig.loginActions;
     }
-    if (code.length !== 6) {
-      setHelperTextCode(t("checkCode.codeRequired"));
-      return;
+    if (propConfig?.logo) {
+      logo = propConfig.logo;
+    }
+    if (propConfig?.colors) {
+      colors = propConfig.colors;
+    }
+    if (!publicApiKey) {
+      const cookieApiKey = getCookie("publicApiKey");
+      const cookieEnv = getCookie("environment");
+      const cookieAppName = getCookie("appName");
+      const cookieLoginActions = getCookie("loginActions");
+      if (cookieApiKey) {
+        publicApiKey = cookieApiKey;
+        configSource = "cookies";
+      }
+      if (cookieEnv && ["dev", "stg", "prod"].includes(cookieEnv)) {
+        env = cookieEnv;
+      }
+      if (cookieAppName) {
+        appName = cookieAppName;
+      }
+      if (cookieLoginActions) {
+        loginActions = cookieLoginActions.split(",").map((s) => s.trim()).filter(Boolean);
+      }
+    }
+    console.log("\u{1F50D} SessionProvider - Configuration Detection:");
+    console.log("   - Config source:", configSource);
+    console.log("   - PublicApiKey:", publicApiKey ? publicApiKey.substring(0, 15) + "..." : "undefined");
+    console.log("   - Environment:", env);
+    console.log("   - App name:", appName);
+    console.log("   - Login actions:", loginActions);
+    return {
+      publicApiKey,
+      env,
+      appName,
+      loginActions,
+      logo,
+      colors
+    };
+  }, [propConfig]);
+  const sessionData = useMemo2(() => {
+    if (!sessionHook.tokens?.accessToken || !sessionHook.isAuthenticated) {
+      return null;
     }
-    setLoading(true);
     try {
-      const data = [
-        {
-          operation: "validatePasswordResetCode",
-          data: { email, codePassword: code }
-        }
-      ];
-      const response = await crudify6.transaction(data);
-      if (response.success) {
-        onScreenChange?.("resetPassword", { email, code, fromCodeVerification: "true" });
-      } else {
-        const parsedErrors = handleCrudifyError(response);
-        const translatedErrors = parsedErrors.map(translateError);
-        setErrors(translatedErrors);
-        setLoading(false);
+      const decoded = decodeJwtSafely(sessionHook.tokens.accessToken);
+      if (decoded && decoded.sub && decoded.email && decoded.subscriber) {
+        const result = {
+          _id: decoded.sub,
+          email: decoded.email,
+          subscriberKey: decoded.subscriber
+        };
+        Object.keys(decoded).forEach((key) => {
+          if (!["sub", "email", "subscriber"].includes(key)) {
+            result[key] = decoded[key];
+          }
+        });
+        return result;
       }
     } catch (error) {
-      const parsedErrors = handleCrudifyError(error);
-      const translatedErrors = parsedErrors.map(translateError);
-      setErrors(translatedErrors);
-      setLoading(false);
-      if (onError) {
-        onError(translatedErrors.join(", "));
-      }
+      console.error("Error decoding JWT token for sessionData:", error);
     }
+    return null;
+  }, [sessionHook.tokens?.accessToken, sessionHook.isAuthenticated]);
+  const contextValue = {
+    ...sessionHook,
+    sessionData,
+    config: resolvedConfig
   };
-  const handleBack = () => {
-    onScreenChange?.("forgotPassword");
-  };
-  const handleCodeChange = (event) => {
-    const value = event.target.value.replace(/\D/g, "").slice(0, 6);
-    setCode(value);
-  };
-  return /* @__PURE__ */ jsxs4(Fragment4, { children: [
-    /* @__PURE__ */ jsxs4(Box4, { component: "form", noValidate: true, sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2 }, children: [
-      /* @__PURE__ */ jsxs4(Box4, { sx: { mb: 2 }, children: [
-        /* @__PURE__ */ jsx7(Typography4, { variant: "h5", component: "h1", sx: { mb: 1, fontWeight: 600 }, children: t("checkCode.title") }),
-        /* @__PURE__ */ jsx7(Typography4, { variant: "body2", sx: { color: "grey.600" }, children: t("checkCode.instructions") })
-      ] }),
-      /* @__PURE__ */ jsxs4(Box4, { sx: { mb: 1 }, children: [
-        /* @__PURE__ */ jsx7(
-          Typography4,
-          {
-            variant: "body2",
-            component: "label",
-            htmlFor: "code",
-            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
-            children: t("checkCode.codeLabel")
+  return /* @__PURE__ */ jsx4(SessionContext.Provider, { value: contextValue, children });
+}
+function useSessionContext() {
+  const context = useContext4(SessionContext);
+  if (context === void 0) {
+    throw new Error("useSessionContext must be used within a SessionProvider");
+  }
+  return context;
+}
+function ProtectedRoute({ children, fallback = /* @__PURE__ */ jsx4("div", { children: "Please log in to access this content" }), redirectTo }) {
+  const { isAuthenticated, isLoading, isInitialized } = useSessionContext();
+  if (!isInitialized || isLoading) {
+    return /* @__PURE__ */ jsx4("div", { children: "Loading..." });
+  }
+  if (!isAuthenticated) {
+    if (redirectTo) {
+      redirectTo();
+      return null;
+    }
+    return /* @__PURE__ */ jsx4(Fragment, { children: fallback });
+  }
+  return /* @__PURE__ */ jsx4(Fragment, { children });
+}
+function SessionDebugInfo() {
+  const session = useSessionContext();
+  if (!session.isInitialized) {
+    return /* @__PURE__ */ jsx4("div", { children: "Session not initialized" });
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        padding: "10px",
+        margin: "10px",
+        border: "1px solid #ccc",
+        borderRadius: "4px",
+        fontSize: "12px",
+        fontFamily: "monospace"
+      },
+      children: [
+        /* @__PURE__ */ jsx4("h4", { children: "Session Debug Info" }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx4("strong", { children: "Authenticated:" }),
+          " ",
+          session.isAuthenticated ? "Yes" : "No"
+        ] }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx4("strong", { children: "Loading:" }),
+          " ",
+          session.isLoading ? "Yes" : "No"
+        ] }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx4("strong", { children: "Error:" }),
+          " ",
+          session.error || "None"
+        ] }),
+        session.tokens && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx4("strong", { children: "Access Token:" }),
+            " ",
+            session.tokens.accessToken.substring(0, 20),
+            "..."
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx4("strong", { children: "Refresh Token:" }),
+            " ",
+            session.tokens.refreshToken.substring(0, 20),
+            "..."
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx4("strong", { children: "Access Expires In:" }),
+            " ",
+            Math.round(session.expiresIn / 1e3 / 60),
+            " minutes"
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx4("strong", { children: "Refresh Expires In:" }),
+            " ",
+            Math.round(session.refreshExpiresIn / 1e3 / 60 / 60),
+            " hours"
+          ] }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx4("strong", { children: "Expiring Soon:" }),
+            " ",
+            session.isExpiringSoon ? "Yes" : "No"
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/CrudifyLogin/Forms/LoginForm.tsx
+import { useEffect as useEffect5, useRef } from "react";
+import { Typography, TextField, Button, Box, CircularProgress, Alert, Link } from "@mui/material";
+
+// src/utils/errorHandler.ts
+var ERROR_CODES = {
+  // Authentication Errors
+  INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  INVALID_API_KEY: "INVALID_API_KEY",
+  USER_NOT_FOUND: "USER_NOT_FOUND",
+  USER_NOT_ACTIVE: "USER_NOT_ACTIVE",
+  NO_PERMISSION: "NO_PERMISSION",
+  // Data Errors
+  ITEM_NOT_FOUND: "ITEM_NOT_FOUND",
+  NOT_FOUND: "NOT_FOUND",
+  IN_USE: "IN_USE",
+  // Validation Errors
+  FIELD_ERROR: "FIELD_ERROR",
+  BAD_REQUEST: "BAD_REQUEST",
+  INVALID_EMAIL: "INVALID_EMAIL",
+  INVALID_CODE: "INVALID_CODE",
+  // System Errors
+  INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
+  DATABASE_CONNECTION_ERROR: "DATABASE_CONNECTION_ERROR",
+  INVALID_CONFIGURATION: "INVALID_CONFIGURATION",
+  UNKNOWN_OPERATION: "UNKNOWN_OPERATION",
+  // Rate Limiting
+  TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS",
+  // Network Errors
+  NETWORK_ERROR: "NETWORK_ERROR",
+  TIMEOUT_ERROR: "TIMEOUT_ERROR"
+};
+var ERROR_SEVERITY_MAP = {
+  // Authentication - warning (user can fix)
+  [ERROR_CODES.INVALID_CREDENTIALS]: "warning",
+  [ERROR_CODES.UNAUTHORIZED]: "warning",
+  [ERROR_CODES.INVALID_API_KEY]: "error",
+  [ERROR_CODES.USER_NOT_FOUND]: "warning",
+  [ERROR_CODES.USER_NOT_ACTIVE]: "warning",
+  [ERROR_CODES.NO_PERMISSION]: "warning",
+  // Data - info (might be expected)
+  [ERROR_CODES.ITEM_NOT_FOUND]: "info",
+  [ERROR_CODES.NOT_FOUND]: "info",
+  [ERROR_CODES.IN_USE]: "warning",
+  // Validation - warning (user input issue)
+  [ERROR_CODES.FIELD_ERROR]: "warning",
+  [ERROR_CODES.BAD_REQUEST]: "warning",
+  [ERROR_CODES.INVALID_EMAIL]: "warning",
+  [ERROR_CODES.INVALID_CODE]: "warning",
+  // System - error (server issue)
+  [ERROR_CODES.INTERNAL_SERVER_ERROR]: "error",
+  [ERROR_CODES.DATABASE_CONNECTION_ERROR]: "error",
+  [ERROR_CODES.INVALID_CONFIGURATION]: "error",
+  [ERROR_CODES.UNKNOWN_OPERATION]: "error",
+  // Rate limiting - warning with higher duration
+  [ERROR_CODES.TOO_MANY_REQUESTS]: "warning",
+  // Network - error
+  [ERROR_CODES.NETWORK_ERROR]: "error",
+  [ERROR_CODES.TIMEOUT_ERROR]: "error"
+};
+function parseApiError(response) {
+  const errors = [];
+  try {
+    const apiResponse = response;
+    if (apiResponse.data && typeof apiResponse.data === "object") {
+      const responseData = apiResponse.data;
+      if (responseData.response) {
+        const { status, fieldsWarning } = responseData.response;
+        if (fieldsWarning && typeof fieldsWarning === "object") {
+          Object.entries(fieldsWarning).forEach(([field, messages]) => {
+            if (Array.isArray(messages) && messages.length > 0) {
+              errors.push({
+                code: ERROR_CODES.FIELD_ERROR,
+                message: messages[0],
+                severity: "warning",
+                field
+              });
+            }
+          });
+        }
+        if (status && typeof status === "string") {
+          const errorCode = status;
+          if (ERROR_SEVERITY_MAP[errorCode]) {
+            errors.push({
+              code: errorCode,
+              message: getErrorMessage(errorCode),
+              severity: ERROR_SEVERITY_MAP[errorCode]
+            });
           }
-        ),
-        /* @__PURE__ */ jsx7(
-          TextField4,
-          {
-            fullWidth: true,
-            id: "code",
-            name: "code",
-            type: "text",
-            value: code,
-            disabled: loading,
-            onChange: handleCodeChange,
-            error: !!helperTextCode,
-            helperText: helperTextCode,
-            placeholder: t("checkCode.codePlaceholder"),
-            inputProps: {
-              maxLength: 6,
-              style: { textAlign: "center", fontSize: "1.5rem", letterSpacing: "0.4rem" }
-            },
-            required: true
+        }
+      }
+    }
+    if (apiResponse.errors) {
+      if (typeof apiResponse.errors === "string") {
+        errors.push({
+          code: ERROR_CODES.BAD_REQUEST,
+          message: apiResponse.errors,
+          severity: "warning"
+        });
+      } else if (typeof apiResponse.errors === "object") {
+        const errorObj = apiResponse.errors;
+        Object.entries(errorObj).forEach(([field, messages]) => {
+          if (Array.isArray(messages) && messages.length > 0) {
+            if (field === "_error") {
+              messages.forEach((msg) => {
+                const errorCode = typeof msg === "string" && isValidErrorCode(msg) ? msg : ERROR_CODES.BAD_REQUEST;
+                errors.push({
+                  code: errorCode,
+                  message: typeof msg === "string" ? msg : getErrorMessage(errorCode),
+                  severity: ERROR_SEVERITY_MAP[errorCode] || "warning"
+                });
+              });
+            } else if (field === "_graphql") {
+              messages.forEach((msg) => {
+                if (typeof msg === "string") {
+                  const errorCode = isValidErrorCode(msg) ? msg : ERROR_CODES.BAD_REQUEST;
+                  errors.push({
+                    code: errorCode,
+                    message: getErrorMessage(errorCode),
+                    severity: ERROR_SEVERITY_MAP[errorCode] || "warning"
+                  });
+                }
+              });
+            } else {
+              errors.push({
+                code: ERROR_CODES.FIELD_ERROR,
+                message: typeof messages[0] === "string" ? messages[0] : "Validation error",
+                severity: "warning",
+                field
+              });
+            }
           }
-        )
-      ] }),
-      /* @__PURE__ */ jsx7(
-        Button4,
-        {
-          disabled: loading || code.length !== 6,
-          type: "button",
-          onClick: handleSubmit,
-          fullWidth: true,
-          variant: "contained",
-          color: "primary",
-          sx: { mt: 2, mb: 2 },
-          children: loading ? /* @__PURE__ */ jsx7(CircularProgress4, { size: 20 }) : t("checkCode.verifyButton")
+        });
+      }
+    }
+    if (errors.length === 0 && apiResponse.success === false) {
+      errors.push({
+        code: ERROR_CODES.BAD_REQUEST,
+        message: "Request failed",
+        severity: "warning"
+      });
+    }
+  } catch (error) {
+    errors.push({
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+      message: "Failed to parse error response",
+      severity: "error",
+      details: { originalError: error }
+    });
+  }
+  return errors.length > 0 ? errors : [
+    {
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+      message: "Unknown error occurred",
+      severity: "error"
+    }
+  ];
+}
+function parseTransactionError(response) {
+  try {
+    const transactionResponse = response;
+    if (transactionResponse.data && Array.isArray(transactionResponse.data)) {
+      const errors = [];
+      transactionResponse.data.forEach((item, index) => {
+        if (item.response?.status === "TOO_MANY_REQUESTS") {
+          errors.push({
+            code: ERROR_CODES.TOO_MANY_REQUESTS,
+            message: getErrorMessage(ERROR_CODES.TOO_MANY_REQUESTS),
+            severity: "warning",
+            details: { transactionIndex: index }
+          });
+        } else if (!item.response || item.response.status !== "OK") {
+          errors.push({
+            code: ERROR_CODES.BAD_REQUEST,
+            message: "Transaction failed",
+            severity: "warning",
+            details: { transactionIndex: index, response: item.response }
+          });
         }
-      ),
-      /* @__PURE__ */ jsx7(Box4, { sx: { display: "flex", justifyContent: "center", alignItems: "center" }, children: /* @__PURE__ */ jsx7(Link4, { sx: { cursor: "pointer" }, onClick: handleBack, variant: "body2", color: "secondary", children: t("common.back") }) })
-    ] }),
-    /* @__PURE__ */ jsx7(Box4, { children: errors.length > 0 && errors.map((error, index) => /* @__PURE__ */ jsx7(Alert4, { sx: { mt: 2 }, severity: "error", children: error }, index)) })
-  ] });
-};
-var CheckCodeForm_default = CheckCodeForm;
-
-// src/components/CrudifyLogin/components/CrudifyInitializer.tsx
-import { Box as Box5, CircularProgress as CircularProgress5, Alert as Alert5, Typography as Typography5 } from "@mui/material";
-import { Fragment as Fragment5, jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
-var CrudifyInitializer = ({ children, fallback }) => {
-  const { isLoading, error, isInitialized } = useCrudify();
-  const { t } = useTranslation();
-  if (isLoading) {
-    return fallback || /* @__PURE__ */ jsxs5(
-      Box5,
+      });
+      return errors;
+    }
+    return parseApiError(response);
+  } catch (error) {
+    return [
       {
-        sx: {
-          display: "flex",
-          flexDirection: "column",
-          alignItems: "center",
-          justifyContent: "center",
-          minHeight: "200px",
-          gap: 2
-        },
-        children: [
-          /* @__PURE__ */ jsx8(CircularProgress5, {}),
-          /* @__PURE__ */ jsx8(Typography5, { variant: "body2", color: "text.secondary", children: t("login.initializing") !== "login.initializing" ? t("login.initializing") : "Initializing..." })
-        ]
+        code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+        message: "Failed to parse transaction error",
+        severity: "error",
+        details: { originalError: error }
       }
-    );
-  }
-  if (error) {
-    return /* @__PURE__ */ jsx8(Alert5, { severity: "error", sx: { mt: 2 }, children: /* @__PURE__ */ jsxs5(Typography5, { variant: "body2", children: [
-      t("login.initializationError") !== "login.initializationError" ? t("login.initializationError") : "Initialization error",
-      ":",
-      " ",
-      error
-    ] }) });
-  }
-  if (!isInitialized) {
-    return /* @__PURE__ */ jsx8(Alert5, { severity: "warning", sx: { mt: 2 }, children: /* @__PURE__ */ jsx8(Typography5, { variant: "body2", children: t("login.notInitialized") !== "login.notInitialized" ? t("login.notInitialized") : "System not initialized" }) });
-  }
-  return /* @__PURE__ */ jsx8(Fragment5, { children });
-};
-
-// src/providers/SessionProvider.tsx
-import { createContext as createContext4, useContext as useContext4, useMemo as useMemo2 } from "react";
-
-// src/hooks/useSession.ts
-import { useState as useState6, useEffect as useEffect7, useCallback } from "react";
-
-// src/core/SessionManager.ts
-import crudify2 from "@nocios/crudify-browser";
-
-// src/utils/tokenStorage.ts
-import CryptoJS from "crypto-js";
-var _TokenStorage = class _TokenStorage {
-  /**
-   * Configurar tipo de almacenamiento
-   */
-  static setStorageType(type) {
-    _TokenStorage.storageType = type;
+    ];
   }
-  /**
-   * Verificar si el storage está disponible
-   */
-  static isStorageAvailable(type) {
-    try {
-      const storage = window[type];
-      const testKey = "__storage_test__";
-      storage.setItem(testKey, "test");
-      storage.removeItem(testKey);
-      return true;
-    } catch {
-      return false;
+}
+function isValidErrorCode(code) {
+  return Object.values(ERROR_CODES).includes(code);
+}
+function getErrorMessage(code) {
+  const messages = {
+    [ERROR_CODES.INVALID_CREDENTIALS]: "Invalid email or password",
+    [ERROR_CODES.UNAUTHORIZED]: "You are not authorized to perform this action",
+    [ERROR_CODES.INVALID_API_KEY]: "Invalid API key",
+    [ERROR_CODES.USER_NOT_FOUND]: "User not found",
+    [ERROR_CODES.USER_NOT_ACTIVE]: "User account is not active",
+    [ERROR_CODES.NO_PERMISSION]: "You do not have permission to perform this action",
+    [ERROR_CODES.ITEM_NOT_FOUND]: "Item not found",
+    [ERROR_CODES.NOT_FOUND]: "Resource not found",
+    [ERROR_CODES.IN_USE]: "Resource is currently in use",
+    [ERROR_CODES.FIELD_ERROR]: "Validation error",
+    [ERROR_CODES.BAD_REQUEST]: "Invalid request",
+    [ERROR_CODES.INVALID_EMAIL]: "Please enter a valid email address",
+    [ERROR_CODES.INVALID_CODE]: "Invalid or expired code",
+    [ERROR_CODES.INTERNAL_SERVER_ERROR]: "Internal server error",
+    [ERROR_CODES.DATABASE_CONNECTION_ERROR]: "Database connection error",
+    [ERROR_CODES.INVALID_CONFIGURATION]: "Invalid configuration",
+    [ERROR_CODES.UNKNOWN_OPERATION]: "Unknown operation",
+    [ERROR_CODES.TOO_MANY_REQUESTS]: "Too many requests. Please try again later.",
+    [ERROR_CODES.NETWORK_ERROR]: "Network error. Please check your connection.",
+    [ERROR_CODES.TIMEOUT_ERROR]: "Request timed out. Please try again."
+  };
+  return messages[code] || "An unknown error occurred";
+}
+function parseJavaScriptError(error) {
+  if (error instanceof Error) {
+    if (error.name === "AbortError") {
+      return {
+        code: ERROR_CODES.TIMEOUT_ERROR,
+        message: "Request was cancelled",
+        severity: "info"
+      };
     }
-  }
-  /**
-   * Obtener instancia de storage
-   */
-  static getStorage() {
-    if (_TokenStorage.storageType === "none") return null;
-    if (!_TokenStorage.isStorageAvailable(_TokenStorage.storageType)) {
-      console.warn(`Crudify: ${_TokenStorage.storageType} not available, tokens won't persist`);
-      return null;
+    if (error.message.includes("NetworkError") || error.message.includes("Failed to fetch")) {
+      return {
+        code: ERROR_CODES.NETWORK_ERROR,
+        message: getErrorMessage(ERROR_CODES.NETWORK_ERROR),
+        severity: "error"
+      };
     }
-    return window[_TokenStorage.storageType];
+    return {
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+      message: error.message || "An unexpected error occurred",
+      severity: "error",
+      details: { originalError: error }
+    };
   }
-  /**
-   * Encriptar datos sensibles
-   */
-  static encrypt(data) {
-    try {
-      return CryptoJS.AES.encrypt(data, _TokenStorage.ENCRYPTION_KEY).toString();
-    } catch (error) {
-      console.error("Crudify: Encryption failed", error);
-      return data;
-    }
+  return {
+    code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+    message: "An unknown error occurred",
+    severity: "error",
+    details: { originalError: error }
+  };
+}
+function handleCrudifyError(error) {
+  if (error instanceof Error) {
+    return [parseJavaScriptError(error)];
   }
-  /**
-   * Desencriptar datos
-   */
-  static decrypt(encryptedData) {
-    try {
-      const bytes = CryptoJS.AES.decrypt(encryptedData, _TokenStorage.ENCRYPTION_KEY);
-      const decrypted = bytes.toString(CryptoJS.enc.Utf8);
-      return decrypted || encryptedData;
-    } catch (error) {
-      console.error("Crudify: Decryption failed", error);
-      return encryptedData;
+  if (typeof error === "object" && error !== null) {
+    const response = error;
+    if (response.data && Array.isArray(response.data)) {
+      return parseTransactionError(error);
     }
+    return parseApiError(error);
   }
-  /**
-   * Guardar tokens de forma segura
-   */
-  static saveTokens(tokens) {
-    const storage = _TokenStorage.getStorage();
-    if (!storage) return;
-    try {
-      const tokenData = {
-        accessToken: tokens.accessToken,
-        refreshToken: tokens.refreshToken,
-        expiresAt: tokens.expiresAt,
-        refreshExpiresAt: tokens.refreshExpiresAt,
-        savedAt: Date.now()
-      };
-      const encrypted = _TokenStorage.encrypt(JSON.stringify(tokenData));
-      storage.setItem(_TokenStorage.TOKEN_KEY, encrypted);
-      console.debug("Crudify: Tokens saved successfully");
-    } catch (error) {
-      console.error("Crudify: Failed to save tokens", error);
+  return [
+    {
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+      message: "An unknown error occurred",
+      severity: "error",
+      details: { originalError: error }
     }
-  }
-  /**
-   * Obtener tokens guardados
-   */
-  static getTokens() {
-    const storage = _TokenStorage.getStorage();
-    if (!storage) return null;
-    try {
-      const encrypted = storage.getItem(_TokenStorage.TOKEN_KEY);
-      if (!encrypted) return null;
-      const decrypted = _TokenStorage.decrypt(encrypted);
-      const tokenData = JSON.parse(decrypted);
-      if (!tokenData.accessToken || !tokenData.refreshToken || !tokenData.expiresAt || !tokenData.refreshExpiresAt) {
-        console.warn("Crudify: Incomplete token data found, clearing storage");
-        _TokenStorage.clearTokens();
-        return null;
+  ];
+}
+
+// src/components/CrudifyLogin/Forms/LoginForm.tsx
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+var LoginForm = ({ onScreenChange, onExternalNavigate, onLoginSuccess, onError, redirectUrl = "/" }) => {
+  const { crudify: crudify6 } = useCrudify();
+  const { state, updateFormData, setFieldError, clearErrors, setLoading } = useLoginState();
+  const { login: sessionLogin } = useSessionContext();
+  const { t } = useTranslation();
+  const usernameInputRef = useRef(null);
+  const getRedirectUrl = () => {
+    if (state.searchParams.redirect) {
+      try {
+        const decodedPath = decodeURIComponent(state.searchParams.redirect);
+        if (decodedPath.startsWith("/") && !decodedPath.startsWith("//")) {
+          return decodedPath;
+        }
+      } catch (error) {
       }
-      if (Date.now() >= tokenData.refreshExpiresAt) {
-        console.info("Crudify: Refresh token expired, clearing storage");
-        _TokenStorage.clearTokens();
-        return null;
+    }
+    return redirectUrl || "/";
+  };
+  useEffect5(() => {
+    const timer = setTimeout(() => {
+      if (usernameInputRef.current) usernameInputRef.current.focus();
+    }, 100);
+    return () => clearTimeout(timer);
+  }, []);
+  const translateError = (parsedError) => {
+    const possibleKeys = [
+      `errors.auth.${parsedError.code}`,
+      `errors.data.${parsedError.code}`,
+      `errors.system.${parsedError.code}`,
+      `errors.${parsedError.code}`,
+      `login.${parsedError.code.toLowerCase()}`
+    ];
+    for (const key of possibleKeys) {
+      const translated = t(key);
+      if (translated !== key) {
+        return translated;
       }
-      return {
-        accessToken: tokenData.accessToken,
-        refreshToken: tokenData.refreshToken,
-        expiresAt: tokenData.expiresAt,
-        refreshExpiresAt: tokenData.refreshExpiresAt
-      };
-    } catch (error) {
-      console.error("Crudify: Failed to retrieve tokens", error);
-      _TokenStorage.clearTokens();
-      return null;
     }
-  }
-  /**
-   * Limpiar tokens almacenados
-   */
-  static clearTokens() {
-    const storage = _TokenStorage.getStorage();
-    if (!storage) return;
-    try {
-      storage.removeItem(_TokenStorage.TOKEN_KEY);
-      console.debug("Crudify: Tokens cleared from storage");
-    } catch (error) {
-      console.error("Crudify: Failed to clear tokens", error);
+    return parsedError.message || t("error.unknown");
+  };
+  const handleLogin = async () => {
+    if (state.loading) return;
+    if (!state.formData.username.trim()) {
+      setFieldError("username", t("login.usernameRequired"));
+      return;
     }
-  }
-  /**
-   * Verificar si hay tokens válidos guardados
-   */
-  static hasValidTokens() {
-    const tokens = _TokenStorage.getTokens();
-    return tokens !== null;
-  }
-  /**
-   * Obtener información de expiración
-   */
-  static getExpirationInfo() {
-    const tokens = _TokenStorage.getTokens();
-    if (!tokens) return null;
-    const now = Date.now();
-    return {
-      accessExpired: now >= tokens.expiresAt,
-      refreshExpired: now >= tokens.refreshExpiresAt,
-      accessExpiresIn: Math.max(0, tokens.expiresAt - now),
-      refreshExpiresIn: Math.max(0, tokens.refreshExpiresAt - now)
-    };
-  }
-  /**
-   * Actualizar solo el access token (después de refresh)
-   */
-  static updateAccessToken(newAccessToken, newExpiresAt) {
-    const existingTokens = _TokenStorage.getTokens();
-    if (!existingTokens) {
-      console.warn("Crudify: Cannot update access token, no existing tokens found");
+    if (!state.formData.password.trim()) {
+      setFieldError("password", t("login.passwordRequired"));
       return;
     }
-    _TokenStorage.saveTokens({
-      ...existingTokens,
-      accessToken: newAccessToken,
-      expiresAt: newExpiresAt
+    clearErrors();
+    setLoading(true);
+    try {
+      const response = await sessionLogin(state.formData.username, state.formData.password);
+      setLoading(false);
+      if (response.success) {
+        console.log("\u{1F510} LoginForm - Login successful via SessionProvider, calling onLoginSuccess");
+        const finalRedirectUrl = getRedirectUrl();
+        if (onLoginSuccess) {
+          onLoginSuccess(response.data, finalRedirectUrl);
+        }
+      } else {
+        handleLoginError(response);
+      }
+    } catch (error) {
+      setLoading(false);
+      const parsedErrors = handleCrudifyError(error);
+      const translatedErrors = parsedErrors.map(translateError);
+      setFieldError("global", translatedErrors);
+      if (onError) {
+        onError(translatedErrors.join(", "));
+      }
+    }
+  };
+  const handleLoginError = (response) => {
+    const parsedErrors = handleCrudifyError(response);
+    parsedErrors.forEach((error) => {
+      if (error.field) {
+        setFieldError(error.field, translateError(error));
+      } else {
+        const currentGlobalErrors = state.errors.global || [];
+        setFieldError("global", [...currentGlobalErrors, translateError(error)]);
+      }
     });
-  }
+  };
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    handleLogin();
+  };
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !state.loading) {
+      e.preventDefault();
+      handleLogin();
+    }
+  };
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsxs2(
+      Box,
+      {
+        component: "form",
+        noValidate: true,
+        onSubmit: handleSubmit,
+        onKeyDown: handleKeyDown,
+        sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2 },
+        children: [
+          /* @__PURE__ */ jsxs2(Box, { sx: { mb: 1 }, children: [
+            /* @__PURE__ */ jsx5(
+              Typography,
+              {
+                variant: "body2",
+                component: "label",
+                htmlFor: "email",
+                sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+                children: t("login.usernameOrEmailLabel")
+              }
+            ),
+            /* @__PURE__ */ jsx5(
+              TextField,
+              {
+                fullWidth: true,
+                id: "email",
+                name: "email",
+                type: "email",
+                value: state.formData.username,
+                disabled: state.loading,
+                onChange: (e) => updateFormData({ username: e.target.value }),
+                error: !!state.errors.username,
+                helperText: state.errors.username,
+                autoComplete: "email",
+                placeholder: t("login.usernameOrEmailPlaceholder"),
+                inputRef: usernameInputRef,
+                required: true
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs2(Box, { sx: { mb: 1 }, children: [
+            /* @__PURE__ */ jsx5(
+              Typography,
+              {
+                variant: "body2",
+                component: "label",
+                htmlFor: "password",
+                sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+                children: t("login.passwordLabel")
+              }
+            ),
+            /* @__PURE__ */ jsx5(
+              TextField,
+              {
+                fullWidth: true,
+                id: "password",
+                name: "password",
+                type: "password",
+                value: state.formData.password,
+                disabled: state.loading,
+                onChange: (e) => updateFormData({ password: e.target.value }),
+                error: !!state.errors.password,
+                helperText: state.errors.password,
+                autoComplete: "current-password",
+                placeholder: t("login.passwordPlaceholder"),
+                required: true
+              }
+            )
+          ] }),
+          state.config.loginActions?.includes("forgotPassword") && /* @__PURE__ */ jsx5(Box, { sx: { display: "flex", justifyContent: "flex-end", alignItems: "center" }, children: /* @__PURE__ */ jsx5(
+            Link,
+            {
+              sx: { cursor: "pointer" },
+              onClick: () => {
+                onScreenChange?.("forgotPassword", state.searchParams);
+              },
+              variant: "body2",
+              color: "secondary",
+              children: t("login.forgotPasswordLink")
+            }
+          ) }),
+          /* @__PURE__ */ jsx5(Button, { disabled: state.loading, type: "submit", fullWidth: true, variant: "contained", color: "primary", sx: { mt: 1, mb: 2 }, children: state.loading ? /* @__PURE__ */ jsx5(CircularProgress, { size: 20 }) : t("login.loginButton") })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx5(Box, { children: state.errors.global && state.errors.global.length > 0 && state.errors.global.map((error, index) => /* @__PURE__ */ jsx5(Alert, { variant: "filled", sx: { mt: 2 }, severity: "error", children: /* @__PURE__ */ jsx5("div", { children: error }) }, index)) }),
+    state.config.loginActions?.includes("createUser") && /* @__PURE__ */ jsxs2(Typography, { variant: "body2", align: "center", sx: { color: "text.secondary", mt: 3 }, children: [
+      t("login.noAccountPrompt"),
+      " ",
+      /* @__PURE__ */ jsx5(
+        Link,
+        {
+          sx: { cursor: "pointer" },
+          onClick: () => {
+            const searchString = Object.keys(state.searchParams).length > 0 ? `?${new URLSearchParams(state.searchParams).toString()}` : "";
+            const signupUrl = `/public/users/create${searchString}`;
+            onExternalNavigate?.(signupUrl);
+          },
+          fontWeight: "medium",
+          color: "secondary",
+          children: t("login.signUpLink")
+        }
+      )
+    ] })
+  ] });
 };
-_TokenStorage.TOKEN_KEY = "crudify_tokens";
-_TokenStorage.ENCRYPTION_KEY = "crudify_secure_key_v1";
-_TokenStorage.storageType = "localStorage";
-var TokenStorage = _TokenStorage;
+var LoginForm_default = LoginForm;
 
-// src/core/SessionManager.ts
-var SessionManager = class _SessionManager {
-  constructor() {
-    this.config = {};
-    this.initialized = false;
-  }
-  static getInstance() {
-    if (!_SessionManager.instance) {
-      _SessionManager.instance = new _SessionManager();
-    }
-    return _SessionManager.instance;
-  }
-  /**
-   * Inicializar el SessionManager
-   */
-  async initialize(config = {}) {
-    if (this.initialized) {
-      console.warn("SessionManager: Already initialized");
-      return;
+// src/components/CrudifyLogin/Forms/ForgotPasswordForm.tsx
+import { useState as useState4 } from "react";
+import { Typography as Typography2, TextField as TextField2, Button as Button2, Box as Box2, CircularProgress as CircularProgress2, Alert as Alert2, Link as Link2 } from "@mui/material";
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+var ForgotPasswordForm = ({ onScreenChange, onError }) => {
+  const { crudify: crudify6 } = useCrudify();
+  const [email, setEmail] = useState4("");
+  const [loading, setLoading] = useState4(false);
+  const [errors, setErrors] = useState4([]);
+  const [helperTextEmail, setHelperTextEmail] = useState4(null);
+  const [emailSent, setEmailSent] = useState4(false);
+  const [codeAlreadyExists, setCodeAlreadyExists] = useState4(false);
+  const { t } = useTranslation();
+  const translateError = (parsedError) => {
+    const possibleKeys = [
+      `errors.auth.${parsedError.code}`,
+      `errors.data.${parsedError.code}`,
+      `errors.system.${parsedError.code}`,
+      `errors.${parsedError.code}`,
+      `forgotPassword.${parsedError.code.toLowerCase()}`
+    ];
+    for (const key of possibleKeys) {
+      const translated = t(key);
+      if (translated !== key) {
+        return translated;
+      }
     }
-    this.config = {
-      storageType: "localStorage",
-      autoRestore: true,
-      enableLogging: false,
-      ...config
-    };
-    TokenStorage.setStorageType(this.config.storageType || "localStorage");
-    if (this.config.enableLogging) {
+    return parsedError.message || t("error.unknown");
+  };
+  const validateEmail = (email2) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email2);
+  };
+  const handleSubmit = async () => {
+    if (loading || !crudify6) return;
+    setErrors([]);
+    setHelperTextEmail(null);
+    if (!email) {
+      setHelperTextEmail(t("forgotPassword.emailRequired"));
+      return;
     }
-    if (this.config.autoRestore) {
-      await this.restoreSession();
+    if (!validateEmail(email)) {
+      setHelperTextEmail(t("forgotPassword.invalidEmail"));
+      return;
     }
-    this.initialized = true;
-    this.log("SessionManager initialized successfully");
-  }
-  /**
-   * Login con persistencia automática
-   */
-  async login(email, password) {
+    setLoading(true);
     try {
-      this.log("Attempting login...");
-      const response = await crudify2.login(email, password);
-      if (!response.success) {
-        this.log("Login failed:", response.errors);
-        return {
-          success: false,
-          error: this.formatError(response.errors)
-        };
+      const data = [{ operation: "requestPasswordReset", data: { email } }];
+      const response = await crudify6.transaction(data);
+      if (response.success) {
+        if (response.data && response.data.existingCodeValid) {
+          setCodeAlreadyExists(true);
+        } else {
+          setEmailSent(true);
+        }
+      } else {
+        const parsedErrors = handleCrudifyError(response);
+        const translatedErrors = parsedErrors.map(translateError);
+        setErrors(translatedErrors);
       }
-      const tokens = {
-        accessToken: response.data.token,
-        refreshToken: response.data.refreshToken,
-        expiresAt: response.data.expiresAt,
-        refreshExpiresAt: response.data.refreshExpiresAt
-      };
-      TokenStorage.saveTokens(tokens);
-      this.log("Login successful, tokens saved");
-      this.config.onLoginSuccess?.(tokens);
-      return {
-        success: true,
-        tokens
-      };
     } catch (error) {
-      this.log("Login error:", error);
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
+      const parsedErrors = handleCrudifyError(error);
+      const translatedErrors = parsedErrors.map(translateError);
+      setErrors(translatedErrors);
+      if (onError) {
+        onError(translatedErrors.join(", "));
+      }
+    } finally {
+      setLoading(false);
     }
-  }
-  /**
-   * Logout con limpieza de tokens
-   */
-  async logout() {
-    try {
-      this.log("Logging out...");
-      await crudify2.logout();
-      TokenStorage.clearTokens();
-      this.log("Logout successful");
-      this.config.onLogout?.();
-    } catch (error) {
-      this.log("Logout error:", error);
-      TokenStorage.clearTokens();
+  };
+  const handleBack = () => {
+    onScreenChange?.("login");
+  };
+  const handleGoToCheckCode = () => {
+    if (emailSent || codeAlreadyExists) {
+      onScreenChange?.("checkCode", { email });
+      return;
     }
-  }
-  /**
-   * Restaurar sesión desde storage
-   */
-  async restoreSession() {
-    try {
-      this.log("Attempting to restore session...");
-      const savedTokens = TokenStorage.getTokens();
-      if (!savedTokens) {
-        this.log("No valid tokens found in storage");
-        return false;
-      }
-      crudify2.setTokens({
-        accessToken: savedTokens.accessToken,
-        refreshToken: savedTokens.refreshToken,
-        expiresAt: savedTokens.expiresAt,
-        refreshExpiresAt: savedTokens.refreshExpiresAt
-      });
-      this.log("Session restored successfully");
-      this.config.onSessionRestored?.(savedTokens);
-      return true;
-    } catch (error) {
-      this.log("Session restore error:", error);
-      TokenStorage.clearTokens();
-      return false;
+    if (!email) {
+      setHelperTextEmail(t("forgotPassword.emailRequired"));
+      return;
     }
+    if (!validateEmail(email)) {
+      setHelperTextEmail(t("forgotPassword.invalidEmail"));
+      return;
+    }
+    onScreenChange?.("checkCode", { email });
+  };
+  if (emailSent || codeAlreadyExists) {
+    return /* @__PURE__ */ jsx6(Fragment3, { children: /* @__PURE__ */ jsxs3(Box2, { sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2, textAlign: "center" }, children: [
+      /* @__PURE__ */ jsxs3(Box2, { sx: { mb: 2 }, children: [
+        /* @__PURE__ */ jsx6(Typography2, { variant: "h5", component: "h1", sx: { mb: 1, fontWeight: 600 }, children: codeAlreadyExists ? t("forgotPassword.codeAlreadyExistsMessage") : t("forgotPassword.emailSentMessage") }),
+        /* @__PURE__ */ jsx6(Typography2, { variant: "body2", sx: { color: codeAlreadyExists ? "success.main" : "grey.600" }, children: codeAlreadyExists ? t("forgotPassword.checkEmailInstructions") : t("forgotPassword.checkEmailInstructions") })
+      ] }),
+      /* @__PURE__ */ jsx6(Button2, { type: "button", onClick: handleGoToCheckCode, fullWidth: true, variant: "contained", color: "primary", sx: { mt: 2, mb: 2 }, children: t("forgotPassword.enterCodeLink") }),
+      /* @__PURE__ */ jsx6(Box2, { sx: { display: "flex", justifyContent: "center", alignItems: "center" }, children: /* @__PURE__ */ jsx6(Link2, { sx: { cursor: "pointer" }, onClick: handleBack, variant: "body2", color: "secondary", children: t("common.back") }) })
+    ] }) });
   }
-  /**
-   * Verificar si el usuario está autenticado
-   */
-  isAuthenticated() {
-    return crudify2.isLogin() || TokenStorage.hasValidTokens();
-  }
-  /**
-   * Obtener información de tokens actuales
-   */
-  getTokenInfo() {
-    const crudifyTokens = crudify2.getTokenData();
-    const storageInfo = TokenStorage.getExpirationInfo();
-    return {
-      isLoggedIn: this.isAuthenticated(),
-      crudifyTokens,
-      storageInfo,
-      hasValidTokens: TokenStorage.hasValidTokens()
-    };
-  }
-  /**
-   * Refrescar tokens manualmente
-   */
-  async refreshTokens() {
-    try {
-      this.log("Manually refreshing tokens...");
-      const response = await crudify2.refreshAccessToken();
-      if (!response.success) {
-        this.log("Token refresh failed:", response.errors);
-        TokenStorage.clearTokens();
-        this.config.onSessionExpired?.();
-        return false;
+  return /* @__PURE__ */ jsxs3(Fragment3, { children: [
+    /* @__PURE__ */ jsxs3(Box2, { component: "form", noValidate: true, sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2 }, children: [
+      /* @__PURE__ */ jsxs3(Box2, { sx: { mb: 2 }, children: [
+        /* @__PURE__ */ jsx6(Typography2, { variant: "h5", component: "h1", sx: { mb: 1, fontWeight: 600 }, children: t("forgotPassword.title") }),
+        /* @__PURE__ */ jsx6(Typography2, { variant: "body2", sx: { color: "grey.600" }, children: t("forgotPassword.instructions") })
+      ] }),
+      /* @__PURE__ */ jsxs3(Box2, { sx: { mb: 1 }, children: [
+        /* @__PURE__ */ jsx6(
+          Typography2,
+          {
+            variant: "body2",
+            component: "label",
+            htmlFor: "email",
+            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+            children: t("forgotPassword.emailLabel")
+          }
+        ),
+        /* @__PURE__ */ jsx6(
+          TextField2,
+          {
+            fullWidth: true,
+            id: "email",
+            name: "email",
+            type: "email",
+            value: email,
+            disabled: loading,
+            onChange: (e) => setEmail(e.target.value),
+            error: !!helperTextEmail,
+            helperText: helperTextEmail,
+            autoComplete: "email",
+            placeholder: t("forgotPassword.emailPlaceholder"),
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx6(Button2, { disabled: loading, type: "button", onClick: handleSubmit, fullWidth: true, variant: "contained", color: "primary", sx: { mt: 2, mb: 2 }, children: loading ? /* @__PURE__ */ jsx6(CircularProgress2, { size: 20 }) : t("forgotPassword.sendCodeButton") }),
+      /* @__PURE__ */ jsxs3(Box2, { sx: { display: "flex", justifyContent: "center", alignItems: "center", gap: 2 }, children: [
+        /* @__PURE__ */ jsx6(Link2, { sx: { cursor: "pointer" }, onClick: handleBack, variant: "body2", color: "secondary", children: t("common.back") }),
+        /* @__PURE__ */ jsx6(Typography2, { variant: "body2", sx: { color: "grey.400" }, children: "\u2022" }),
+        /* @__PURE__ */ jsx6(Link2, { sx: { cursor: "pointer" }, onClick: handleGoToCheckCode, variant: "body2", color: "secondary", children: t("login.alreadyHaveCodeLink") })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx6(Box2, { children: errors.length > 0 && errors.map((error, index) => /* @__PURE__ */ jsx6(Alert2, { variant: "filled", sx: { mt: 2 }, severity: "error", children: error }, index)) })
+  ] });
+};
+var ForgotPasswordForm_default = ForgotPasswordForm;
+
+// src/components/CrudifyLogin/Forms/ResetPasswordForm.tsx
+import { useState as useState5, useEffect as useEffect6 } from "react";
+import { Typography as Typography3, TextField as TextField3, Button as Button3, Box as Box3, CircularProgress as CircularProgress3, Alert as Alert3, Link as Link3 } from "@mui/material";
+import { Fragment as Fragment4, jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+var ResetPasswordForm = ({ onScreenChange, onError, searchParams, onResetSuccess }) => {
+  const { crudify: crudify6 } = useCrudify();
+  const [newPassword, setNewPassword] = useState5("");
+  const [confirmPassword, setConfirmPassword] = useState5("");
+  const [loading, setLoading] = useState5(false);
+  const [errors, setErrors] = useState5([]);
+  const [helperTextNewPassword, setHelperTextNewPassword] = useState5(null);
+  const [helperTextConfirmPassword, setHelperTextConfirmPassword] = useState5(null);
+  const [email, setEmail] = useState5("");
+  const [code, setCode] = useState5("");
+  const [fromCodeVerification, setFromCodeVerification] = useState5(false);
+  const [validatingCode, setValidatingCode] = useState5(true);
+  const [codeValidated, setCodeValidated] = useState5(false);
+  const [pendingValidation, setPendingValidation] = useState5(null);
+  const [isValidating, setIsValidating] = useState5(false);
+  const { t } = useTranslation();
+  const translateError = (parsedError) => {
+    const possibleKeys = [
+      `errors.auth.${parsedError.code}`,
+      `errors.data.${parsedError.code}`,
+      `errors.system.${parsedError.code}`,
+      `errors.${parsedError.code}`,
+      `resetPassword.${parsedError.code.toLowerCase()}`
+    ];
+    for (const key of possibleKeys) {
+      const translated = t(key);
+      if (translated !== key) {
+        return translated;
       }
-      const newTokens = {
-        accessToken: response.data.token,
-        refreshToken: response.data.refreshToken,
-        expiresAt: response.data.expiresAt,
-        refreshExpiresAt: response.data.refreshExpiresAt
-      };
-      TokenStorage.saveTokens(newTokens);
-      this.log("Tokens refreshed and saved successfully");
-      return true;
-    } catch (error) {
-      this.log("Token refresh error:", error);
-      TokenStorage.clearTokens();
-      this.config.onSessionExpired?.();
-      return false;
     }
-  }
-  /**
-   * Configurar interceptor de respuesta para manejo automático de errores
-   */
-  setupResponseInterceptor() {
-    crudify2.setResponseInterceptor(async (response) => {
-      if (response.errors) {
-        const hasAuthError = response.errors.some(
-          (error) => error.message?.includes("Unauthorized") || error.message?.includes("Token") || error.extensions?.code === "UNAUTHENTICATED"
-        );
-        if (hasAuthError && TokenStorage.hasValidTokens()) {
-          this.log("Auth error detected, attempting token refresh...");
-          const refreshSuccess = await this.refreshTokens();
-          if (!refreshSuccess) {
-            this.log("Session expired, triggering callback");
-            this.config.onSessionExpired?.();
+    return parsedError.message || t("error.unknown");
+  };
+  const getParam = (key) => {
+    if (!searchParams) return null;
+    if (searchParams instanceof URLSearchParams) {
+      return searchParams.get(key);
+    }
+    return searchParams[key] || null;
+  };
+  useEffect6(() => {
+    if (!searchParams) {
+      return;
+    }
+    if (searchParams) {
+      const fromCodeVerificationParam = getParam("fromCodeVerification");
+      const emailParam = getParam("email");
+      const codeParam = getParam("code");
+      if (fromCodeVerificationParam === "true" && emailParam && codeParam) {
+        setEmail(emailParam);
+        setCode(codeParam);
+        setFromCodeVerification(true);
+        setCodeValidated(true);
+        setValidatingCode(false);
+        return;
+      }
+      const linkParam = getParam("link");
+      if (linkParam) {
+        try {
+          const decodedLink = decodeURIComponent(linkParam);
+          const [linkCode, linkEmail] = decodedLink.split("/");
+          if (linkCode && linkEmail && linkCode.length === 6) {
+            setCode(linkCode);
+            setEmail(linkEmail);
+            setFromCodeVerification(false);
+            setPendingValidation({ email: linkEmail, code: linkCode });
+            return;
           }
+        } catch (error) {
         }
       }
-      return response;
-    });
-    this.log("Response interceptor configured");
-  }
-  /**
-   * Limpiar sesión completamente
-   */
-  clearSession() {
-    TokenStorage.clearTokens();
-    crudify2.logout();
-    this.log("Session cleared completely");
-  }
-  // Métodos privados
-  log(message, ...args) {
-    if (this.config.enableLogging) {
-      console.log(`[SessionManager] ${message}`, ...args);
-    }
-  }
-  formatError(errors) {
-    if (!errors) return "Unknown error";
-    if (typeof errors === "string") return errors;
-    if (typeof errors === "object") {
-      const errorMessages = Object.values(errors).flat();
-      return errorMessages.join(", ");
+      if (emailParam && codeParam) {
+        setEmail(emailParam);
+        setCode(codeParam);
+        setFromCodeVerification(false);
+        setPendingValidation({ email: emailParam, code: codeParam });
+        return;
+      }
     }
-    return "Authentication failed";
-  }
-};
-
-// src/hooks/useSession.ts
-function useSession(options = {}) {
-  const [state, setState] = useState6({
-    isAuthenticated: false,
-    isLoading: true,
-    isInitialized: false,
-    tokens: null,
-    error: null
-  });
-  const sessionManager = SessionManager.getInstance();
-  const initialize = useCallback(async () => {
-    try {
-      setState((prev) => ({ ...prev, isLoading: true, error: null }));
-      const config = {
-        autoRestore: options.autoRestore ?? true,
-        enableLogging: options.enableLogging ?? false,
-        onSessionExpired: () => {
-          setState((prev) => ({
-            ...prev,
-            isAuthenticated: false,
-            tokens: null,
-            error: "Session expired"
-          }));
-          options.onSessionExpired?.();
-        },
-        onSessionRestored: (tokens) => {
-          setState((prev) => ({
-            ...prev,
-            isAuthenticated: true,
-            tokens,
-            error: null
-          }));
-          options.onSessionRestored?.(tokens);
-        },
-        onLoginSuccess: (tokens) => {
-          setState((prev) => ({
-            ...prev,
-            isAuthenticated: true,
-            tokens,
-            error: null
-          }));
-        },
-        onLogout: () => {
-          setState((prev) => ({
-            ...prev,
-            isAuthenticated: false,
-            tokens: null,
-            error: null
-          }));
+    setErrors([t("resetPassword.invalidCode")]);
+    setValidatingCode(false);
+    setTimeout(() => onScreenChange?.("forgotPassword"), 3e3);
+  }, [searchParams, crudify6, t, onScreenChange]);
+  useEffect6(() => {
+    if (crudify6 && pendingValidation && !isValidating) {
+      setIsValidating(true);
+      const validateCode = async (emailToValidate, codeToValidate) => {
+        try {
+          const data = [
+            {
+              operation: "validatePasswordResetCode",
+              data: { email: emailToValidate, codePassword: codeToValidate }
+            }
+          ];
+          const response = await crudify6.transaction(data);
+          if (response.data && Array.isArray(response.data)) {
+            const validationResult = response.data[0];
+            if (validationResult && validationResult.response && validationResult.response.status === "OK") {
+              setCodeValidated(true);
+              return;
+            }
+          }
+          if (response.success) {
+            setCodeValidated(true);
+          } else {
+            const parsedErrors = handleCrudifyError(response);
+            const translatedErrors = parsedErrors.map(translateError);
+            setErrors(translatedErrors);
+            setTimeout(() => onScreenChange?.("forgotPassword"), 3e3);
+          }
+        } catch (error) {
+          const parsedErrors = handleCrudifyError(error);
+          const translatedErrors = parsedErrors.map(translateError);
+          setErrors(translatedErrors);
+          setTimeout(() => onScreenChange?.("forgotPassword"), 3e3);
+        } finally {
+          setValidatingCode(false);
+          setPendingValidation(null);
+          setIsValidating(false);
         }
       };
-      await sessionManager.initialize(config);
-      sessionManager.setupResponseInterceptor();
-      const isAuth = sessionManager.isAuthenticated();
-      const tokenInfo = sessionManager.getTokenInfo();
-      setState((prev) => ({
-        ...prev,
-        isAuthenticated: isAuth,
-        isInitialized: true,
-        isLoading: false,
-        tokens: tokenInfo.crudifyTokens.accessToken ? {
-          accessToken: tokenInfo.crudifyTokens.accessToken,
-          refreshToken: tokenInfo.crudifyTokens.refreshToken,
-          expiresAt: tokenInfo.crudifyTokens.expiresAt,
-          refreshExpiresAt: tokenInfo.crudifyTokens.refreshExpiresAt
-        } : null
-      }));
-    } catch (error) {
-      setState((prev) => ({
-        ...prev,
-        isLoading: false,
-        isInitialized: true,
-        error: error instanceof Error ? error.message : "Initialization failed"
-      }));
+      validateCode(pendingValidation.email, pendingValidation.code);
     }
-  }, [options.autoRestore, options.enableLogging, options.onSessionExpired, options.onSessionRestored]);
-  const login = useCallback(async (email, password) => {
-    setState((prev) => ({ ...prev, isLoading: true, error: null }));
-    try {
-      const result = await sessionManager.login(email, password);
-      if (result.success && result.tokens) {
-        setState((prev) => ({
-          ...prev,
-          isAuthenticated: true,
-          tokens: result.tokens,
-          isLoading: false,
-          error: null
-        }));
-      } else {
-        setState((prev) => ({
-          ...prev,
-          isAuthenticated: false,
-          tokens: null,
-          isLoading: false,
-          error: result.error || "Login failed"
-        }));
-      }
-      return result;
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : "Login failed";
-      setState((prev) => ({
-        ...prev,
-        isAuthenticated: false,
-        tokens: null,
-        isLoading: false,
-        error: errorMsg
-      }));
-      return {
-        success: false,
-        error: errorMsg
-      };
+  }, [crudify6, pendingValidation, t, onScreenChange]);
+  const validatePassword = (password) => {
+    if (password.length < 8) {
+      return t("resetPassword.passwordTooShort");
     }
-  }, [sessionManager]);
-  const logout = useCallback(async () => {
-    setState((prev) => ({ ...prev, isLoading: true }));
-    try {
-      await sessionManager.logout();
-      setState((prev) => ({
-        ...prev,
-        isAuthenticated: false,
-        tokens: null,
-        isLoading: false,
-        error: null
-      }));
-    } catch (error) {
-      setState((prev) => ({
-        ...prev,
-        isAuthenticated: false,
-        tokens: null,
-        isLoading: false,
-        error: error instanceof Error ? error.message : "Logout error"
-      }));
+    return null;
+  };
+  const handleSubmit = async () => {
+    if (loading || !crudify6) return;
+    setErrors([]);
+    setHelperTextNewPassword(null);
+    setHelperTextConfirmPassword(null);
+    let hasErrors = false;
+    if (!newPassword) {
+      setHelperTextNewPassword(t("resetPassword.newPasswordRequired"));
+      hasErrors = true;
+    } else {
+      const passwordError = validatePassword(newPassword);
+      if (passwordError) {
+        setHelperTextNewPassword(passwordError);
+        hasErrors = true;
+      }
     }
-  }, [sessionManager]);
-  const refreshTokens = useCallback(async () => {
+    if (!confirmPassword) {
+      setHelperTextConfirmPassword(t("resetPassword.confirmPasswordRequired"));
+      hasErrors = true;
+    } else if (newPassword !== confirmPassword) {
+      setHelperTextConfirmPassword(t("resetPassword.passwordsDoNotMatch"));
+      hasErrors = true;
+    }
+    if (hasErrors) return;
+    setLoading(true);
     try {
-      const success = await sessionManager.refreshTokens();
-      if (success) {
-        const tokenInfo = sessionManager.getTokenInfo();
-        setState((prev) => ({
-          ...prev,
-          tokens: tokenInfo.crudifyTokens.accessToken ? {
-            accessToken: tokenInfo.crudifyTokens.accessToken,
-            refreshToken: tokenInfo.crudifyTokens.refreshToken,
-            expiresAt: tokenInfo.crudifyTokens.expiresAt,
-            refreshExpiresAt: tokenInfo.crudifyTokens.refreshExpiresAt
-          } : null,
-          error: null
-        }));
+      const data = [
+        {
+          operation: "validateAndResetPassword",
+          data: { email, codePassword: code, newPassword }
+        }
+      ];
+      const response = await crudify6.transaction(data);
+      if (response.success) {
+        setErrors([]);
+        setTimeout(() => {
+          onResetSuccess?.();
+        }, 1e3);
       } else {
-        setState((prev) => ({
-          ...prev,
-          isAuthenticated: false,
-          tokens: null,
-          error: "Token refresh failed"
-        }));
+        const parsedErrors = handleCrudifyError(response);
+        const translatedErrors = parsedErrors.map(translateError);
+        setErrors(translatedErrors);
       }
-      return success;
     } catch (error) {
-      setState((prev) => ({
-        ...prev,
-        isAuthenticated: false,
-        tokens: null,
-        error: error instanceof Error ? error.message : "Token refresh failed"
-      }));
-      return false;
+      const parsedErrors = handleCrudifyError(error);
+      const translatedErrors = parsedErrors.map(translateError);
+      setErrors(translatedErrors);
+      if (onError) {
+        onError(translatedErrors.join(", "));
+      }
     }
-  }, [sessionManager]);
-  const clearError = useCallback(() => {
-    setState((prev) => ({ ...prev, error: null }));
-  }, []);
-  const getTokenInfo = useCallback(() => {
-    return sessionManager.getTokenInfo();
-  }, [sessionManager]);
-  useEffect7(() => {
-    initialize();
-  }, [initialize]);
-  return {
-    // Estado
-    ...state,
-    // Acciones
-    login,
-    logout,
-    refreshTokens,
-    clearError,
-    getTokenInfo,
-    // Utilidades
-    isExpiringSoon: state.tokens ? state.tokens.expiresAt - Date.now() < 5 * 60 * 1e3 : false,
-    // 5 minutos
-    expiresIn: state.tokens ? Math.max(0, state.tokens.expiresAt - Date.now()) : 0,
-    refreshExpiresIn: state.tokens ? Math.max(0, state.tokens.refreshExpiresAt - Date.now()) : 0
+    setLoading(false);
   };
-}
-
-// src/utils/jwtUtils.ts
-var decodeJwtSafely = (token) => {
-  try {
-    const parts = token.split(".");
-    if (parts.length !== 3) {
-      console.warn("Invalid JWT format: token must have 3 parts");
-      return null;
-    }
-    const payload = parts[1];
-    const paddedPayload = payload + "=".repeat((4 - payload.length % 4) % 4);
-    const decodedPayload = JSON.parse(atob(paddedPayload));
-    return decodedPayload;
-  } catch (error) {
-    console.warn("Failed to decode JWT token:", error);
-    return null;
-  }
-};
-var getCurrentUserEmail = () => {
-  try {
-    let token = null;
-    token = sessionStorage.getItem("authToken");
-    console.log("\u{1F50D} getCurrentUserEmail - authToken:", token ? `${token.substring(0, 20)}...` : null);
-    if (!token) {
-      token = sessionStorage.getItem("token");
-      console.log("\u{1F50D} getCurrentUserEmail - token:", token ? `${token.substring(0, 20)}...` : null);
-    }
-    if (!token) {
-      token = localStorage.getItem("authToken") || localStorage.getItem("token");
-      console.log("\u{1F50D} getCurrentUserEmail - localStorage:", token ? `${token.substring(0, 20)}...` : null);
-    }
-    if (!token) {
-      console.warn("\u{1F50D} getCurrentUserEmail - No token found in any storage");
-      return null;
-    }
-    const payload = decodeJwtSafely(token);
-    if (!payload) {
-      console.warn("\u{1F50D} getCurrentUserEmail - Failed to decode token");
-      return null;
+  const handleBack = () => {
+    if (fromCodeVerification) {
+      onScreenChange?.("checkCode", { email });
+    } else {
+      onScreenChange?.("forgotPassword");
     }
-    const email = payload.email || payload["cognito:username"] || null;
-    console.log("\u{1F50D} getCurrentUserEmail - Extracted email:", email);
-    return email;
-  } catch (error) {
-    console.warn("Failed to get current user email:", error);
-    return null;
+  };
+  if (validatingCode) {
+    return /* @__PURE__ */ jsx7(Box3, { sx: { display: "flex", justifyContent: "center", alignItems: "center", minHeight: "300px" }, children: /* @__PURE__ */ jsx7(CircularProgress3, {}) });
   }
-};
-var isTokenExpired = (token) => {
-  try {
-    const payload = decodeJwtSafely(token);
-    if (!payload || !payload.exp) return true;
-    const currentTime = Math.floor(Date.now() / 1e3);
-    return payload.exp < currentTime;
-  } catch {
-    return true;
+  if (!codeValidated) {
+    return /* @__PURE__ */ jsx7(Box3, { children: errors.length > 0 && errors.map((error, index) => /* @__PURE__ */ jsx7(Alert3, { variant: "filled", sx: { mt: 2 }, severity: "error", children: error }, index)) });
   }
+  return /* @__PURE__ */ jsxs4(Fragment4, { children: [
+    /* @__PURE__ */ jsxs4(Box3, { component: "form", noValidate: true, sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2 }, children: [
+      /* @__PURE__ */ jsxs4(Box3, { sx: { mb: 2 }, children: [
+        /* @__PURE__ */ jsx7(Typography3, { variant: "h5", component: "h1", sx: { mb: 1, fontWeight: 600 }, children: t("resetPassword.title") }),
+        /* @__PURE__ */ jsx7(Typography3, { variant: "body2", sx: { color: "grey.600" }, children: t("resetPassword.instructions") })
+      ] }),
+      /* @__PURE__ */ jsxs4(Box3, { sx: { mb: 1 }, children: [
+        /* @__PURE__ */ jsx7(
+          Typography3,
+          {
+            variant: "body2",
+            component: "label",
+            htmlFor: "newPassword",
+            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+            children: t("resetPassword.newPasswordLabel")
+          }
+        ),
+        /* @__PURE__ */ jsx7(
+          TextField3,
+          {
+            fullWidth: true,
+            id: "newPassword",
+            name: "newPassword",
+            type: "password",
+            value: newPassword,
+            disabled: loading,
+            onChange: (e) => setNewPassword(e.target.value),
+            error: !!helperTextNewPassword,
+            helperText: helperTextNewPassword,
+            autoComplete: "new-password",
+            placeholder: t("resetPassword.newPasswordPlaceholder"),
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs4(Box3, { sx: { mb: 1 }, children: [
+        /* @__PURE__ */ jsx7(
+          Typography3,
+          {
+            variant: "body2",
+            component: "label",
+            htmlFor: "confirmPassword",
+            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+            children: t("resetPassword.confirmPasswordLabel")
+          }
+        ),
+        /* @__PURE__ */ jsx7(
+          TextField3,
+          {
+            fullWidth: true,
+            id: "confirmPassword",
+            name: "confirmPassword",
+            type: "password",
+            value: confirmPassword,
+            disabled: loading,
+            onChange: (e) => setConfirmPassword(e.target.value),
+            error: !!helperTextConfirmPassword,
+            helperText: helperTextConfirmPassword,
+            autoComplete: "new-password",
+            placeholder: t("resetPassword.confirmPasswordPlaceholder"),
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx7(Button3, { disabled: loading, type: "button", onClick: handleSubmit, fullWidth: true, variant: "contained", color: "primary", sx: { mt: 2, mb: 2 }, children: loading ? /* @__PURE__ */ jsx7(CircularProgress3, { size: 20 }) : t("resetPassword.resetPasswordButton") }),
+      /* @__PURE__ */ jsx7(Box3, { sx: { display: "flex", justifyContent: "center", alignItems: "center" }, children: /* @__PURE__ */ jsx7(Link3, { sx: { cursor: "pointer" }, onClick: handleBack, variant: "body2", color: "secondary", children: t("common.back") }) })
+    ] }),
+    /* @__PURE__ */ jsx7(Box3, { children: errors.length > 0 && errors.map((error, index) => /* @__PURE__ */ jsx7(Alert3, { variant: "filled", sx: { mt: 2 }, severity: "error", children: error }, index)) })
+  ] });
 };
+var ResetPasswordForm_default = ResetPasswordForm;
 
-// src/providers/SessionProvider.tsx
-import { Fragment as Fragment6, jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
-var SessionContext = createContext4(void 0);
-function SessionProvider({ children, options = {}, config: propConfig }) {
-  const sessionHook = useSession(options);
-  const resolvedConfig = useMemo2(() => {
-    let publicApiKey;
-    let env;
-    let appName;
-    let loginActions;
-    let logo;
-    let colors;
-    let configSource = "unknown";
-    if (propConfig?.publicApiKey) {
-      publicApiKey = propConfig.publicApiKey;
-      configSource = "props";
-    }
-    if (propConfig?.env) {
-      env = propConfig.env;
-    }
-    if (propConfig?.appName) {
-      appName = propConfig.appName;
-    }
-    if (propConfig?.loginActions) {
-      loginActions = propConfig.loginActions;
+// src/components/CrudifyLogin/Forms/CheckCodeForm.tsx
+import { useState as useState6, useEffect as useEffect7 } from "react";
+import { Typography as Typography4, TextField as TextField4, Button as Button4, Box as Box4, CircularProgress as CircularProgress4, Alert as Alert4, Link as Link4 } from "@mui/material";
+import { Fragment as Fragment5, jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+var CheckCodeForm = ({ onScreenChange, onError, searchParams }) => {
+  const { crudify: crudify6 } = useCrudify();
+  const [code, setCode] = useState6("");
+  const [loading, setLoading] = useState6(false);
+  const [errors, setErrors] = useState6([]);
+  const [helperTextCode, setHelperTextCode] = useState6(null);
+  const [email, setEmail] = useState6("");
+  const { t } = useTranslation();
+  const getParam = (key) => {
+    if (!searchParams) return null;
+    if (searchParams instanceof URLSearchParams) {
+      return searchParams.get(key);
     }
-    if (propConfig?.logo) {
-      logo = propConfig.logo;
+    return searchParams[key] || null;
+  };
+  const translateError = (parsedError) => {
+    const possibleKeys = [
+      `errors.auth.${parsedError.code}`,
+      `errors.data.${parsedError.code}`,
+      `errors.system.${parsedError.code}`,
+      `errors.${parsedError.code}`,
+      `checkCode.${parsedError.code.toLowerCase()}`
+    ];
+    for (const key of possibleKeys) {
+      const translated = t(key);
+      if (translated !== key) {
+        return translated;
+      }
     }
-    if (propConfig?.colors) {
-      colors = propConfig.colors;
+    return parsedError.message || t("error.unknown");
+  };
+  useEffect7(() => {
+    const emailParam = getParam("email");
+    if (emailParam) {
+      setEmail(emailParam);
+    } else {
+      onScreenChange?.("forgotPassword");
     }
-    if (!publicApiKey) {
-      const cookieApiKey = getCookie("publicApiKey");
-      const cookieEnv = getCookie("environment");
-      const cookieAppName = getCookie("appName");
-      const cookieLoginActions = getCookie("loginActions");
-      if (cookieApiKey) {
-        publicApiKey = cookieApiKey;
-        configSource = "cookies";
-      }
-      if (cookieEnv && ["dev", "stg", "prod"].includes(cookieEnv)) {
-        env = cookieEnv;
-      }
-      if (cookieAppName) {
-        appName = cookieAppName;
-      }
-      if (cookieLoginActions) {
-        loginActions = cookieLoginActions.split(",").map((s) => s.trim()).filter(Boolean);
-      }
+  }, [searchParams, onScreenChange]);
+  const handleSubmit = async () => {
+    if (loading || !crudify6) return;
+    setErrors([]);
+    setHelperTextCode(null);
+    if (!code) {
+      setHelperTextCode(t("checkCode.codeRequired"));
+      return;
     }
-    console.log("\u{1F50D} SessionProvider - Configuration Detection:");
-    console.log("   - Config source:", configSource);
-    console.log("   - PublicApiKey:", publicApiKey ? publicApiKey.substring(0, 15) + "..." : "undefined");
-    console.log("   - Environment:", env);
-    console.log("   - App name:", appName);
-    console.log("   - Login actions:", loginActions);
-    return {
-      publicApiKey,
-      env,
-      appName,
-      loginActions,
-      logo,
-      colors
-    };
-  }, [propConfig]);
-  const sessionData = useMemo2(() => {
-    if (!sessionHook.tokens?.accessToken || !sessionHook.isAuthenticated) {
-      return null;
+    if (code.length !== 6) {
+      setHelperTextCode(t("checkCode.codeRequired"));
+      return;
     }
+    setLoading(true);
     try {
-      const decoded = decodeJwtSafely(sessionHook.tokens.accessToken);
-      if (decoded && decoded.sub && decoded.email && decoded.subscriber) {
-        const result = {
-          _id: decoded.sub,
-          email: decoded.email,
-          subscriberKey: decoded.subscriber
-        };
-        Object.keys(decoded).forEach((key) => {
-          if (!["sub", "email", "subscriber"].includes(key)) {
-            result[key] = decoded[key];
-          }
-        });
-        return result;
+      const data = [
+        {
+          operation: "validatePasswordResetCode",
+          data: { email, codePassword: code }
+        }
+      ];
+      const response = await crudify6.transaction(data);
+      if (response.success) {
+        onScreenChange?.("resetPassword", { email, code, fromCodeVerification: "true" });
+      } else {
+        const parsedErrors = handleCrudifyError(response);
+        const translatedErrors = parsedErrors.map(translateError);
+        setErrors(translatedErrors);
+        setLoading(false);
       }
     } catch (error) {
-      console.error("Error decoding JWT token for sessionData:", error);
+      const parsedErrors = handleCrudifyError(error);
+      const translatedErrors = parsedErrors.map(translateError);
+      setErrors(translatedErrors);
+      setLoading(false);
+      if (onError) {
+        onError(translatedErrors.join(", "));
+      }
     }
-    return null;
-  }, [sessionHook.tokens?.accessToken, sessionHook.isAuthenticated]);
-  const contextValue = {
-    ...sessionHook,
-    sessionData,
-    config: resolvedConfig
   };
-  return /* @__PURE__ */ jsx9(SessionContext.Provider, { value: contextValue, children });
-}
-function useSessionContext() {
-  const context = useContext4(SessionContext);
-  if (context === void 0) {
-    throw new Error("useSessionContext must be used within a SessionProvider");
+  const handleBack = () => {
+    onScreenChange?.("forgotPassword");
+  };
+  const handleCodeChange = (event) => {
+    const value = event.target.value.replace(/\D/g, "").slice(0, 6);
+    setCode(value);
+  };
+  return /* @__PURE__ */ jsxs5(Fragment5, { children: [
+    /* @__PURE__ */ jsxs5(Box4, { component: "form", noValidate: true, sx: { width: "100%", display: "flex", flexDirection: "column", gap: 2 }, children: [
+      /* @__PURE__ */ jsxs5(Box4, { sx: { mb: 2 }, children: [
+        /* @__PURE__ */ jsx8(Typography4, { variant: "h5", component: "h1", sx: { mb: 1, fontWeight: 600 }, children: t("checkCode.title") }),
+        /* @__PURE__ */ jsx8(Typography4, { variant: "body2", sx: { color: "grey.600" }, children: t("checkCode.instructions") })
+      ] }),
+      /* @__PURE__ */ jsxs5(Box4, { sx: { mb: 1 }, children: [
+        /* @__PURE__ */ jsx8(
+          Typography4,
+          {
+            variant: "body2",
+            component: "label",
+            htmlFor: "code",
+            sx: { display: "block", fontWeight: 500, color: "grey.700", mb: 0.5 },
+            children: t("checkCode.codeLabel")
+          }
+        ),
+        /* @__PURE__ */ jsx8(
+          TextField4,
+          {
+            fullWidth: true,
+            id: "code",
+            name: "code",
+            type: "text",
+            value: code,
+            disabled: loading,
+            onChange: handleCodeChange,
+            error: !!helperTextCode,
+            helperText: helperTextCode,
+            placeholder: t("checkCode.codePlaceholder"),
+            inputProps: {
+              maxLength: 6,
+              style: { textAlign: "center", fontSize: "1.5rem", letterSpacing: "0.4rem" }
+            },
+            required: true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx8(
+        Button4,
+        {
+          disabled: loading || code.length !== 6,
+          type: "button",
+          onClick: handleSubmit,
+          fullWidth: true,
+          variant: "contained",
+          color: "primary",
+          sx: { mt: 2, mb: 2 },
+          children: loading ? /* @__PURE__ */ jsx8(CircularProgress4, { size: 20 }) : t("checkCode.verifyButton")
+        }
+      ),
+      /* @__PURE__ */ jsx8(Box4, { sx: { display: "flex", justifyContent: "center", alignItems: "center" }, children: /* @__PURE__ */ jsx8(Link4, { sx: { cursor: "pointer" }, onClick: handleBack, variant: "body2", color: "secondary", children: t("common.back") }) })
+    ] }),
+    /* @__PURE__ */ jsx8(Box4, { children: errors.length > 0 && errors.map((error, index) => /* @__PURE__ */ jsx8(Alert4, { sx: { mt: 2 }, severity: "error", children: error }, index)) })
+  ] });
+};
+var CheckCodeForm_default = CheckCodeForm;
+
+// src/components/CrudifyLogin/components/CrudifyInitializer.tsx
+import { Box as Box5, CircularProgress as CircularProgress5, Alert as Alert5, Typography as Typography5 } from "@mui/material";
+import { Fragment as Fragment6, jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+var CrudifyInitializer = ({ children, fallback }) => {
+  const { isLoading, error, isInitialized } = useCrudify();
+  const { t } = useTranslation();
+  if (isLoading) {
+    return fallback || /* @__PURE__ */ jsxs6(
+      Box5,
+      {
+        sx: {
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "center",
+          justifyContent: "center",
+          minHeight: "200px",
+          gap: 2
+        },
+        children: [
+          /* @__PURE__ */ jsx9(CircularProgress5, {}),
+          /* @__PURE__ */ jsx9(Typography5, { variant: "body2", color: "text.secondary", children: t("login.initializing") !== "login.initializing" ? t("login.initializing") : "Initializing..." })
+        ]
+      }
+    );
   }
-  return context;
-}
-function ProtectedRoute({ children, fallback = /* @__PURE__ */ jsx9("div", { children: "Please log in to access this content" }), redirectTo }) {
-  const { isAuthenticated, isLoading, isInitialized } = useSessionContext();
-  if (!isInitialized || isLoading) {
-    return /* @__PURE__ */ jsx9("div", { children: "Loading..." });
+  if (error) {
+    return /* @__PURE__ */ jsx9(Alert5, { severity: "error", sx: { mt: 2 }, children: /* @__PURE__ */ jsxs6(Typography5, { variant: "body2", children: [
+      t("login.initializationError") !== "login.initializationError" ? t("login.initializationError") : "Initialization error",
+      ":",
+      " ",
+      error
+    ] }) });
   }
-  if (!isAuthenticated) {
-    if (redirectTo) {
-      redirectTo();
-      return null;
-    }
-    return /* @__PURE__ */ jsx9(Fragment6, { children: fallback });
+  if (!isInitialized) {
+    return /* @__PURE__ */ jsx9(Alert5, { severity: "warning", sx: { mt: 2 }, children: /* @__PURE__ */ jsx9(Typography5, { variant: "body2", children: t("login.notInitialized") !== "login.notInitialized" ? t("login.notInitialized") : "System not initialized" }) });
   }
   return /* @__PURE__ */ jsx9(Fragment6, { children });
-}
-function SessionDebugInfo() {
-  const session = useSessionContext();
-  if (!session.isInitialized) {
-    return /* @__PURE__ */ jsx9("div", { children: "Session not initialized" });
-  }
-  return /* @__PURE__ */ jsxs6(
-    "div",
-    {
-      style: {
-        padding: "10px",
-        margin: "10px",
-        border: "1px solid #ccc",
-        borderRadius: "4px",
-        fontSize: "12px",
-        fontFamily: "monospace"
-      },
-      children: [
-        /* @__PURE__ */ jsx9("h4", { children: "Session Debug Info" }),
-        /* @__PURE__ */ jsxs6("div", { children: [
-          /* @__PURE__ */ jsx9("strong", { children: "Authenticated:" }),
-          " ",
-          session.isAuthenticated ? "Yes" : "No"
-        ] }),
-        /* @__PURE__ */ jsxs6("div", { children: [
-          /* @__PURE__ */ jsx9("strong", { children: "Loading:" }),
-          " ",
-          session.isLoading ? "Yes" : "No"
-        ] }),
-        /* @__PURE__ */ jsxs6("div", { children: [
-          /* @__PURE__ */ jsx9("strong", { children: "Error:" }),
-          " ",
-          session.error || "None"
-        ] }),
-        session.tokens && /* @__PURE__ */ jsxs6(Fragment6, { children: [
-          /* @__PURE__ */ jsxs6("div", { children: [
-            /* @__PURE__ */ jsx9("strong", { children: "Access Token:" }),
-            " ",
-            session.tokens.accessToken.substring(0, 20),
-            "..."
-          ] }),
-          /* @__PURE__ */ jsxs6("div", { children: [
-            /* @__PURE__ */ jsx9("strong", { children: "Refresh Token:" }),
-            " ",
-            session.tokens.refreshToken.substring(0, 20),
-            "..."
-          ] }),
-          /* @__PURE__ */ jsxs6("div", { children: [
-            /* @__PURE__ */ jsx9("strong", { children: "Access Expires In:" }),
-            " ",
-            Math.round(session.expiresIn / 1e3 / 60),
-            " minutes"
-          ] }),
-          /* @__PURE__ */ jsxs6("div", { children: [
-            /* @__PURE__ */ jsx9("strong", { children: "Refresh Expires In:" }),
-            " ",
-            Math.round(session.refreshExpiresIn / 1e3 / 60 / 60),
-            " hours"
-          ] }),
-          /* @__PURE__ */ jsxs6("div", { children: [
-            /* @__PURE__ */ jsx9("strong", { children: "Expiring Soon:" }),
-            " ",
-            session.isExpiringSoon ? "Yes" : "No"
-          ] })
-        ] })
-      ]
-    }
-  );
-}
+};
 
 // src/components/CrudifyLogin/index.tsx
 import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";