@nocios/crudify-ui 1.2.29 → 1.2.34

package/dist/{CrudifyDataProvider-BLW4PCVZ.mjs → CrudifyDataProvider-5GXGNQKI.mjs}

@@ -2,9 +2,11 @@ import {
   CrudifyDataProvider,
   configurationManager,
   crudifyInitializer,
-  tokenManager,
   useCrudifyDataContext
-} from "./chunk-LR5FXHGC.mjs";
+} from "./chunk-GY5F6KOF.mjs";
+import {
+  tokenManager
+} from "./chunk-M7V4UGCN.mjs";
 export {
   CrudifyDataProvider,
   configurationManager,

package/dist/TokenManager-AYUNIXQU.mjs

@@ -0,0 +1,8 @@
+import {
+  TokenManager,
+  tokenManager
+} from "./chunk-M7V4UGCN.mjs";
+export {
+  TokenManager,
+  tokenManager
+};

package/dist/{chunk-LR5FXHGC.mjs → chunk-GY5F6KOF.mjs}

@@ -1,3 +1,7 @@
+import {
+  tokenManager
+} from "./chunk-M7V4UGCN.mjs";
+
 // src/providers/CrudifyDataProvider.tsx
 import { createContext, useContext, useEffect, useState, useCallback } from "react";
 
@@ -462,506 +466,6 @@ _CrudifyInitializer.instance = null;
 var CrudifyInitializer = _CrudifyInitializer;
 var crudifyInitializer = CrudifyInitializer.getInstance();
 
-// src/core/TokenManager.ts
-import crudify2 from "@nocios/crudify-browser";
-
-// src/components/CrudifyLogin/utils/secureStorage.ts
-import CryptoJS from "crypto-js";
-var SecureStorage = class {
-  constructor(storageType = "sessionStorage") {
-    this.encryptionKey = this.generateEncryptionKey();
-    this.storage = storageType === "localStorage" ? window.localStorage : window.sessionStorage;
-  }
-  generateEncryptionKey() {
-    const browserFingerprint = [
-      navigator.userAgent,
-      navigator.language,
-      (/* @__PURE__ */ new Date()).getTimezoneOffset(),
-      screen.colorDepth,
-      screen.width,
-      screen.height,
-      "crudify-login"
-    ].join("|");
-    return CryptoJS.SHA256(browserFingerprint).toString();
-  }
-  setItem(key, value, expiryMinutes) {
-    try {
-      const encrypted = CryptoJS.AES.encrypt(value, this.encryptionKey).toString();
-      this.storage.setItem(key, encrypted);
-      if (expiryMinutes) {
-        const expiryTime = (/* @__PURE__ */ new Date()).getTime() + expiryMinutes * 60 * 1e3;
-        this.storage.setItem(`${key}_expiry`, expiryTime.toString());
-      }
-    } catch (error) {
-      console.error("Failed to encrypt and store data:", error);
-    }
-  }
-  getItem(key) {
-    try {
-      const expiryKey = `${key}_expiry`;
-      const expiry = this.storage.getItem(expiryKey);
-      if (expiry) {
-        const expiryTime = parseInt(expiry, 10);
-        if ((/* @__PURE__ */ new Date()).getTime() > expiryTime) {
-          this.removeItem(key);
-          return null;
-        }
-      }
-      const encrypted = this.storage.getItem(key);
-      if (!encrypted) return null;
-      const decrypted = CryptoJS.AES.decrypt(encrypted, this.encryptionKey);
-      const result = decrypted.toString(CryptoJS.enc.Utf8);
-      if (!result) {
-        console.warn("Failed to decrypt stored data - may be corrupted");
-        this.removeItem(key);
-        return null;
-      }
-      return result;
-    } catch (error) {
-      console.error("Failed to decrypt data:", error);
-      this.removeItem(key);
-      return null;
-    }
-  }
-  removeItem(key) {
-    this.storage.removeItem(key);
-    this.storage.removeItem(`${key}_expiry`);
-  }
-  setToken(token) {
-    try {
-      const parts = token.split(".");
-      if (parts.length === 3) {
-        const payload = JSON.parse(atob(parts[1]));
-        if (payload.exp) {
-          const expiryTime = payload.exp * 1e3;
-          const now = (/* @__PURE__ */ new Date()).getTime();
-          const minutesUntilExpiry = Math.floor((expiryTime - now) / (60 * 1e3));
-          if (minutesUntilExpiry > 0) {
-            this.setItem("authToken", token, minutesUntilExpiry);
-            return;
-          }
-        }
-      }
-    } catch (error) {
-      console.warn("Failed to parse token expiry, using default expiry");
-    }
-    this.setItem("authToken", token, 24 * 60);
-  }
-  getToken() {
-    const token = this.getItem("authToken");
-    if (token) {
-      try {
-        const parts = token.split(".");
-        if (parts.length === 3) {
-          const payload = JSON.parse(atob(parts[1]));
-          if (payload.exp) {
-            const now = Math.floor(Date.now() / 1e3);
-            if (payload.exp < now) {
-              this.removeItem("authToken");
-              return null;
-            }
-          }
-        }
-      } catch (error) {
-        console.warn("Failed to validate token expiry");
-        this.removeItem("authToken");
-        return null;
-      }
-    }
-    return token;
-  }
-};
-var secureSessionStorage = new SecureStorage("sessionStorage");
-var secureLocalStorage = new SecureStorage("localStorage");
-
-// 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 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;
-  }
-};
-
-// src/core/TokenManager.ts
-var _TokenManager = class _TokenManager {
-  constructor() {
-    this.TOKEN_KEY = "authToken";
-    // Compatible with crudia-ui
-    this.tokenCache = null;
-    this.parsedTokenCache = null;
-    this.expirationCheckInterval = null;
-    this.storageEventListener = null;
-    this.initializeTokenManager();
-  }
-  /**
-   * Singleton pattern to ensure consistent token management
-   */
-  static getInstance() {
-    if (!_TokenManager.instance) {
-      _TokenManager.instance = new _TokenManager();
-    }
-    return _TokenManager.instance;
-  }
-  /**
-   * Reset the singleton instance (useful for testing)
-   */
-  static resetInstance() {
-    if (_TokenManager.instance) {
-      _TokenManager.instance.cleanup();
-    }
-    _TokenManager.instance = null;
-  }
-  /**
-   * Initialize the token manager with storage synchronization
-   */
-  initializeTokenManager() {
-    console.log("\u{1F510} TokenManager - Initializing token management");
-    this.migrateFromLocalStorage();
-    this.loadTokenFromStorage();
-    this.setupExpirationCheck();
-    this.setupStorageListener();
-    console.log("\u{1F510} TokenManager - Initialization complete");
-  }
-  /**
-   * Migrate tokens from plain localStorage to encrypted localStorage
-   * This ensures compatibility with older implementations
-   */
-  migrateFromLocalStorage() {
-    try {
-      const legacyKeys = ["authToken", "token", "jwt", "jwtToken"];
-      for (const key of legacyKeys) {
-        const token = localStorage.getItem(key);
-        if (token && !secureLocalStorage.getToken()) {
-          console.log(`\u{1F510} TokenManager - Migrating token from localStorage key: ${key}`);
-          secureLocalStorage.setToken(token);
-          localStorage.removeItem(key);
-          break;
-        }
-      }
-    } catch (error) {
-      console.warn("\u{1F510} TokenManager - Token migration failed:", error);
-    }
-  }
-  /**
-   * Load token from storage and synchronize with crudify
-   */
-  loadTokenFromStorage() {
-    console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Entry point - loading token from storage");
-    try {
-      console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Getting token from secure local storage");
-      const storedToken = secureLocalStorage.getToken();
-      console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Stored token exists:", !!storedToken);
-      if (storedToken && this.isTokenValid(storedToken)) {
-        console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Stored token is valid, updating cache");
-        this.tokenCache = storedToken;
-        this.parsedTokenCache = this.parseToken(storedToken);
-        this.syncTokenWithCrudify(storedToken);
-        console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Token loaded from storage and synchronized");
-      } else if (storedToken) {
-        console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Stored token exists but is invalid/expired, clearing");
-        this.clearToken();
-      } else {
-        console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: No stored token found");
-      }
-    } catch (error) {
-      console.warn("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Error loading token from storage:", error);
-      this.clearToken();
-    }
-  }
-  /**
-   * Set up automatic token expiration checking
-   */
-  setupExpirationCheck() {
-    this.expirationCheckInterval = window.setInterval(() => {
-      if (this.tokenCache && !this.isTokenValid(this.tokenCache)) {
-        console.log("\u{1F510} TokenManager - Token expired, clearing automatically");
-        this.clearToken();
-      }
-    }, 3e4);
-  }
-  /**
-   * Set up storage event listener for cross-tab synchronization
-   */
-  setupStorageListener() {
-    this.storageEventListener = (event) => {
-      if (event.key === this.TOKEN_KEY) {
-        console.log("\u{1F510} TokenManager - Token change detected from another tab");
-        this.loadTokenFromStorage();
-      }
-    };
-    window.addEventListener("storage", this.storageEventListener);
-  }
-  /**
-   * Set a new JWT token with automatic synchronization
-   */
-  setToken(token) {
-    console.log("\u{1F510} TokenManager - SET_TOKEN: Entry point - setting token:", token ? "provided" : "null");
-    try {
-      if (!token) {
-        console.log("\u{1F510} TokenManager - SET_TOKEN: No token provided, clearing token");
-        this.clearToken();
-        return;
-      }
-      console.log("\u{1F510} TokenManager - SET_TOKEN: Validating token before setting");
-      if (!this.isTokenValid(token)) {
-        console.warn("\u{1F510} TokenManager - SET_TOKEN: Attempted to set invalid or expired token");
-        this.clearToken();
-        return;
-      }
-      console.log("\u{1F510} TokenManager - SET_TOKEN: Token is valid, updating cache");
-      this.tokenCache = token;
-      this.parsedTokenCache = this.parseToken(token);
-      console.log("\u{1F510} TokenManager - SET_TOKEN: Storing token in secure storage");
-      secureLocalStorage.setToken(token);
-      console.log("\u{1F510} TokenManager - SET_TOKEN: Synchronizing with crudify");
-      this.syncTokenWithCrudify(token);
-      console.log("\u{1F510} TokenManager - SET_TOKEN: Token set and synchronized successfully");
-    } catch (error) {
-      console.error("\u{1F510} TokenManager - SET_TOKEN: Error setting token:", error);
-      this.clearToken();
-    }
-  }
-  /**
-   * Get the current JWT token
-   */
-  getToken() {
-    console.log("\u{1F510} TokenManager - GET_TOKEN: Entry point - checking cache");
-    if (this.tokenCache) {
-      console.log("\u{1F510} TokenManager - GET_TOKEN: Cache exists, validating token");
-      if (this.isTokenValid(this.tokenCache)) {
-        console.log("\u{1F510} TokenManager - GET_TOKEN: Cache valid, returning cached token");
-        return this.tokenCache;
-      } else {
-        console.log("\u{1F510} TokenManager - GET_TOKEN: Cache invalid, clearing cache");
-        this.tokenCache = null;
-      }
-    } else {
-      console.log("\u{1F510} TokenManager - GET_TOKEN: No cache, loading from storage");
-    }
-    console.log("\u{1F510} TokenManager - GET_TOKEN: Loading from storage");
-    this.loadTokenFromStorage();
-    console.log("\u{1F510} TokenManager - GET_TOKEN: Returning final token:", !!this.tokenCache);
-    return this.tokenCache;
-  }
-  /**
-   * Parse the current JWT token
-   */
-  parseToken(token) {
-    console.log("\u{1F510} TokenManager - PARSE_TOKEN: Entry point - parsing token");
-    const targetToken = token !== void 0 ? token : this.tokenCache;
-    console.log("\u{1F510} TokenManager - PARSE_TOKEN: Target token exists:", !!targetToken);
-    if (!targetToken) {
-      console.log("\u{1F510} TokenManager - PARSE_TOKEN: No target token, returning null");
-      return null;
-    }
-    if (this.tokenCache === targetToken && this.parsedTokenCache) {
-      console.log("\u{1F510} TokenManager - PARSE_TOKEN: Returning cached parsed token");
-      return this.parsedTokenCache;
-    }
-    console.log("\u{1F510} TokenManager - PARSE_TOKEN: Cache miss, parsing token with decodeJwtSafely");
-    const parsed = decodeJwtSafely(targetToken);
-    console.log("\u{1F510} TokenManager - PARSE_TOKEN: Token parsed successfully:", !!parsed);
-    if (targetToken === this.tokenCache) {
-      console.log("\u{1F510} TokenManager - PARSE_TOKEN: Updating parsed token cache");
-      this.parsedTokenCache = parsed;
-    }
-    return parsed;
-  }
-  /**
-   * Check if a token is valid (properly formatted and not expired)
-   */
-  isTokenValid(token) {
-    console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Entry point - checking token validity");
-    const targetToken = token !== void 0 ? token : this.tokenCache;
-    console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Target token exists:", !!targetToken);
-    if (!targetToken) {
-      console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: No token, returning false");
-      return false;
-    }
-    try {
-      console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Checking if token is expired");
-      if (isTokenExpired(targetToken)) {
-        console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Token is expired, returning false");
-        return false;
-      }
-      console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Token not expired, checking if can be parsed");
-      const parsed = decodeJwtSafely(targetToken);
-      const isValid = parsed !== null;
-      console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Token parsing result:", isValid);
-      return isValid;
-    } catch (error) {
-      console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Error validating token:", error);
-      return false;
-    }
-  }
-  /**
-   * Get token expiration time as Date object
-   */
-  getTokenExpiration() {
-    const token = this.getToken();
-    if (!token) return null;
-    const parsed = this.parseToken(token);
-    if (!parsed?.exp) return null;
-    return new Date(parsed.exp * 1e3);
-  }
-  /**
-   * Clear the current token from all storages and crudify
-   */
-  clearToken() {
-    console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Entry point - clearing all tokens");
-    try {
-      console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Clearing cache");
-      this.tokenCache = null;
-      this.parsedTokenCache = null;
-      console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Clearing from secure storage");
-      secureLocalStorage.removeItem(this.TOKEN_KEY);
-      console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Clearing from crudify");
-      crudify2.setToken("");
-      console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Token cleared from all storages successfully");
-    } catch (error) {
-      console.warn("\u{1F510} TokenManager - CLEAR_TOKEN: Error clearing token:", error);
-    }
-  }
-  /**
-   * Synchronize token with crudify library
-   */
-  syncTokenWithCrudify(token) {
-    try {
-      crudify2.setToken(token);
-      console.log("\u{1F510} TokenManager - Token synchronized with crudify");
-    } catch (error) {
-      console.warn("\u{1F510} TokenManager - Failed to sync token with crudify:", error);
-    }
-  }
-  /**
-   * Refresh token (placeholder for future implementation)
-   */
-  async refreshToken() {
-    throw new Error("Token refresh not yet implemented");
-  }
-  /**
-   * Get user information from the current token
-   */
-  getUserInfo() {
-    const parsed = this.parseToken();
-    if (!parsed) {
-      return {
-        email: null,
-        userId: null,
-        userIdentifier: null,
-        username: null
-      };
-    }
-    return {
-      email: parsed.email || null,
-      userId: parsed.sub || null,
-      userIdentifier: parsed["cognito:username"] || parsed.email || parsed.sub || null,
-      username: parsed["cognito:username"] || null
-    };
-  }
-  /**
-   * Check if user is currently authenticated
-   */
-  isAuthenticated() {
-    return this.isTokenValid();
-  }
-  /**
-   * Get time until token expires in minutes
-   */
-  getTimeUntilExpiration() {
-    const expiration = this.getTokenExpiration();
-    if (!expiration) return null;
-    const now = /* @__PURE__ */ new Date();
-    const minutesUntilExpiry = Math.floor((expiration.getTime() - now.getTime()) / (60 * 1e3));
-    return Math.max(0, minutesUntilExpiry);
-  }
-  /**
-   * Cleanup resources (call when the component unmounts)
-   */
-  cleanup() {
-    if (this.expirationCheckInterval) {
-      window.clearInterval(this.expirationCheckInterval);
-      this.expirationCheckInterval = null;
-    }
-    if (this.storageEventListener) {
-      window.removeEventListener("storage", this.storageEventListener);
-      this.storageEventListener = null;
-    }
-    console.log("\u{1F510} TokenManager - Cleanup completed");
-  }
-  /**
-   * Get debug information about the current token state
-   */
-  getDebugInfo() {
-    const token = this.getToken();
-    const parsed = this.parseToken();
-    const expiration = this.getTokenExpiration();
-    return {
-      hasToken: !!token,
-      tokenLength: token?.length || 0,
-      isValid: this.isTokenValid(),
-      isAuthenticated: this.isAuthenticated(),
-      expiration: expiration?.toISOString() || null,
-      minutesUntilExpiry: this.getTimeUntilExpiration(),
-      userInfo: this.getUserInfo(),
-      parsedTokenKeys: parsed ? Object.keys(parsed) : []
-    };
-  }
-};
-_TokenManager.instance = null;
-var TokenManager = _TokenManager;
-var tokenManager = TokenManager.getInstance();
-
 // src/providers/CrudifyDataProvider.tsx
 import { jsx } from "react/jsx-runtime";
 var CrudifyDataContext = createContext(null);
