@nocios/crudify-ui 1.2.34 → 1.3.0

package/dist/index.js

@@ -1289,9 +1289,16 @@ __export(index_exports, {
   CrudifyLogin: () => CrudifyLogin_default,
   ERROR_CODES: () => ERROR_CODES,
   ERROR_SEVERITY_MAP: () => ERROR_SEVERITY_MAP,
+  LoginComponent: () => LoginComponent,
+  ProtectedRoute: () => ProtectedRoute,
+  SessionDebugInfo: () => SessionDebugInfo,
+  SessionManager: () => SessionManager,
+  SessionProvider: () => SessionProvider,
+  SessionStatus: () => SessionStatus,
+  TokenStorage: () => TokenStorage,
   UserProfileDisplay: () => UserProfileDisplay_default,
   configurationManager: () => configurationManager,
-  crudify: () => import_crudify_browser8.default,
+  crudify: () => import_crudify_browser9.default,
   crudifyInitializer: () => crudifyInitializer,
   decodeJwtSafely: () => decodeJwtSafely,
   getCookie: () => getCookie,
@@ -1314,10 +1321,12 @@ __export(index_exports, {
   useCrudifyInstance: () => useCrudifyInstance,
   useCrudifyLogin: () => useCrudifyLogin,
   useCrudifyUser: () => useCrudifyUser,
+  useSession: () => useSession,
+  useSessionContext: () => useSessionContext,
   useUserProfile: () => useUserProfile
 });
 module.exports = __toCommonJS(index_exports);
-var import_crudify_browser8 = __toESM(require("@nocios/crudify-browser"));
+var import_crudify_browser9 = __toESM(require("@nocios/crudify-browser"));
 __reExport(index_exports, require("@nocios/crudify-browser"), module.exports);
 
 // src/components/CrudifyLogin/index.tsx
@@ -2009,7 +2018,7 @@ var useCrudifyAuth = () => {
 // src/components/CrudifyLogin/Forms/LoginForm.tsx
 var import_jsx_runtime5 = require("react/jsx-runtime");
 var LoginForm = ({ onScreenChange, onExternalNavigate, onLoginSuccess, onError, redirectUrl = "/" }) => {
-  const { crudify: crudify8 } = useCrudify();
+  const { crudify: crudify9 } = useCrudify();
   const { state, updateFormData, setFieldError, clearErrors, setLoading } = useLoginState();
   const { setToken } = useCrudifyAuth();
   const { t } = useTranslation();
@@ -2061,10 +2070,10 @@ var LoginForm = ({ onScreenChange, onExternalNavigate, onLoginSuccess, onError,
     clearErrors();
     setLoading(true);
     try {
-      if (!crudify8) {
+      if (!crudify9) {
         throw new Error("Crudify not initialized");
       }
-      const response = await crudify8.login(state.formData.username, state.formData.password);
+      const response = await crudify9.login(state.formData.username, state.formData.password);
       setLoading(false);
       if (response.success) {
         console.log("\u{1F510} LoginForm - Login successful, setting tokens");
@@ -2227,7 +2236,7 @@ var import_react7 = require("react");
 var import_material2 = require("@mui/material");
 var import_jsx_runtime6 = require("react/jsx-runtime");
 var ForgotPasswordForm = ({ onScreenChange, onError }) => {
-  const { crudify: crudify8 } = useCrudify();
+  const { crudify: crudify9 } = useCrudify();
   const [email, setEmail] = (0, import_react7.useState)("");
   const [loading, setLoading] = (0, import_react7.useState)(false);
   const [errors, setErrors] = (0, import_react7.useState)([]);
@@ -2256,7 +2265,7 @@ var ForgotPasswordForm = ({ onScreenChange, onError }) => {
     return emailRegex.test(email2);
   };
   const handleSubmit = async () => {
-    if (loading || !crudify8) return;
+    if (loading || !crudify9) return;
     setErrors([]);
     setHelperTextEmail(null);
     if (!email) {
@@ -2270,7 +2279,7 @@ var ForgotPasswordForm = ({ onScreenChange, onError }) => {
     setLoading(true);
     try {
       const data = [{ operation: "requestPasswordReset", data: { email } }];
-      const response = await crudify8.transaction(data);
+      const response = await crudify9.transaction(data);
       if (response.success) {
         if (response.data && response.data.existingCodeValid) {
           setCodeAlreadyExists(true);
@@ -2373,7 +2382,7 @@ var import_react8 = require("react");
 var import_material3 = require("@mui/material");
 var import_jsx_runtime7 = require("react/jsx-runtime");
 var ResetPasswordForm = ({ onScreenChange, onError, searchParams, onResetSuccess }) => {
-  const { crudify: crudify8 } = useCrudify();
+  const { crudify: crudify9 } = useCrudify();
   const [newPassword, setNewPassword] = (0, import_react8.useState)("");
   const [confirmPassword, setConfirmPassword] = (0, import_react8.useState)("");
   const [loading, setLoading] = (0, import_react8.useState)(false);
@@ -2453,9 +2462,9 @@ var ResetPasswordForm = ({ onScreenChange, onError, searchParams, onResetSuccess
     setErrors([t("resetPassword.invalidCode")]);
     setValidatingCode(false);
     setTimeout(() => onScreenChange?.("forgotPassword"), 3e3);
-  }, [searchParams, crudify8, t, onScreenChange]);
+  }, [searchParams, crudify9, t, onScreenChange]);
   (0, import_react8.useEffect)(() => {
-    if (crudify8 && pendingValidation && !isValidating) {
+    if (crudify9 && pendingValidation && !isValidating) {
       setIsValidating(true);
       const validateCode = async (emailToValidate, codeToValidate) => {
         try {
@@ -2465,7 +2474,7 @@ var ResetPasswordForm = ({ onScreenChange, onError, searchParams, onResetSuccess
               data: { email: emailToValidate, codePassword: codeToValidate }
             }
           ];
-          const response = await crudify8.transaction(data);
+          const response = await crudify9.transaction(data);
           if (response.data && Array.isArray(response.data)) {
             const validationResult = response.data[0];
             if (validationResult && validationResult.response && validationResult.response.status === "OK") {
@@ -2494,7 +2503,7 @@ var ResetPasswordForm = ({ onScreenChange, onError, searchParams, onResetSuccess
       };
       validateCode(pendingValidation.email, pendingValidation.code);
     }
-  }, [crudify8, pendingValidation, t, onScreenChange]);
+  }, [crudify9, pendingValidation, t, onScreenChange]);
   const validatePassword = (password) => {
     if (password.length < 8) {
       return t("resetPassword.passwordTooShort");
@@ -2502,7 +2511,7 @@ var ResetPasswordForm = ({ onScreenChange, onError, searchParams, onResetSuccess
     return null;
   };
   const handleSubmit = async () => {
-    if (loading || !crudify8) return;
+    if (loading || !crudify9) return;
     setErrors([]);
     setHelperTextNewPassword(null);
     setHelperTextConfirmPassword(null);
@@ -2533,7 +2542,7 @@ var ResetPasswordForm = ({ onScreenChange, onError, searchParams, onResetSuccess
           data: { email, codePassword: code, newPassword }
         }
       ];
-      const response = await crudify8.transaction(data);
+      const response = await crudify9.transaction(data);
       if (response.success) {
         setErrors([]);
         setTimeout(() => {
@@ -2644,7 +2653,7 @@ var import_react9 = require("react");
 var import_material4 = require("@mui/material");
 var import_jsx_runtime8 = require("react/jsx-runtime");
 var CheckCodeForm = ({ onScreenChange, onError, searchParams }) => {
-  const { crudify: crudify8 } = useCrudify();
+  const { crudify: crudify9 } = useCrudify();
   const [code, setCode] = (0, import_react9.useState)("");
   const [loading, setLoading] = (0, import_react9.useState)(false);
   const [errors, setErrors] = (0, import_react9.useState)([]);
@@ -2683,7 +2692,7 @@ var CheckCodeForm = ({ onScreenChange, onError, searchParams }) => {
     }
   }, [searchParams, onScreenChange]);
   const handleSubmit = async () => {
-    if (loading || !crudify8) return;
+    if (loading || !crudify9) return;
     setErrors([]);
     setHelperTextCode(null);
     if (!code) {
@@ -2702,7 +2711,7 @@ var CheckCodeForm = ({ onScreenChange, onError, searchParams }) => {
           data: { email, codePassword: code }
         }
       ];
-      const response = await crudify8.transaction(data);
+      const response = await crudify9.transaction(data);
       if (response.success) {
         onScreenChange?.("resetPassword", { email, code, fromCodeVerification: "true" });
       } else {
@@ -3699,12 +3708,18 @@ var useCrudifyInstance = () => {
     }
   }, [isReady, waitForReady]);
   const ensureTokenSync = (0, import_react15.useCallback)(async () => {
+    console.log("\u{1F504} useCrudifyInstance - ensureTokenSync: Starting token sync check");
     const { tokenManager: tokenManager2 } = await Promise.resolve().then(() => (init_TokenManager(), TokenManager_exports));
     const tmToken = tokenManager2.getToken();
     const crudifyToken = import_crudify_browser7.default.getToken?.();
+    console.log("   - TokenManager token in sync check:", tmToken ? `${tmToken.substring(0, 20)}...` : "null");
+    console.log("   - crudify token in sync check:", crudifyToken ? `${crudifyToken.substring(0, 20)}...` : "null");
     if (tmToken && tmToken !== crudifyToken) {
       console.log("\u{1F504} useCrudifyInstance - Forcing token sync for authenticated operation");
       import_crudify_browser7.default.setToken(tmToken);
+      console.log("   - crudify token after sync:", import_crudify_browser7.default.getToken?.() ? `${import_crudify_browser7.default.getToken?.()?.substring(0, 20)}...` : "null");
+    } else {
+      console.log("\u{1F504} useCrudifyInstance - No token sync needed, tokens match or no token");
     }
   }, []);
   const getStructure = (0, import_react15.useCallback)(async (options) => {
@@ -3869,12 +3884,839 @@ init_CrudifyDataProvider();
 init_jwtUtils();
 init_cookies();
 init_secureStorage();
+
+// src/core/SessionManager.ts
+var import_crudify_browser8 = __toESM(require("@nocios/crudify-browser"));
+
+// src/utils/tokenStorage.ts
+var import_crypto_js2 = __toESM(require("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;
+    }
+  }
+  /**
+   * 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;
+    }
+    return window[_TokenStorage.storageType];
+  }
+  /**
+   * Encriptar datos sensibles
+   */
+  static encrypt(data) {
+    try {
+      return import_crypto_js2.default.AES.encrypt(data, _TokenStorage.ENCRYPTION_KEY).toString();
+    } catch (error) {
+      console.error("Crudify: Encryption failed", error);
+      return data;
+    }
+  }
+  /**
+   * Desencriptar datos
+   */
+  static decrypt(encryptedData) {
+    try {
+      const bytes = import_crypto_js2.default.AES.decrypt(encryptedData, _TokenStorage.ENCRYPTION_KEY);
+      const decrypted = bytes.toString(import_crypto_js2.default.enc.Utf8);
+      return decrypted || encryptedData;
+    } catch (error) {
+      console.error("Crudify: Decryption failed", error);
+      return encryptedData;
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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 {
+        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 {
+      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");
+      return;
+    }
+    _TokenStorage.saveTokens({
+      ...existingTokens,
+      accessToken: newAccessToken,
+      expiresAt: newExpiresAt
+    });
+  }
+};
+_TokenStorage.TOKEN_KEY = "crudify_tokens";
+_TokenStorage.ENCRYPTION_KEY = "crudify_secure_key_v1";
+_TokenStorage.storageType = "localStorage";
+var TokenStorage = _TokenStorage;
+
+// 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;
+    }
+    this.config = {
+      storageType: "localStorage",
+      autoRestore: true,
+      enableLogging: false,
+      ...config
+    };
+    TokenStorage.setStorageType(this.config.storageType || "localStorage");
+    if (this.config.enableLogging) {
+    }
+    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 {
+      this.log("Attempting login...");
+      const response = await import_crudify_browser8.default.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) {
+      this.log("Login error:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Logout con limpieza de tokens
+   */
+  async logout() {
+    try {
+      this.log("Logging out...");
+      await import_crudify_browser8.default.logout();
+      TokenStorage.clearTokens();
+      this.log("Logout successful");
+      this.config.onLogout?.();
+    } catch (error) {
+      this.log("Logout error:", error);
+      TokenStorage.clearTokens();
+    }
+  }
+  /**
+   * 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;
+      }
+      import_crudify_browser8.default.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;
+    }
+  }
+  /**
+   * Verificar si el usuario está autenticado
+   */
+  isAuthenticated() {
+    return import_crudify_browser8.default.isLogin() || TokenStorage.hasValidTokens();
+  }
+  /**
+   * Obtener información de tokens actuales
+   */
+  getTokenInfo() {
+    const crudifyTokens = import_crudify_browser8.default.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 import_crudify_browser8.default.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;
+    }
+  }
+  /**
+   * Configurar interceptor de respuesta para manejo automático de errores
+   */
+  setupResponseInterceptor() {
+    import_crudify_browser8.default.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 response;
+    });
+    this.log("Response interceptor configured");
+  }
+  /**
+   * Limpiar sesión completamente
+   */
+  clearSession() {
+    TokenStorage.clearTokens();
+    import_crudify_browser8.default.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(", ");
+    }
+    return "Authentication failed";
+  }
+};
+
+// src/hooks/useSession.ts
+var import_react16 = require("react");
+function useSession(options = {}) {
+  const [state, setState] = (0, import_react16.useState)({
+    isAuthenticated: false,
+    isLoading: true,
+    isInitialized: false,
+    tokens: null,
+    error: null
+  });
+  const sessionManager = SessionManager.getInstance();
+  const initialize = (0, import_react16.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
+          }));
+        }
+      };
+      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 = (0, import_react16.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
+      };
+    }
+  }, [sessionManager]);
+  const logout = (0, import_react16.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 = (0, import_react16.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;
+    }
+  }, [sessionManager]);
+  const clearError = (0, import_react16.useCallback)(() => {
+    setState((prev) => ({ ...prev, error: null }));
+  }, []);
+  const getTokenInfo = (0, import_react16.useCallback)(() => {
+    return sessionManager.getTokenInfo();
+  }, [sessionManager]);
+  (0, import_react16.useEffect)(() => {
+    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
+  };
+}
+
+// src/providers/SessionProvider.tsx
+var import_react17 = require("react");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var SessionContext = (0, import_react17.createContext)(void 0);
+function SessionProvider({ children, options = {} }) {
+  const sessionData = useSession(options);
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(SessionContext.Provider, { value: sessionData, children });
+}
+function useSessionContext() {
+  const context = (0, import_react17.useContext)(SessionContext);
+  if (context === void 0) {
+    throw new Error("useSessionContext must be used within a SessionProvider");
+  }
+  return context;
+}
+function ProtectedRoute({
+  children,
+  fallback = /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { children: "Please log in to access this content" }),
+  redirectTo
+}) {
+  const { isAuthenticated, isLoading, isInitialized } = useSessionContext();
+  if (!isInitialized || isLoading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { children: "Loading..." });
+  }
+  if (!isAuthenticated) {
+    if (redirectTo) {
+      redirectTo();
+      return null;
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_jsx_runtime12.Fragment, { children: fallback });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_jsx_runtime12.Fragment, { children });
+}
+function SessionDebugInfo() {
+  const session = useSessionContext();
+  if (!session.isInitialized) {
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { children: "Session not initialized" });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { style: {
+    padding: "10px",
+    margin: "10px",
+    border: "1px solid #ccc",
+    borderRadius: "4px",
+    fontSize: "12px",
+    fontFamily: "monospace"
+  }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("h4", { children: "Session Debug Info" }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("strong", { children: "Authenticated:" }),
+      " ",
+      session.isAuthenticated ? "Yes" : "No"
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("strong", { children: "Loading:" }),
+      " ",
+      session.isLoading ? "Yes" : "No"
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("strong", { children: "Error:" }),
+      " ",
+      session.error || "None"
+    ] }),
+    session.tokens && /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_jsx_runtime12.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("strong", { children: "Access Token:" }),
+        " ",
+        session.tokens.accessToken.substring(0, 20),
+        "..."
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("strong", { children: "Refresh Token:" }),
+        " ",
+        session.tokens.refreshToken.substring(0, 20),
+        "..."
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("strong", { children: "Access Expires In:" }),
+        " ",
+        Math.round(session.expiresIn / 1e3 / 60),
+        " minutes"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("strong", { children: "Refresh Expires In:" }),
+        " ",
+        Math.round(session.refreshExpiresIn / 1e3 / 60 / 60),
+        " hours"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)("div", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("strong", { children: "Expiring Soon:" }),
+        " ",
+        session.isExpiringSoon ? "Yes" : "No"
+      ] })
+    ] })
+  ] });
+}
+
+// src/components/LoginComponent.tsx
+var import_react18 = require("react");
+var import_material8 = require("@mui/material");
+var import_jsx_runtime13 = require("react/jsx-runtime");
+function LoginComponent() {
+  const [email, setEmail] = (0, import_react18.useState)("");
+  const [password, setPassword] = (0, import_react18.useState)("");
+  const [showForm, setShowForm] = (0, import_react18.useState)(false);
+  const {
+    isAuthenticated,
+    isLoading,
+    error,
+    login,
+    logout,
+    refreshTokens,
+    clearError,
+    isExpiringSoon,
+    expiresIn
+  } = useSessionContext();
+  const handleLogin = async (e) => {
+    e.preventDefault();
+    if (!email || !password) {
+      return;
+    }
+    const result = await login(email, password);
+    if (result.success) {
+      setEmail("");
+      setPassword("");
+      setShowForm(false);
+    }
+  };
+  const handleLogout = async () => {
+    await logout();
+  };
+  const handleRefreshTokens = async () => {
+    await refreshTokens();
+  };
+  if (isAuthenticated) {
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_material8.Box, { sx: { maxWidth: 600, mx: "auto", p: 3 }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Typography, { variant: "h4", gutterBottom: true, children: "Welcome! \u{1F389}" }),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Alert, { severity: "success", sx: { mb: 3 }, children: "You are successfully logged in with Refresh Token Pattern enabled" }),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_material8.Box, { sx: { mb: 3, p: 2, bgcolor: "background.paper", border: 1, borderColor: "divider", borderRadius: 1 }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Typography, { variant: "h6", gutterBottom: true, children: "Token Status" }),
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_material8.Typography, { variant: "body2", color: "text.secondary", children: [
+          "Access Token expires in: ",
+          Math.round(expiresIn / 1e3 / 60),
+          " minutes"
+        ] }),
+        isExpiringSoon && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Alert, { severity: "warning", sx: { mt: 1 }, children: "Token expires soon - automatic refresh will happen" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_material8.Box, { sx: { display: "flex", gap: 2, flexWrap: "wrap" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+          import_material8.Button,
+          {
+            variant: "contained",
+            onClick: handleRefreshTokens,
+            disabled: isLoading,
+            startIcon: isLoading ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.CircularProgress, { size: 16 }) : null,
+            children: "Refresh Tokens"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+          import_material8.Button,
+          {
+            variant: "outlined",
+            color: "error",
+            onClick: handleLogout,
+            disabled: isLoading,
+            children: "Logout"
+          }
+        )
+      ] }),
+      error && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Alert, { severity: "error", sx: { mt: 2 }, onClose: clearError, children: error })
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_material8.Box, { sx: { maxWidth: 400, mx: "auto", p: 3 }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Typography, { variant: "h4", gutterBottom: true, align: "center", children: "Login with Refresh Tokens" }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Alert, { severity: "info", sx: { mb: 3 }, children: "This demo shows the new Refresh Token Pattern with automatic session management" }),
+    !showForm ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+      import_material8.Button,
+      {
+        fullWidth: true,
+        variant: "contained",
+        size: "large",
+        onClick: () => setShowForm(true),
+        sx: { mt: 2 },
+        children: "Show Login Form"
+      }
+    ) : /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("form", { onSubmit: handleLogin, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+        import_material8.TextField,
+        {
+          fullWidth: true,
+          label: "Email",
+          type: "email",
+          value: email,
+          onChange: (e) => setEmail(e.target.value),
+          margin: "normal",
+          required: true,
+          autoComplete: "email"
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+        import_material8.TextField,
+        {
+          fullWidth: true,
+          label: "Password",
+          type: "password",
+          value: password,
+          onChange: (e) => setPassword(e.target.value),
+          margin: "normal",
+          required: true,
+          autoComplete: "current-password"
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+        import_material8.Button,
+        {
+          type: "submit",
+          fullWidth: true,
+          variant: "contained",
+          size: "large",
+          disabled: isLoading,
+          startIcon: isLoading ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.CircularProgress, { size: 16 }) : null,
+          sx: { mt: 3, mb: 2 },
+          children: isLoading ? "Logging in..." : "Login"
+        }
+      )
+    ] }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Alert, { severity: "error", sx: { mt: 2 }, onClose: clearError, children: error })
+  ] });
+}
+function SessionStatus() {
+  const { isAuthenticated, isLoading, isExpiringSoon, expiresIn } = useSessionContext();
+  if (isLoading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_material8.Box, { sx: { display: "flex", alignItems: "center", gap: 1 }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.CircularProgress, { size: 16 }),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Typography, { variant: "caption", children: "Loading session..." })
+    ] });
+  }
+  if (!isAuthenticated) {
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Typography, { variant: "caption", color: "text.secondary", children: "Not logged in" });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_material8.Box, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_material8.Typography, { variant: "caption", color: "success.main", children: "\u2713 Authenticated" }),
+    isExpiringSoon && /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_material8.Typography, { variant: "caption", color: "warning.main", display: "block", children: [
+      "\u26A0 Token expires in ",
+      Math.round(expiresIn / 1e3 / 60),
+      " min"
+    ] })
+  ] });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CrudifyDataProvider,
   CrudifyLogin,
   ERROR_CODES,
   ERROR_SEVERITY_MAP,
+  LoginComponent,
+  ProtectedRoute,
+  SessionDebugInfo,
+  SessionManager,
+  SessionProvider,
+  SessionStatus,
+  TokenStorage,
   UserProfileDisplay,
   configurationManager,
   crudify,
@@ -3900,6 +4742,8 @@ init_secureStorage();
   useCrudifyInstance,
   useCrudifyLogin,
   useCrudifyUser,
+  useSession,
+  useSessionContext,
   useUserProfile,
   ...require("@nocios/crudify-browser")
 });