@@ -1190,14 +694,8 @@ var useCrudifyDataContext = () => {
 
 export {
   getCookie,
-  secureSessionStorage,
-  secureLocalStorage,
   configurationManager,
   crudifyInitializer,
-  decodeJwtSafely,
-  getCurrentUserEmail,
-  isTokenExpired,
-  tokenManager,
   CrudifyDataProvider,
   useCrudifyDataContext
 };

package/dist/chunk-M7V4UGCN.mjs

@@ -0,0 +1,512 @@
+// src/core/TokenManager.ts
+import crudify from "@nocios/crudify-browser";
+
+// src/components/CrudifyLogin/utils/secureStorage.ts
+import CryptoJS from "crypto-js";
+var SecureStorage = class {
+  constructor(storageType = "sessionStorage") {
+    this.encryptionKey = this.generateEncryptionKey();
+    this.storage = storageType === "localStorage" ? window.localStorage : window.sessionStorage;
+  }
+  generateEncryptionKey() {
+    const browserFingerprint = [
+      navigator.userAgent,
+      navigator.language,
+      (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+      screen.colorDepth,
+      screen.width,
+      screen.height,
+      "crudify-login"
+    ].join("|");
+    return CryptoJS.SHA256(browserFingerprint).toString();
+  }
+  setItem(key, value, expiryMinutes) {
+    try {
+      const encrypted = CryptoJS.AES.encrypt(value, this.encryptionKey).toString();
+      this.storage.setItem(key, encrypted);
+      if (expiryMinutes) {
+        const expiryTime = (/* @__PURE__ */ new Date()).getTime() + expiryMinutes * 60 * 1e3;
+        this.storage.setItem(`${key}_expiry`, expiryTime.toString());
+      }
+    } catch (error) {
+      console.error("Failed to encrypt and store data:", error);
+    }
+  }
+  getItem(key) {
+    try {
+      const expiryKey = `${key}_expiry`;
+      const expiry = this.storage.getItem(expiryKey);
+      if (expiry) {
+        const expiryTime = parseInt(expiry, 10);
+        if ((/* @__PURE__ */ new Date()).getTime() > expiryTime) {
+          this.removeItem(key);
+          return null;
+        }
+      }
+      const encrypted = this.storage.getItem(key);
+      if (!encrypted) return null;
+      const decrypted = CryptoJS.AES.decrypt(encrypted, this.encryptionKey);
+      const result = decrypted.toString(CryptoJS.enc.Utf8);
+      if (!result) {
+        console.warn("Failed to decrypt stored data - may be corrupted");
+        this.removeItem(key);
+        return null;
+      }
+      return result;
+    } catch (error) {
+      console.error("Failed to decrypt data:", error);
+      this.removeItem(key);
+      return null;
+    }
+  }
+  removeItem(key) {
+    this.storage.removeItem(key);
+    this.storage.removeItem(`${key}_expiry`);
+  }
+  setToken(token) {
+    try {
+      const parts = token.split(".");
+      if (parts.length === 3) {
+        const payload = JSON.parse(atob(parts[1]));
+        if (payload.exp) {
+          const expiryTime = payload.exp * 1e3;
+          const now = (/* @__PURE__ */ new Date()).getTime();
+          const minutesUntilExpiry = Math.floor((expiryTime - now) / (60 * 1e3));
+          if (minutesUntilExpiry > 0) {
+            this.setItem("authToken", token, minutesUntilExpiry);
+            return;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to parse token expiry, using default expiry");
+    }
+    this.setItem("authToken", token, 24 * 60);
+  }
+  getToken() {
+    const token = this.getItem("authToken");
+    if (token) {
+      try {
+        const parts = token.split(".");
+        if (parts.length === 3) {
+          const payload = JSON.parse(atob(parts[1]));
+          if (payload.exp) {
+            const now = Math.floor(Date.now() / 1e3);
+            if (payload.exp < now) {
+              this.removeItem("authToken");
+              return null;
+            }
+          }
+        }
+      } catch (error) {
+        console.warn("Failed to validate token expiry");
+        this.removeItem("authToken");
+        return null;
+      }
+    }
+    return token;
+  }
+};
+var secureSessionStorage = new SecureStorage("sessionStorage");
+var secureLocalStorage = new SecureStorage("localStorage");
+
+// 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 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;
+  }
+};
+
+// src/core/TokenManager.ts
+var _TokenManager = class _TokenManager {
+  constructor() {
+    this.TOKEN_KEY = "authToken";
+    // Compatible with crudia-ui
+    this.tokenCache = null;
+    this.parsedTokenCache = null;
+    this.expirationCheckInterval = null;
+    this.storageEventListener = null;
+    this.initializeTokenManager();
+  }
+  /**
+   * Singleton pattern to ensure consistent token management
+   */
+  static getInstance() {
+    if (!_TokenManager.instance) {
+      _TokenManager.instance = new _TokenManager();
+    }
+    return _TokenManager.instance;
+  }
+  /**
+   * Reset the singleton instance (useful for testing)
+   */
+  static resetInstance() {
+    if (_TokenManager.instance) {
+      _TokenManager.instance.cleanup();
+    }
+    _TokenManager.instance = null;
+  }
+  /**
+   * Initialize the token manager with storage synchronization
+   */
+  initializeTokenManager() {
+    console.log("\u{1F510} TokenManager - Initializing token management");
+    this.migrateFromLocalStorage();
+    this.loadTokenFromStorage();
+    this.setupExpirationCheck();
+    this.setupStorageListener();
+    console.log("\u{1F510} TokenManager - Initialization complete");
+  }
+  /**
+   * Migrate tokens from plain localStorage to encrypted localStorage
+   * This ensures compatibility with older implementations
+   */
+  migrateFromLocalStorage() {
+    try {
+      const legacyKeys = ["authToken", "token", "jwt", "jwtToken"];
+      for (const key of legacyKeys) {
+        const token = localStorage.getItem(key);
+        if (token && !secureLocalStorage.getToken()) {
+          console.log(`\u{1F510} TokenManager - Migrating token from localStorage key: ${key}`);
+          secureLocalStorage.setToken(token);
+          localStorage.removeItem(key);
+          break;
+        }
+      }
+    } catch (error) {
+      console.warn("\u{1F510} TokenManager - Token migration failed:", error);
+    }
+  }
+  /**
+   * Load token from storage and synchronize with crudify
+   */
+  loadTokenFromStorage() {
+    console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Entry point - loading token from storage");
+    try {
+      console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Getting token from secure local storage");
+      const storedToken = secureLocalStorage.getToken();
+      console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Stored token exists:", !!storedToken);
+      if (storedToken && this.isTokenValid(storedToken)) {
+        console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Stored token is valid, updating cache");
+        this.tokenCache = storedToken;
+        this.parsedTokenCache = this.parseToken(storedToken);
+        this.syncTokenWithCrudify(storedToken);
+        console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Token loaded from storage and synchronized");
+      } else if (storedToken) {
+        console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Stored token exists but is invalid/expired, clearing");
+        this.clearToken();
+      } else {
+        console.log("\u{1F510} TokenManager - LOAD_FROM_STORAGE: No stored token found");
+      }
+    } catch (error) {
+      console.warn("\u{1F510} TokenManager - LOAD_FROM_STORAGE: Error loading token from storage:", error);
+      this.clearToken();
+    }
+  }
+  /**
+   * Set up automatic token expiration checking
+   */
+  setupExpirationCheck() {
+    this.expirationCheckInterval = window.setInterval(() => {
+      if (this.tokenCache && !this.isTokenValid(this.tokenCache)) {
+        console.log("\u{1F510} TokenManager - Token expired, clearing automatically");
+        this.clearToken();
+      }
+    }, 3e4);
+  }
+  /**
+   * Set up storage event listener for cross-tab synchronization
+   */
+  setupStorageListener() {
+    this.storageEventListener = (event) => {
+      if (event.key === this.TOKEN_KEY) {
+        console.log("\u{1F510} TokenManager - Token change detected from another tab");
+        this.loadTokenFromStorage();
+      }
+    };
+    window.addEventListener("storage", this.storageEventListener);
+  }
+  /**
+   * Set a new JWT token with automatic synchronization
+   */
+  setToken(token) {
+    console.log("\u{1F510} TokenManager - SET_TOKEN: Entry point - setting token:", token ? "provided" : "null");
+    try {
+      if (!token) {
+        console.log("\u{1F510} TokenManager - SET_TOKEN: No token provided, clearing token");
+        this.clearToken();
+        return;
+      }
+      console.log("\u{1F510} TokenManager - SET_TOKEN: Validating token before setting");
+      if (!this.isTokenValid(token)) {
+        console.warn("\u{1F510} TokenManager - SET_TOKEN: Attempted to set invalid or expired token");
+        this.clearToken();
+        return;
+      }
+      console.log("\u{1F510} TokenManager - SET_TOKEN: Token is valid, updating cache");
+      this.tokenCache = token;
+      this.parsedTokenCache = this.parseToken(token);
+      console.log("\u{1F510} TokenManager - SET_TOKEN: Storing token in secure storage");
+      secureLocalStorage.setToken(token);
+      console.log("\u{1F510} TokenManager - SET_TOKEN: Synchronizing with crudify");
+      this.syncTokenWithCrudify(token);
+      console.log("\u{1F510} TokenManager - SET_TOKEN: Token set and synchronized successfully");
+    } catch (error) {
+      console.error("\u{1F510} TokenManager - SET_TOKEN: Error setting token:", error);
+      this.clearToken();
+    }
+  }
+  /**
+   * Get the current JWT token
+   */
+  getToken() {
+    console.log("\u{1F510} TokenManager - GET_TOKEN: Entry point - checking cache");
+    if (this.tokenCache) {
+      console.log("\u{1F510} TokenManager - GET_TOKEN: Cache exists, validating token");
+      if (this.isTokenValid(this.tokenCache)) {
+        console.log("\u{1F510} TokenManager - GET_TOKEN: Cache valid, returning cached token");
+        return this.tokenCache;
+      } else {
+        console.log("\u{1F510} TokenManager - GET_TOKEN: Cache invalid, clearing cache");
+        this.tokenCache = null;
+      }
+    } else {
+      console.log("\u{1F510} TokenManager - GET_TOKEN: No cache, loading from storage");
+    }
+    console.log("\u{1F510} TokenManager - GET_TOKEN: Loading from storage");
+    this.loadTokenFromStorage();
+    console.log("\u{1F510} TokenManager - GET_TOKEN: Returning final token:", !!this.tokenCache);
+    return this.tokenCache;
+  }
+  /**
+   * Parse the current JWT token
+   */
+  parseToken(token) {
+    console.log("\u{1F510} TokenManager - PARSE_TOKEN: Entry point - parsing token");
+    const targetToken = token !== void 0 ? token : this.tokenCache;
+    console.log("\u{1F510} TokenManager - PARSE_TOKEN: Target token exists:", !!targetToken);
+    if (!targetToken) {
+      console.log("\u{1F510} TokenManager - PARSE_TOKEN: No target token, returning null");
+      return null;
+    }
+    if (this.tokenCache === targetToken && this.parsedTokenCache) {
+      console.log("\u{1F510} TokenManager - PARSE_TOKEN: Returning cached parsed token");
+      return this.parsedTokenCache;
+    }
+    console.log("\u{1F510} TokenManager - PARSE_TOKEN: Cache miss, parsing token with decodeJwtSafely");
+    const parsed = decodeJwtSafely(targetToken);
+    console.log("\u{1F510} TokenManager - PARSE_TOKEN: Token parsed successfully:", !!parsed);
+    if (targetToken === this.tokenCache) {
+      console.log("\u{1F510} TokenManager - PARSE_TOKEN: Updating parsed token cache");
+      this.parsedTokenCache = parsed;
+    }
+    return parsed;
+  }
+  /**
+   * Check if a token is valid (properly formatted and not expired)
+   */
+  isTokenValid(token) {
+    console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Entry point - checking token validity");
+    const targetToken = token !== void 0 ? token : this.tokenCache;
+    console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Target token exists:", !!targetToken);
+    if (!targetToken) {
+      console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: No token, returning false");
+      return false;
+    }
+    try {
+      console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Checking if token is expired");
+      if (isTokenExpired(targetToken)) {
+        console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Token is expired, returning false");
+        return false;
+      }
+      console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Token not expired, checking if can be parsed");
+      const parsed = decodeJwtSafely(targetToken);
+      const isValid = parsed !== null;
+      console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Token parsing result:", isValid);
+      return isValid;
+    } catch (error) {
+      console.log("\u{1F510} TokenManager - IS_TOKEN_VALID: Error validating token:", error);
+      return false;
+    }
+  }
+  /**
+   * Get token expiration time as Date object
+   */
+  getTokenExpiration() {
+    const token = this.getToken();
+    if (!token) return null;
+    const parsed = this.parseToken(token);
+    if (!parsed?.exp) return null;
+    return new Date(parsed.exp * 1e3);
+  }
+  /**
+   * Clear the current token from all storages and crudify
+   */
+  clearToken() {
+    console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Entry point - clearing all tokens");
+    try {
+      console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Clearing cache");
+      this.tokenCache = null;
+      this.parsedTokenCache = null;
+      console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Clearing from secure storage");
+      secureLocalStorage.removeItem(this.TOKEN_KEY);
+      console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Clearing from crudify");
+      crudify.setToken("");
+      console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Token cleared from all storages successfully");
+    } catch (error) {
+      console.warn("\u{1F510} TokenManager - CLEAR_TOKEN: Error clearing token:", error);
+    }
+  }
+  /**
+   * Synchronize token with crudify library
+   */
+  syncTokenWithCrudify(token) {
+    try {
+      console.log("\u{1F510} TokenManager - SYNC_TOKEN: Starting token sync with crudify");
+      console.log("   - Token to sync:", token ? `${token.substring(0, 20)}...` : "null");
+      crudify.setToken(token);
+      console.log("   - crudify.getToken() after sync:", crudify.getToken?.() ? `${crudify.getToken?.()?.substring(0, 20)}...` : "null");
+      console.log("\u{1F510} TokenManager - Token synchronized with crudify successfully");
+    } catch (error) {
+      console.warn("\u{1F510} TokenManager - Failed to sync token with crudify:", error);
+    }
+  }
+  /**
+   * Refresh token (placeholder for future implementation)
+   */
+  async refreshToken() {
+    throw new Error("Token refresh not yet implemented");
+  }
+  /**
+   * Get user information from the current token
+   */
+  getUserInfo() {
+    const parsed = this.parseToken();
+    if (!parsed) {
+      return {
+        email: null,
+        userId: null,
+        userIdentifier: null,
+        username: null
+      };
+    }
+    return {
+      email: parsed.email || null,
+      userId: parsed.sub || null,
+      userIdentifier: parsed["cognito:username"] || parsed.email || parsed.sub || null,
+      username: parsed["cognito:username"] || null
+    };
+  }
+  /**
+   * Check if user is currently authenticated
+   */
+  isAuthenticated() {
+    return this.isTokenValid();
+  }
+  /**
+   * Get time until token expires in minutes
+   */
+  getTimeUntilExpiration() {
+    const expiration = this.getTokenExpiration();
+    if (!expiration) return null;
+    const now = /* @__PURE__ */ new Date();
+    const minutesUntilExpiry = Math.floor((expiration.getTime() - now.getTime()) / (60 * 1e3));
+    return Math.max(0, minutesUntilExpiry);
+  }
+  /**
+   * Cleanup resources (call when the component unmounts)
+   */
+  cleanup() {
+    if (this.expirationCheckInterval) {
+      window.clearInterval(this.expirationCheckInterval);
+      this.expirationCheckInterval = null;
+    }
+    if (this.storageEventListener) {
+      window.removeEventListener("storage", this.storageEventListener);
+      this.storageEventListener = null;
+    }
+    console.log("\u{1F510} TokenManager - Cleanup completed");
+  }
+  /**
+   * Get debug information about the current token state
+   */
+  getDebugInfo() {
+    const token = this.getToken();
+    const parsed = this.parseToken();
+    const expiration = this.getTokenExpiration();
+    return {
+      hasToken: !!token,
+      tokenLength: token?.length || 0,
+      isValid: this.isTokenValid(),
+      isAuthenticated: this.isAuthenticated(),
+      expiration: expiration?.toISOString() || null,
+      minutesUntilExpiry: this.getTimeUntilExpiration(),
+      userInfo: this.getUserInfo(),
+      parsedTokenKeys: parsed ? Object.keys(parsed) : []
+    };
+  }
+};
+_TokenManager.instance = null;
+var TokenManager = _TokenManager;
+var tokenManager = TokenManager.getInstance();
+
+export {
+  secureSessionStorage,
+  secureLocalStorage,
+  decodeJwtSafely,
+  getCurrentUserEmail,
+  isTokenExpired,
+  TokenManager,
+  tokenManager
+};

package/dist/index.js

@@ -692,6 +692,11 @@ var init_jwtUtils = __esm({
 });
 
 // src/core/TokenManager.ts
+var TokenManager_exports = {};
+__export(TokenManager_exports, {
+  TokenManager: () => TokenManager,
+  tokenManager: () => tokenManager
+});
 var import_crudify_browser3, _TokenManager, TokenManager, tokenManager;
 var init_TokenManager = __esm({
   "src/core/TokenManager.ts"() {
@@ -943,8 +948,11 @@ var init_TokenManager = __esm({
        */
       syncTokenWithCrudify(token) {
         try {
+          console.log("\u{1F510} TokenManager - SYNC_TOKEN: Starting token sync with crudify");
+          console.log("   - Token to sync:", token ? `${token.substring(0, 20)}...` : "null");
           import_crudify_browser3.default.setToken(token);
-          console.log("\u{1F510} TokenManager - Token synchronized with crudify");
+          console.log("   - crudify.getToken() after sync:", import_crudify_browser3.default.getToken?.() ? `${import_crudify_browser3.default.getToken?.()?.substring(0, 20)}...` : "null");
+          console.log("\u{1F510} TokenManager - Token synchronized with crudify successfully");
         } catch (error) {
           console.warn("\u{1F510} TokenManager - Failed to sync token with crudify:", error);
         }
@@ -3690,10 +3698,27 @@ var useCrudifyInstance = () => {
       console.log(`\u2705 useCrudifyInstance - ${operationName}: Crudify is ready`);
     }
   }, [isReady, waitForReady]);
+  const ensureTokenSync = (0, import_react15.useCallback)(async () => {
+    const { tokenManager: tokenManager2 } = await Promise.resolve().then(() => (init_TokenManager(), TokenManager_exports));
+    const tmToken = tokenManager2.getToken();
+    const crudifyToken = import_crudify_browser7.default.getToken?.();
+    if (tmToken && tmToken !== crudifyToken) {
+      console.log("\u{1F504} useCrudifyInstance - Forcing token sync for authenticated operation");
+      import_crudify_browser7.default.setToken(tmToken);
+    }
+  }, []);
   const getStructure = (0, import_react15.useCallback)(async (options) => {
     console.log("\u{1F4E1} useCrudifyInstance - getStructure: Starting");
     await ensureReady("getStructure");
     try {
+      const { tokenManager: tokenManager2 } = await Promise.resolve().then(() => (init_TokenManager(), TokenManager_exports));
+      const tmToken = tokenManager2.getToken();
+      const crudifyToken = import_crudify_browser7.default.getToken?.();
+      console.log("\u{1F510} useCrudifyInstance - getStructure: Token status check:");
+      console.log("   - TokenManager token:", tmToken ? `${tmToken.substring(0, 20)}...` : "null");
+      console.log("   - crudify.getToken():", crudifyToken ? `${crudifyToken.substring(0, 20)}...` : "null");
+      console.log("   - Tokens match:", tmToken === crudifyToken);
+      await ensureTokenSync();
       console.log("\u{1F4E1} useCrudifyInstance - getStructure: Calling crudify.getStructure");
       const response = await import_crudify_browser7.default.getStructure(options);
       console.log("\u{1F4E1} useCrudifyInstance - getStructure: Response received", response);
@@ -3702,7 +3727,7 @@ var useCrudifyInstance = () => {
       console.error("\u{1F4E1} useCrudifyInstance - getStructure: Error", error);
       throw error;
     }
-  }, [ensureReady]);
+  }, [ensureReady, ensureTokenSync]);
   const getStructurePublic = (0, import_react15.useCallback)(async (options) => {
     console.log("\u{1F4E1} useCrudifyInstance - getStructurePublic: Starting");
     await ensureReady("getStructurePublic");
@@ -3718,6 +3743,7 @@ var useCrudifyInstance = () => {
   }, [ensureReady]);
   const readItems = (0, import_react15.useCallback)(async (moduleKey, filter, options) => {
     await ensureReady("readItems");
+    await ensureTokenSync();
     if (moduleKey === "__test_connection__") {
       console.error("\u{1F6A8} FOUND TEST CONNECTION CALL in useCrudifyInstance! Stack trace:");
       console.error(new Error().stack);
@@ -3729,7 +3755,7 @@ var useCrudifyInstance = () => {
       console.error("\u{1F4CA} useCrudifyInstance - readItems error:", error);
       throw error;
     }
-  }, [ensureReady]);
+  }, [ensureReady, ensureTokenSync]);
   const readItem = (0, import_react15.useCallback)(async (moduleKey, filter, options) => {
     await ensureReady("readItem");
     try {

package/dist/index.mjs

@@ -2,15 +2,17 @@ import {
   CrudifyDataProvider,
   configurationManager,
   crudifyInitializer,
-  decodeJwtSafely,
   getCookie,
+  useCrudifyDataContext
+} from "./chunk-GY5F6KOF.mjs";
+import {
+  decodeJwtSafely,
   getCurrentUserEmail,
   isTokenExpired,
   secureLocalStorage,
   secureSessionStorage,
-  tokenManager,
-  useCrudifyDataContext
-} from "./chunk-LR5FXHGC.mjs";
+  tokenManager
+} from "./chunk-M7V4UGCN.mjs";
 
 // src/index.ts
 import { default as default2 } from "@nocios/crudify-browser";
@@ -2388,7 +2390,7 @@ var useCrudifyInstance = () => {
     }
     try {
       console.log("\u{1F504} useCrudifyInstance - waitForReady: Using CrudifyInitializer.waitForInitialization()");
-      const { crudifyInitializer: crudifyInitializer2 } = await import("./CrudifyDataProvider-BLW4PCVZ.mjs");
+      const { crudifyInitializer: crudifyInitializer2 } = await import("./CrudifyDataProvider-5GXGNQKI.mjs");
       await crudifyInitializer2.waitForInitialization();
       console.log("\u2705 useCrudifyInstance - waitForReady: CrudifyInitializer completed");
       if (!crudifyInitializer2.isReady()) {
@@ -2408,10 +2410,27 @@ var useCrudifyInstance = () => {
       console.log(`\u2705 useCrudifyInstance - ${operationName}: Crudify is ready`);
     }
   }, [isReady, waitForReady]);
+  const ensureTokenSync = useCallback4(async () => {
+    const { tokenManager: tokenManager2 } = await import("./TokenManager-AYUNIXQU.mjs");
+    const tmToken = tokenManager2.getToken();
+    const crudifyToken = crudify5.getToken?.();
+    if (tmToken && tmToken !== crudifyToken) {
+      console.log("\u{1F504} useCrudifyInstance - Forcing token sync for authenticated operation");
+      crudify5.setToken(tmToken);
+    }
+  }, []);
   const getStructure = useCallback4(async (options) => {
     console.log("\u{1F4E1} useCrudifyInstance - getStructure: Starting");
     await ensureReady("getStructure");
     try {
+      const { tokenManager: tokenManager2 } = await import("./TokenManager-AYUNIXQU.mjs");
+      const tmToken = tokenManager2.getToken();
+      const crudifyToken = crudify5.getToken?.();
+      console.log("\u{1F510} useCrudifyInstance - getStructure: Token status check:");
+      console.log("   - TokenManager token:", tmToken ? `${tmToken.substring(0, 20)}...` : "null");
+      console.log("   - crudify.getToken():", crudifyToken ? `${crudifyToken.substring(0, 20)}...` : "null");
+      console.log("   - Tokens match:", tmToken === crudifyToken);
+      await ensureTokenSync();
       console.log("\u{1F4E1} useCrudifyInstance - getStructure: Calling crudify.getStructure");
       const response = await crudify5.getStructure(options);
       console.log("\u{1F4E1} useCrudifyInstance - getStructure: Response received", response);
@@ -2420,7 +2439,7 @@ var useCrudifyInstance = () => {
       console.error("\u{1F4E1} useCrudifyInstance - getStructure: Error", error);
       throw error;
     }
-  }, [ensureReady]);
+  }, [ensureReady, ensureTokenSync]);
   const getStructurePublic = useCallback4(async (options) => {
     console.log("\u{1F4E1} useCrudifyInstance - getStructurePublic: Starting");
     await ensureReady("getStructurePublic");
@@ -2436,6 +2455,7 @@ var useCrudifyInstance = () => {
   }, [ensureReady]);
   const readItems = useCallback4(async (moduleKey, filter, options) => {
     await ensureReady("readItems");
+    await ensureTokenSync();
     if (moduleKey === "__test_connection__") {
       console.error("\u{1F6A8} FOUND TEST CONNECTION CALL in useCrudifyInstance! Stack trace:");
       console.error(new Error().stack);
@@ -2447,7 +2467,7 @@ var useCrudifyInstance = () => {
       console.error("\u{1F4CA} useCrudifyInstance - readItems error:", error);
       throw error;
     }
-  }, [ensureReady]);
+  }, [ensureReady, ensureTokenSync]);
   const readItem = useCallback4(async (moduleKey, filter, options) => {
     await ensureReady("readItem");
     try {
@@ -2530,7 +2550,7 @@ var useCrudifyInstance = () => {
 };
 var getCrudifyInstanceAsync = async () => {
   console.log("\u{1F504} getCrudifyInstanceAsync - Starting");
-  const { crudifyInitializer: crudifyInitializer2 } = await import("./CrudifyDataProvider-BLW4PCVZ.mjs");
+  const { crudifyInitializer: crudifyInitializer2 } = await import("./CrudifyDataProvider-5GXGNQKI.mjs");
   console.log("\u{1F504} getCrudifyInstanceAsync - Checking if ready");
   console.log("   - crudifyInitializer.isReady():", crudifyInitializer2.isReady());
   console.log("   - crudifyInitializer.getStatus():", crudifyInitializer2.getStatus());
@@ -2549,7 +2569,7 @@ var getCrudifyInstanceAsync = async () => {
   return crudify5;
 };
 var getCrudifyInstanceSync = async () => {
-  const { crudifyInitializer: crudifyInitializer2 } = await import("./CrudifyDataProvider-BLW4PCVZ.mjs");
+  const { crudifyInitializer: crudifyInitializer2 } = await import("./CrudifyDataProvider-5GXGNQKI.mjs");
   if (!crudifyInitializer2.isReady()) {
     throw new Error("Crudify not ready. Use getCrudifyInstanceAsync() or call this from within a React component using useCrudifyInstance()");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocios/crudify-ui",
-  "version": "1.2.29",
+  "version": "1.2.34",
   "description": "Biblioteca de componentes UI para Crudify",
   "author": "Nocios",
   "license": "MIT",