@nocios/crudify-ui 1.1.0 → 1.2.1

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,6 +31,1211 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/components/CrudifyLogin/utils/cookies.ts
+var getCookie;
+var init_cookies = __esm({
+  "src/components/CrudifyLogin/utils/cookies.ts"() {
+    "use strict";
+    getCookie = (name) => {
+      const match = document.cookie.match(new RegExp("(^|;)\\s*" + name + "=([^;]+)"));
+      return match ? match[2] : null;
+    };
+  }
+});
+
+// src/components/CrudifyLogin/utils/secureStorage.ts
+var import_crypto_js, SecureStorage, secureSessionStorage, secureLocalStorage;
+var init_secureStorage = __esm({
+  "src/components/CrudifyLogin/utils/secureStorage.ts"() {
+    "use strict";
+    import_crypto_js = __toESM(require("crypto-js"));
+    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 import_crypto_js.default.SHA256(browserFingerprint).toString();
+      }
+      setItem(key, value, expiryMinutes) {
+        try {
+          const encrypted = import_crypto_js.default.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 = import_crypto_js.default.AES.decrypt(encrypted, this.encryptionKey);
+          const result = decrypted.toString(import_crypto_js.default.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;
+      }
+    };
+    secureSessionStorage = new SecureStorage("sessionStorage");
+    secureLocalStorage = new SecureStorage("localStorage");
+  }
+});
+
+// src/core/ConfigurationManager.ts
+var _ConfigurationManager, ConfigurationManager, configurationManager;
+var init_ConfigurationManager = __esm({
+  "src/core/ConfigurationManager.ts"() {
+    "use strict";
+    init_cookies();
+    _ConfigurationManager = class _ConfigurationManager {
+      constructor() {
+        this.resolvedConfig = null;
+        this.configError = null;
+      }
+      /**
+       * Singleton pattern to ensure consistent configuration across the app
+       */
+      static getInstance() {
+        if (!_ConfigurationManager.instance) {
+          _ConfigurationManager.instance = new _ConfigurationManager();
+        }
+        return _ConfigurationManager.instance;
+      }
+      /**
+       * Reset the singleton instance (useful for testing)
+       */
+      static resetInstance() {
+        _ConfigurationManager.instance = null;
+      }
+      /**
+       * Resolve configuration from all sources with proper priority
+       */
+      resolveConfig(propsConfig = {}) {
+        if (this.resolvedConfig && this.isConfigStillValid(propsConfig)) {
+          return this.resolvedConfig;
+        }
+        try {
+          this.configError = null;
+          const envConfig = this.getEnvConfig();
+          const cookieConfig = this.getCookieConfig();
+          const configSource = {
+            env: "default",
+            publicApiKey: "default",
+            loginActions: "default",
+            appName: "default",
+            logo: "default",
+            colors: "default"
+          };
+          const env = this.resolveValue("env", propsConfig.env, envConfig.env, cookieConfig.env, "prod", configSource);
+          const publicApiKey = this.resolveValue("publicApiKey", propsConfig.publicApiKey, envConfig.publicApiKey, cookieConfig.publicApiKey, void 0, configSource);
+          const loginActions = this.resolveValue("loginActions", propsConfig.loginActions, envConfig.loginActions, cookieConfig.loginActions, [], configSource);
+          const appName = this.resolveValue("appName", propsConfig.appName, envConfig.appName, cookieConfig.appName, "Crudify App", configSource);
+          const logo = this.resolveValue("logo", propsConfig.logo, envConfig.logo, cookieConfig.logo, "", configSource);
+          const colors = this.resolveValue("colors", propsConfig.colors, envConfig.colors, cookieConfig.colors, {}, configSource);
+          if (!publicApiKey) {
+            throw new Error(
+              "publicApiKey is required. Provide it via:\n1. Props: <CrudifyDataProvider publicApiKey={...} />\n2. Environment: VITE_TEST_PUBLIC_API_KEY\n3. Cookie: publicApiKey"
+            );
+          }
+          this.resolvedConfig = {
+            env,
+            publicApiKey,
+            loginActions,
+            appName,
+            logo,
+            colors,
+            configSource,
+            rawConfig: {
+              props: propsConfig,
+              env: envConfig,
+              cookies: cookieConfig
+            }
+          };
+          console.log("\u{1F527} ConfigurationManager - Configuration resolved:", {
+            config: {
+              env: this.resolvedConfig.env,
+              publicApiKey: `${this.resolvedConfig.publicApiKey.substring(0, 8)}...`,
+              appName: this.resolvedConfig.appName,
+              loginActionsCount: this.resolvedConfig.loginActions.length
+            },
+            sources: this.resolvedConfig.configSource
+          });
+          return this.resolvedConfig;
+        } catch (error) {
+          this.configError = error instanceof Error ? error.message : "Unknown configuration error";
+          console.error("\u{1F527} ConfigurationManager - Configuration error:", this.configError);
+          this.resolvedConfig = {
+            env: "prod",
+            publicApiKey: "",
+            loginActions: [],
+            appName: "Crudify App",
+            logo: "",
+            colors: {},
+            configSource: {
+              env: "default",
+              publicApiKey: "default",
+              loginActions: "default",
+              appName: "default",
+              logo: "default",
+              colors: "default"
+            },
+            rawConfig: {
+              props: propsConfig,
+              env: {},
+              cookies: {},
+              error: this.configError
+            }
+          };
+          return this.resolvedConfig;
+        }
+      }
+      /**
+       * Check if current configuration is still valid for the given props
+       */
+      isConfigStillValid(propsConfig) {
+        if (!this.resolvedConfig) return false;
+        const currentProps = this.resolvedConfig.rawConfig.props;
+        return JSON.stringify(currentProps) === JSON.stringify(propsConfig);
+      }
+      /**
+       * Resolve a single config value with priority and source tracking
+       */
+      resolveValue(key, propsValue, envValue, cookieValue, defaultValue, configSource) {
+        if (propsValue !== void 0) {
+          configSource[key] = "props";
+          return propsValue;
+        }
+        if (envValue !== void 0) {
+          configSource[key] = "env";
+          return envValue;
+        }
+        if (cookieValue !== void 0) {
+          configSource[key] = "cookies";
+          return cookieValue;
+        }
+        configSource[key] = "default";
+        return defaultValue;
+      }
+      /**
+       * Get configuration from environment variables
+       */
+      getEnvConfig() {
+        const config = {};
+        try {
+        } catch (error) {
+          console.warn("\u{1F527} ConfigurationManager - Environment variables not available:", error);
+        }
+        return config;
+      }
+      /**
+       * Get configuration from cookies (multi-tenant support)
+       */
+      getCookieConfig() {
+        const config = {};
+        try {
+          const env = getCookie("environment");
+          if (env && ["dev", "stg", "prod"].includes(env)) {
+            config.env = env;
+          }
+          const publicApiKey = getCookie("publicApiKey");
+          if (publicApiKey) {
+            config.publicApiKey = publicApiKey;
+          }
+          const appName = getCookie("appName");
+          if (appName) {
+            config.appName = appName;
+          }
+          const loginActions = getCookie("loginActions");
+          if (loginActions) {
+            config.loginActions = loginActions.split(",").map((action) => action.trim()).filter(Boolean);
+          }
+          const logo = getCookie("logo");
+          if (logo) {
+            config.logo = logo;
+          }
+          const colors = getCookie("colors");
+          if (colors) {
+            try {
+              config.colors = JSON.parse(colors);
+            } catch (error) {
+              console.warn("\u{1F527} ConfigurationManager - Failed to parse colors from cookie:", error);
+            }
+          }
+        } catch (error) {
+          console.warn("\u{1F527} ConfigurationManager - Error reading cookies:", error);
+        }
+        return config;
+      }
+      /**
+       * Get the current resolved configuration
+       */
+      getConfig() {
+        return this.resolvedConfig;
+      }
+      /**
+       * Get any configuration errors
+       */
+      getConfigError() {
+        return this.configError;
+      }
+      /**
+       * Check if configuration is valid (no errors and has required fields)
+       */
+      isConfigured() {
+        return this.resolvedConfig !== null && this.configError === null && !!this.resolvedConfig.publicApiKey;
+      }
+      /**
+       * Clear the current configuration (useful for testing or reconfiguration)
+       */
+      clearConfig() {
+        this.resolvedConfig = null;
+        this.configError = null;
+      }
+    };
+    _ConfigurationManager.instance = null;
+    ConfigurationManager = _ConfigurationManager;
+    configurationManager = ConfigurationManager.getInstance();
+  }
+});
+
+// src/core/CrudifyInitializer.ts
+var import_crudify_browser2, _CrudifyInitializer, CrudifyInitializer, crudifyInitializer;
+var init_CrudifyInitializer = __esm({
+  "src/core/CrudifyInitializer.ts"() {
+    "use strict";
+    import_crudify_browser2 = __toESM(require("@nocios/crudify-browser"));
+    _CrudifyInitializer = class _CrudifyInitializer {
+      constructor() {
+        this.state = {
+          isInitialized: false,
+          isInitializing: false,
+          initializationError: null,
+          config: null,
+          initializationPromise: null
+        };
+        console.log("\u{1F680} CrudifyInitializer - Instance created");
+      }
+      /**
+       * Singleton pattern to ensure global initialization coordination
+       */
+      static getInstance() {
+        if (!_CrudifyInitializer.instance) {
+          _CrudifyInitializer.instance = new _CrudifyInitializer();
+        }
+        return _CrudifyInitializer.instance;
+      }
+      /**
+       * Reset the singleton instance (useful for testing)
+       */
+      static resetInstance() {
+        _CrudifyInitializer.instance = null;
+      }
+      /**
+       * Initialize crudify with the given configuration
+       * This method is idempotent and thread-safe
+       */
+      async initialize(config) {
+        if (this.state.isInitialized && this.isConfigurationSame(config)) {
+          console.log("\u{1F680} CrudifyInitializer - Already initialized with same config");
+          return;
+        }
+        if (this.state.isInitializing && this.state.initializationPromise) {
+          console.log("\u{1F680} CrudifyInitializer - Waiting for ongoing initialization");
+          await this.state.initializationPromise;
+          return;
+        }
+        if (this.state.isInitialized && !this.isConfigurationSame(config)) {
+          console.log("\u{1F680} CrudifyInitializer - Configuration changed, re-initializing");
+          this.reset();
+        }
+        this.state.isInitializing = true;
+        this.state.initializationError = null;
+        this.state.initializationPromise = this.performInitialization(config);
+        try {
+          await this.state.initializationPromise;
+          this.state.isInitialized = true;
+          this.state.config = { ...config };
+          console.log("\u{1F680} CrudifyInitializer - Initialization completed successfully");
+        } catch (error) {
+          this.state.initializationError = error instanceof Error ? error.message : "Unknown initialization error";
+          console.error("\u{1F680} CrudifyInitializer - Initialization failed:", this.state.initializationError);
+          throw error;
+        } finally {
+          this.state.isInitializing = false;
+          this.state.initializationPromise = null;
+        }
+      }
+      /**
+       * Perform the actual initialization process
+       */
+      async performInitialization(config) {
+        if (!config.publicApiKey) {
+          throw new Error("publicApiKey is required for crudify initialization");
+        }
+        console.log("\u{1F680} CrudifyInitializer - Starting initialization with config:", {
+          env: config.env,
+          publicApiKey: `${config.publicApiKey.substring(0, 8)}...`,
+          appName: config.appName
+        });
+        try {
+          const environment = config.env || "prod";
+          console.log("\u{1F680} CrudifyInitializer - Step 1: Configuring environment:", environment);
+          await import_crudify_browser2.default.config(environment);
+          console.log("\u{1F680} CrudifyInitializer - Step 2: Initializing with API key");
+          await import_crudify_browser2.default.init(config.publicApiKey, "none");
+          console.log("\u{1F680} CrudifyInitializer - Step 3: Verifying initialization");
+          await this.verifyInitialization();
+          console.log("\u{1F680} CrudifyInitializer - All initialization steps completed");
+        } catch (error) {
+          console.error("\u{1F680} CrudifyInitializer - Initialization failed at step:", error);
+          throw new Error(
+            `Crudify initialization failed: ${error instanceof Error ? error.message : "Unknown error"}. Please check your configuration (env: ${config.env || "prod"}, publicApiKey: ${config.publicApiKey ? "provided" : "missing"})`
+          );
+        }
+      }
+      /**
+       * Verify that crudify is properly initialized by checking core methods
+       */
+      async verifyInitialization() {
+        const requiredMethods = ["readItems", "readItem", "createItem", "updateItem", "deleteItem", "login", "transaction"];
+        const missingMethods = [];
+        for (const method of requiredMethods) {
+          if (typeof import_crudify_browser2.default[method] !== "function") {
+            missingMethods.push(method);
+          }
+        }
+        if (missingMethods.length > 0) {
+          throw new Error(
+            `Crudify initialization incomplete. Missing methods: ${missingMethods.join(", ")}. This usually indicates a configuration or network issue.`
+          );
+        }
+        console.log("\u{1F680} CrudifyInitializer - Verification successful (test call skipped for performance)");
+      }
+      /**
+       * Check if the given configuration is the same as the current one
+       */
+      isConfigurationSame(config) {
+        if (!this.state.config) return false;
+        return this.state.config.env === config.env && this.state.config.publicApiKey === config.publicApiKey;
+      }
+      /**
+       * Reset the initialization state (useful for testing or configuration changes)
+       */
+      reset() {
+        console.log("\u{1F680} CrudifyInitializer - Resetting initialization state");
+        this.state = {
+          isInitialized: false,
+          isInitializing: false,
+          initializationError: null,
+          config: null,
+          initializationPromise: null
+        };
+      }
+      /**
+       * Get the current initialization status
+       */
+      getStatus() {
+        return {
+          isInitialized: this.state.isInitialized,
+          isInitializing: this.state.isInitializing,
+          initializationError: this.state.initializationError,
+          config: this.state.config
+        };
+      }
+      /**
+       * Check if crudify is ready to use
+       */
+      isReady() {
+        return this.state.isInitialized && !this.state.initializationError;
+      }
+      /**
+       * Get the current initialization error, if any
+       */
+      getError() {
+        return this.state.initializationError;
+      }
+      /**
+       * Force re-initialization (useful when configuration changes)
+       */
+      async reinitialize(config) {
+        console.log("\u{1F680} CrudifyInitializer - Forcing re-initialization");
+        this.reset();
+        await this.initialize(config);
+      }
+      /**
+       * Check if initialization is currently in progress
+       */
+      isInitializing() {
+        return this.state.isInitializing;
+      }
+      /**
+       * Wait for any ongoing initialization to complete
+       */
+      async waitForInitialization() {
+        if (this.state.initializationPromise) {
+          await this.state.initializationPromise;
+        }
+      }
+    };
+    _CrudifyInitializer.instance = null;
+    CrudifyInitializer = _CrudifyInitializer;
+    crudifyInitializer = CrudifyInitializer.getInstance();
+  }
+});
+
+// src/utils/jwtUtils.ts
+var decodeJwtSafely, getCurrentUserEmail, isTokenExpired;
+var init_jwtUtils = __esm({
+  "src/utils/jwtUtils.ts"() {
+    "use strict";
+    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;
+      }
+    };
+    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;
+      }
+    };
+    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 import_crudify_browser3, _TokenManager, TokenManager, tokenManager;
+var init_TokenManager = __esm({
+  "src/core/TokenManager.ts"() {
+    "use strict";
+    import_crudify_browser3 = __toESM(require("@nocios/crudify-browser"));
+    init_secureStorage();
+    init_jwtUtils();
+    _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 localStorage to sessionStorage for better security
+       * 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 && !secureSessionStorage.getToken()) {
+              console.log(`\u{1F510} TokenManager - Migrating token from localStorage key: ${key}`);
+              secureSessionStorage.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 session storage");
+          const storedToken = secureSessionStorage.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");
+          secureSessionStorage.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");
+          secureSessionStorage.removeItem(this.TOKEN_KEY);
+          console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Clearing from crudify");
+          import_crudify_browser3.default.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 {
+          import_crudify_browser3.default.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;
+    TokenManager = _TokenManager;
+    tokenManager = TokenManager.getInstance();
+  }
+});
+
+// src/providers/CrudifyDataProvider.tsx
+var CrudifyDataProvider_exports = {};
+__export(CrudifyDataProvider_exports, {
+  CrudifyDataProvider: () => CrudifyDataProvider,
+  configurationManager: () => configurationManager,
+  crudifyInitializer: () => crudifyInitializer,
+  tokenManager: () => tokenManager,
+  useCrudifyDataContext: () => useCrudifyDataContext
+});
+var import_react5, import_jsx_runtime4, CrudifyDataContext, CrudifyDataProvider, useCrudifyDataContext;
+var init_CrudifyDataProvider = __esm({
+  "src/providers/CrudifyDataProvider.tsx"() {
+    "use strict";
+    import_react5 = require("react");
+    init_ConfigurationManager();
+    init_CrudifyInitializer();
+    init_TokenManager();
+    import_jsx_runtime4 = require("react/jsx-runtime");
+    CrudifyDataContext = (0, import_react5.createContext)(null);
+    CrudifyDataProvider = ({
+      children,
+      env,
+      publicApiKey,
+      loginActions,
+      appName,
+      logo,
+      colors
+    }) => {
+      const [config, setConfig] = (0, import_react5.useState)(null);
+      const [isConfigured, setIsConfigured] = (0, import_react5.useState)(false);
+      const [configError, setConfigError] = (0, import_react5.useState)(null);
+      const [isInitialized, setIsInitialized] = (0, import_react5.useState)(false);
+      const [isInitializing, setIsInitializing] = (0, import_react5.useState)(false);
+      const [initializationError, setInitializationError] = (0, import_react5.useState)(null);
+      const [isAuthenticated, setIsAuthenticated] = (0, import_react5.useState)(false);
+      const [token, setTokenState] = (0, import_react5.useState)(null);
+      const [user, setUser] = (0, import_react5.useState)(null);
+      const [tokenExpiration, setTokenExpiration] = (0, import_react5.useState)(null);
+      const initializeConfiguration = (0, import_react5.useCallback)(() => {
+        try {
+          console.log("\u{1F30D} CrudifyDataProvider - Initializing configuration");
+          const propsConfig = {
+            env,
+            publicApiKey,
+            loginActions,
+            appName,
+            logo,
+            colors
+          };
+          const resolvedConfig = configurationManager.resolveConfig(propsConfig);
+          const error = configurationManager.getConfigError();
+          setConfig(resolvedConfig);
+          setConfigError(error);
+          setIsConfigured(configurationManager.isConfigured());
+          console.log("\u{1F30D} CrudifyDataProvider - Configuration initialized:", {
+            isConfigured: configurationManager.isConfigured(),
+            error,
+            sources: resolvedConfig.configSource
+          });
+          return resolvedConfig;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Configuration initialization failed";
+          console.error("\u{1F30D} CrudifyDataProvider - Configuration error:", errorMessage);
+          setConfigError(errorMessage);
+          setIsConfigured(false);
+          return null;
+        }
+      }, [env, publicApiKey, loginActions, appName, logo, colors]);
+      const initializeCrudify = (0, import_react5.useCallback)(async (resolvedConfig) => {
+        if (!resolvedConfig || !resolvedConfig.publicApiKey) {
+          setInitializationError("Cannot initialize crudify without valid configuration");
+          return;
+        }
+        try {
+          setIsInitializing(true);
+          setInitializationError(null);
+          console.log("\u{1F680} CrudifyDataProvider - Starting crudify initialization");
+          await crudifyInitializer.initialize({
+            env: resolvedConfig.env,
+            publicApiKey: resolvedConfig.publicApiKey,
+            loginActions: resolvedConfig.loginActions,
+            appName: resolvedConfig.appName,
+            logo: resolvedConfig.logo,
+            colors: resolvedConfig.colors
+          });
+          setIsInitialized(true);
+          console.log("\u{1F680} CrudifyDataProvider - Crudify initialization completed");
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Crudify initialization failed";
+          console.error("\u{1F680} CrudifyDataProvider - Initialization error:", errorMessage);
+          setInitializationError(errorMessage);
+          setIsInitialized(false);
+        } finally {
+          setIsInitializing(false);
+        }
+      }, []);
+      const updateAuthenticationState = (0, import_react5.useCallback)(() => {
+        console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Starting authentication state update");
+        try {
+          console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Getting token from TokenManager");
+          const currentToken = tokenManager.getToken();
+          console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Token retrieved:", !!currentToken);
+          console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Parsing token");
+          const parsedUser = tokenManager.parseToken();
+          console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Token parsed:", !!parsedUser);
+          console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Getting expiration");
+          const expiration = tokenManager.getTokenExpiration();
+          console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Expiration retrieved:", !!expiration);
+          console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Checking authentication");
+          const authenticated = tokenManager.isAuthenticated();
+          console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Authentication checked:", authenticated);
+          console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Updating state variables");
+          setTokenState(currentToken);
+          setUser(parsedUser);
+          setTokenExpiration(expiration);
+          setIsAuthenticated(authenticated);
+          console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Authentication state updated successfully:", {
+            hasToken: !!currentToken,
+            isAuthenticated: authenticated,
+            userEmail: parsedUser?.email || null,
+            expiration: expiration?.toISOString() || null
+          });
+        } catch (error) {
+          console.error("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Error updating authentication state:", error);
+        }
+      }, []);
+      const setToken = (0, import_react5.useCallback)((newToken) => {
+        console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: ===== STARTING TOKEN SET =====");
+        console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: New token:", newToken ? `${newToken.substring(0, 20)}...` : "null");
+        console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: Setting token in TokenManager...");
+        tokenManager.setToken(newToken);
+        console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: Updating state using newToken directly");
+        if (newToken) {
+          const parsedUser = tokenManager.parseToken(newToken);
+          const expiration = tokenManager.getTokenExpiration();
+          const authenticated = tokenManager.isTokenValid(newToken);
+          console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: Setting state values:");
+          console.log("   - setTokenState:", newToken ? `${newToken.substring(0, 20)}...` : "null");
+          console.log("   - setUser:", parsedUser?.email || "null");
+          console.log("   - setIsAuthenticated:", authenticated);
+          setTokenState(newToken);
+          setUser(parsedUser);
+          setTokenExpiration(expiration);
+          setIsAuthenticated(authenticated);
+          console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: \u2705 Token set, state updated", {
+            hasToken: true,
+            isAuthenticated: authenticated,
+            userEmail: parsedUser?.email || null
+          });
+        } else {
+          console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: Clearing all states");
+          setTokenState(null);
+          setUser(null);
+          setTokenExpiration(null);
+          setIsAuthenticated(false);
+          console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: \u2705 Token cleared, state reset");
+        }
+        console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: ===== TOKEN SET COMPLETE =====");
+      }, []);
+      const logout = (0, import_react5.useCallback)(() => {
+        console.log("\u{1F510} CrudifyDataProvider - LOGOUT_CALLBACK: Logging out user");
+        tokenManager.clearToken();
+        console.log("\u{1F510} CrudifyDataProvider - LOGOUT_CALLBACK: Updating state directly");
+        setTokenState(null);
+        setUser(null);
+        setTokenExpiration(null);
+        setIsAuthenticated(false);
+        console.log("\u{1F510} CrudifyDataProvider - LOGOUT_CALLBACK: User logged out, state cleared");
+      }, []);
+      const refreshConfig = (0, import_react5.useCallback)(() => {
+        console.log("\u{1F30D} CrudifyDataProvider - Refreshing configuration");
+        configurationManager.clearConfig();
+        const newConfig = initializeConfiguration();
+        if (newConfig && newConfig.publicApiKey) {
+          initializeCrudify(newConfig);
+        }
+      }, [initializeConfiguration, initializeCrudify]);
+      const reinitialize = (0, import_react5.useCallback)(async () => {
+        if (!config || !config.publicApiKey) {
+          console.warn("\u{1F680} CrudifyDataProvider - Cannot reinitialize without valid configuration");
+          return;
+        }
+        console.log("\u{1F680} CrudifyDataProvider - Force reinitializing crudify");
+        crudifyInitializer.reset();
+        await initializeCrudify(config);
+      }, [config, initializeCrudify]);
+      const getDebugInfo = (0, import_react5.useCallback)(() => {
+        return {
+          provider: {
+            isConfigured,
+            configError,
+            isInitialized,
+            isInitializing,
+            initializationError,
+            isAuthenticated
+          },
+          configuration: {
+            config: config ? {
+              env: config.env,
+              publicApiKey: `${config.publicApiKey.substring(0, 8)}...`,
+              appName: config.appName,
+              loginActionsCount: config.loginActions.length,
+              hasLogo: !!config.logo,
+              colorsCount: Object.keys(config.colors).length
+            } : null,
+            sources: config?.configSource || null,
+            rawConfig: config?.rawConfig || null
+          },
+          authentication: {
+            hasToken: !!token,
+            tokenLength: token?.length || 0,
+            userEmail: user?.email || null,
+            userId: user?.sub || null,
+            expiration: tokenExpiration?.toISOString() || null,
+            minutesUntilExpiry: tokenManager.getTimeUntilExpiration()
+          },
+          tokenManager: tokenManager.getDebugInfo(),
+          crudifyInitializer: crudifyInitializer.getStatus()
+        };
+      }, [isConfigured, configError, isInitialized, isInitializing, initializationError, isAuthenticated, config, token, user, tokenExpiration]);
+      (0, import_react5.useEffect)(() => {
+        console.log("\u{1F30D} CrudifyDataProvider - Provider mounting, starting initialization");
+        const resolvedConfig = initializeConfiguration();
+        updateAuthenticationState();
+        if (resolvedConfig && resolvedConfig.publicApiKey) {
+          initializeCrudify(resolvedConfig);
+        }
+        return () => {
+          console.log("\u{1F30D} CrudifyDataProvider - Provider unmounting, cleaning up");
+          tokenManager.cleanup();
+        };
+      }, []);
+      (0, import_react5.useEffect)(() => {
+        console.log("\u{1F510} CrudifyDataProvider - INITIAL_AUTH_EFFECT: Loading initial authentication state");
+        updateAuthenticationState();
+      }, []);
+      const contextValue = {
+        // Configuration
+        config,
+        isConfigured,
+        configError,
+        configSource: config ? JSON.stringify(config.configSource) : "none",
+        // Initialization
+        isInitialized,
+        isInitializing,
+        initializationError,
+        // Authentication
+        isAuthenticated,
+        token,
+        user,
+        tokenExpiration,
+        // Actions
+        setToken,
+        logout,
+        refreshConfig,
+        reinitialize,
+        // Debug
+        getDebugInfo
+      };
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(CrudifyDataContext.Provider, { value: contextValue, children });
+    };
+    useCrudifyDataContext = () => {
+      const context = (0, import_react5.useContext)(CrudifyDataContext);
+      if (!context) {
+        throw new Error(
+          "useCrudifyDataContext must be used within a CrudifyDataProvider. Make sure to wrap your app with <CrudifyDataProvider>."
+        );
+      }
+      return context;
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -41,6 +1249,8 @@ __export(index_exports, {
   crudifyInitializer: () => crudifyInitializer,
   decodeJwtSafely: () => decodeJwtSafely,
   getCookie: () => getCookie,
+  getCrudifyInstanceAsync: () => getCrudifyInstanceAsync,
+  getCrudifyInstanceSync: () => getCrudifyInstanceSync,
   getCurrentUserEmail: () => getCurrentUserEmail,
   getErrorMessage: () => getErrorMessage,
   handleCrudifyError: () => handleCrudifyError,
@@ -218,14 +1428,7 @@ var useCrudify = () => {
 
 // src/components/CrudifyLogin/context/LoginStateProvider.tsx
 var import_react4 = require("react");
-
-// src/components/CrudifyLogin/utils/cookies.ts
-var getCookie = (name) => {
-  const match = document.cookie.match(new RegExp("(^|;)\\s*" + name + "=([^;]+)"));
-  return match ? match[2] : null;
-};
-
-// src/components/CrudifyLogin/context/LoginStateProvider.tsx
+init_cookies();
 var import_jsx_runtime3 = require("react/jsx-runtime");
 var initialState = {
   currentScreen: "login",
@@ -450,115 +1653,7 @@ var useLoginState = () => {
 // src/components/CrudifyLogin/Forms/LoginForm.tsx
 var import_react6 = require("react");
 var import_material = require("@mui/material");
-
-// src/components/CrudifyLogin/utils/secureStorage.ts
-var import_crypto_js = __toESM(require("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 import_crypto_js.default.SHA256(browserFingerprint).toString();
-  }
-  setItem(key, value, expiryMinutes) {
-    try {
-      const encrypted = import_crypto_js.default.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 = import_crypto_js.default.AES.decrypt(encrypted, this.encryptionKey);
-      const result = decrypted.toString(import_crypto_js.default.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");
+init_secureStorage();
 
 // src/utils/errorHandler.ts
 var ERROR_CODES = {
@@ -673,1202 +1768,165 @@ function parseApiError(response) {
               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
-              });
-            }
-          }
-        });
-      }
-    }
-    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 }
-          });
-        }
-      });
-      return errors;
-    }
-    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"
-      };
-    }
-    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 {
-      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-      message: error.message || "An unexpected error occurred",
-      severity: "error",
-      details: { originalError: error }
-    };
-  }
-  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);
-    }
-    return parseApiError(error);
-  }
-  return [
-    {
-      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-      message: "An unknown error occurred",
-      severity: "error",
-      details: { originalError: error }
-    }
-  ];
-}
-
-// src/providers/CrudifyDataProvider.tsx
-var import_react5 = require("react");
-
-// src/core/ConfigurationManager.ts
-var _ConfigurationManager = class _ConfigurationManager {
-  constructor() {
-    this.resolvedConfig = null;
-    this.configError = null;
-  }
-  /**
-   * Singleton pattern to ensure consistent configuration across the app
-   */
-  static getInstance() {
-    if (!_ConfigurationManager.instance) {
-      _ConfigurationManager.instance = new _ConfigurationManager();
-    }
-    return _ConfigurationManager.instance;
-  }
-  /**
-   * Reset the singleton instance (useful for testing)
-   */
-  static resetInstance() {
-    _ConfigurationManager.instance = null;
-  }
-  /**
-   * Resolve configuration from all sources with proper priority
-   */
-  resolveConfig(propsConfig = {}) {
-    if (this.resolvedConfig && this.isConfigStillValid(propsConfig)) {
-      return this.resolvedConfig;
-    }
-    try {
-      this.configError = null;
-      const envConfig = this.getEnvConfig();
-      const cookieConfig = this.getCookieConfig();
-      const configSource = {
-        env: "default",
-        publicApiKey: "default",
-        loginActions: "default",
-        appName: "default",
-        logo: "default",
-        colors: "default"
-      };
-      const env = this.resolveValue("env", propsConfig.env, envConfig.env, cookieConfig.env, "prod", configSource);
-      const publicApiKey = this.resolveValue("publicApiKey", propsConfig.publicApiKey, envConfig.publicApiKey, cookieConfig.publicApiKey, void 0, configSource);
-      const loginActions = this.resolveValue("loginActions", propsConfig.loginActions, envConfig.loginActions, cookieConfig.loginActions, [], configSource);
-      const appName = this.resolveValue("appName", propsConfig.appName, envConfig.appName, cookieConfig.appName, "Crudify App", configSource);
-      const logo = this.resolveValue("logo", propsConfig.logo, envConfig.logo, cookieConfig.logo, "", configSource);
-      const colors = this.resolveValue("colors", propsConfig.colors, envConfig.colors, cookieConfig.colors, {}, configSource);
-      if (!publicApiKey) {
-        throw new Error(
-          "publicApiKey is required. Provide it via:\n1. Props: <CrudifyDataProvider publicApiKey={...} />\n2. Environment: VITE_TEST_PUBLIC_API_KEY\n3. Cookie: publicApiKey"
-        );
-      }
-      this.resolvedConfig = {
-        env,
-        publicApiKey,
-        loginActions,
-        appName,
-        logo,
-        colors,
-        configSource,
-        rawConfig: {
-          props: propsConfig,
-          env: envConfig,
-          cookies: cookieConfig
-        }
-      };
-      console.log("\u{1F527} ConfigurationManager - Configuration resolved:", {
-        config: {
-          env: this.resolvedConfig.env,
-          publicApiKey: `${this.resolvedConfig.publicApiKey.substring(0, 8)}...`,
-          appName: this.resolvedConfig.appName,
-          loginActionsCount: this.resolvedConfig.loginActions.length
-        },
-        sources: this.resolvedConfig.configSource
-      });
-      return this.resolvedConfig;
-    } catch (error) {
-      this.configError = error instanceof Error ? error.message : "Unknown configuration error";
-      console.error("\u{1F527} ConfigurationManager - Configuration error:", this.configError);
-      this.resolvedConfig = {
-        env: "prod",
-        publicApiKey: "",
-        loginActions: [],
-        appName: "Crudify App",
-        logo: "",
-        colors: {},
-        configSource: {
-          env: "default",
-          publicApiKey: "default",
-          loginActions: "default",
-          appName: "default",
-          logo: "default",
-          colors: "default"
-        },
-        rawConfig: {
-          props: propsConfig,
-          env: {},
-          cookies: {},
-          error: this.configError
-        }
-      };
-      return this.resolvedConfig;
-    }
-  }
-  /**
-   * Check if current configuration is still valid for the given props
-   */
-  isConfigStillValid(propsConfig) {
-    if (!this.resolvedConfig) return false;
-    const currentProps = this.resolvedConfig.rawConfig.props;
-    return JSON.stringify(currentProps) === JSON.stringify(propsConfig);
-  }
-  /**
-   * Resolve a single config value with priority and source tracking
-   */
-  resolveValue(key, propsValue, envValue, cookieValue, defaultValue, configSource) {
-    if (propsValue !== void 0) {
-      configSource[key] = "props";
-      return propsValue;
-    }
-    if (envValue !== void 0) {
-      configSource[key] = "env";
-      return envValue;
-    }
-    if (cookieValue !== void 0) {
-      configSource[key] = "cookies";
-      return cookieValue;
-    }
-    configSource[key] = "default";
-    return defaultValue;
-  }
-  /**
-   * Get configuration from environment variables
-   */
-  getEnvConfig() {
-    const config = {};
-    try {
-    } catch (error) {
-      console.warn("\u{1F527} ConfigurationManager - Environment variables not available:", error);
-    }
-    return config;
-  }
-  /**
-   * Get configuration from cookies (multi-tenant support)
-   */
-  getCookieConfig() {
-    const config = {};
-    try {
-      const env = getCookie("environment");
-      if (env && ["dev", "stg", "prod"].includes(env)) {
-        config.env = env;
-      }
-      const publicApiKey = getCookie("publicApiKey");
-      if (publicApiKey) {
-        config.publicApiKey = publicApiKey;
-      }
-      const appName = getCookie("appName");
-      if (appName) {
-        config.appName = appName;
-      }
-      const loginActions = getCookie("loginActions");
-      if (loginActions) {
-        config.loginActions = loginActions.split(",").map((action) => action.trim()).filter(Boolean);
-      }
-      const logo = getCookie("logo");
-      if (logo) {
-        config.logo = logo;
-      }
-      const colors = getCookie("colors");
-      if (colors) {
-        try {
-          config.colors = JSON.parse(colors);
-        } catch (error) {
-          console.warn("\u{1F527} ConfigurationManager - Failed to parse colors from cookie:", error);
-        }
-      }
-    } catch (error) {
-      console.warn("\u{1F527} ConfigurationManager - Error reading cookies:", error);
-    }
-    return config;
-  }
-  /**
-   * Get the current resolved configuration
-   */
-  getConfig() {
-    return this.resolvedConfig;
-  }
-  /**
-   * Get any configuration errors
-   */
-  getConfigError() {
-    return this.configError;
-  }
-  /**
-   * Check if configuration is valid (no errors and has required fields)
-   */
-  isConfigured() {
-    return this.resolvedConfig !== null && this.configError === null && !!this.resolvedConfig.publicApiKey;
-  }
-  /**
-   * Clear the current configuration (useful for testing or reconfiguration)
-   */
-  clearConfig() {
-    this.resolvedConfig = null;
-    this.configError = null;
-  }
-};
-_ConfigurationManager.instance = null;
-var ConfigurationManager = _ConfigurationManager;
-var configurationManager = ConfigurationManager.getInstance();
-
-// src/core/CrudifyInitializer.ts
-var import_crudify_browser2 = __toESM(require("@nocios/crudify-browser"));
-var _CrudifyInitializer = class _CrudifyInitializer {
-  constructor() {
-    this.state = {
-      isInitialized: false,
-      isInitializing: false,
-      initializationError: null,
-      config: null,
-      initializationPromise: null
-    };
-    console.log("\u{1F680} CrudifyInitializer - Instance created");
-  }
-  /**
-   * Singleton pattern to ensure global initialization coordination
-   */
-  static getInstance() {
-    if (!_CrudifyInitializer.instance) {
-      _CrudifyInitializer.instance = new _CrudifyInitializer();
-    }
-    return _CrudifyInitializer.instance;
-  }
-  /**
-   * Reset the singleton instance (useful for testing)
-   */
-  static resetInstance() {
-    _CrudifyInitializer.instance = null;
-  }
-  /**
-   * Initialize crudify with the given configuration
-   * This method is idempotent and thread-safe
-   */
-  async initialize(config) {
-    if (this.state.isInitialized && this.isConfigurationSame(config)) {
-      console.log("\u{1F680} CrudifyInitializer - Already initialized with same config");
-      return;
-    }
-    if (this.state.isInitializing && this.state.initializationPromise) {
-      console.log("\u{1F680} CrudifyInitializer - Waiting for ongoing initialization");
-      await this.state.initializationPromise;
-      return;
-    }
-    if (this.state.isInitialized && !this.isConfigurationSame(config)) {
-      console.log("\u{1F680} CrudifyInitializer - Configuration changed, re-initializing");
-      this.reset();
-    }
-    this.state.isInitializing = true;
-    this.state.initializationError = null;
-    this.state.initializationPromise = this.performInitialization(config);
-    try {
-      await this.state.initializationPromise;
-      this.state.isInitialized = true;
-      this.state.config = { ...config };
-      console.log("\u{1F680} CrudifyInitializer - Initialization completed successfully");
-    } catch (error) {
-      this.state.initializationError = error instanceof Error ? error.message : "Unknown initialization error";
-      console.error("\u{1F680} CrudifyInitializer - Initialization failed:", this.state.initializationError);
-      throw error;
-    } finally {
-      this.state.isInitializing = false;
-      this.state.initializationPromise = null;
-    }
-  }
-  /**
-   * Perform the actual initialization process
-   */
-  async performInitialization(config) {
-    if (!config.publicApiKey) {
-      throw new Error("publicApiKey is required for crudify initialization");
-    }
-    console.log("\u{1F680} CrudifyInitializer - Starting initialization with config:", {
-      env: config.env,
-      publicApiKey: `${config.publicApiKey.substring(0, 8)}...`,
-      appName: config.appName
-    });
-    try {
-      const environment = config.env || "prod";
-      console.log("\u{1F680} CrudifyInitializer - Step 1: Configuring environment:", environment);
-      await import_crudify_browser2.default.config(environment);
-      console.log("\u{1F680} CrudifyInitializer - Step 2: Initializing with API key");
-      await import_crudify_browser2.default.init(config.publicApiKey, "none");
-      console.log("\u{1F680} CrudifyInitializer - Step 3: Verifying initialization");
-      await this.verifyInitialization();
-      console.log("\u{1F680} CrudifyInitializer - All initialization steps completed");
-    } catch (error) {
-      console.error("\u{1F680} CrudifyInitializer - Initialization failed at step:", error);
-      throw new Error(
-        `Crudify initialization failed: ${error instanceof Error ? error.message : "Unknown error"}. Please check your configuration (env: ${config.env || "prod"}, publicApiKey: ${config.publicApiKey ? "provided" : "missing"})`
-      );
-    }
-  }
-  /**
-   * Verify that crudify is properly initialized by checking core methods
-   */
-  async verifyInitialization() {
-    const requiredMethods = ["readItems", "readItem", "createItem", "updateItem", "deleteItem", "login", "transaction"];
-    const missingMethods = [];
-    for (const method of requiredMethods) {
-      if (typeof import_crudify_browser2.default[method] !== "function") {
-        missingMethods.push(method);
-      }
-    }
-    if (missingMethods.length > 0) {
-      throw new Error(
-        `Crudify initialization incomplete. Missing methods: ${missingMethods.join(", ")}. This usually indicates a configuration or network issue.`
-      );
-    }
-    console.log("\u{1F680} CrudifyInitializer - Verification successful (test call skipped for performance)");
-  }
-  /**
-   * Check if the given configuration is the same as the current one
-   */
-  isConfigurationSame(config) {
-    if (!this.state.config) return false;
-    return this.state.config.env === config.env && this.state.config.publicApiKey === config.publicApiKey;
-  }
-  /**
-   * Reset the initialization state (useful for testing or configuration changes)
-   */
-  reset() {
-    console.log("\u{1F680} CrudifyInitializer - Resetting initialization state");
-    this.state = {
-      isInitialized: false,
-      isInitializing: false,
-      initializationError: null,
-      config: null,
-      initializationPromise: null
-    };
-  }
-  /**
-   * Get the current initialization status
-   */
-  getStatus() {
-    return {
-      isInitialized: this.state.isInitialized,
-      isInitializing: this.state.isInitializing,
-      initializationError: this.state.initializationError,
-      config: this.state.config
-    };
-  }
-  /**
-   * Check if crudify is ready to use
-   */
-  isReady() {
-    return this.state.isInitialized && !this.state.initializationError;
-  }
-  /**
-   * Get the current initialization error, if any
-   */
-  getError() {
-    return this.state.initializationError;
-  }
-  /**
-   * Force re-initialization (useful when configuration changes)
-   */
-  async reinitialize(config) {
-    console.log("\u{1F680} CrudifyInitializer - Forcing re-initialization");
-    this.reset();
-    await this.initialize(config);
-  }
-  /**
-   * Check if initialization is currently in progress
-   */
-  isInitializing() {
-    return this.state.isInitializing;
-  }
-  /**
-   * Wait for any ongoing initialization to complete
-   */
-  async waitForInitialization() {
-    if (this.state.initializationPromise) {
-      await this.state.initializationPromise;
-    }
-  }
-};
-_CrudifyInitializer.instance = null;
-var CrudifyInitializer = _CrudifyInitializer;
-var crudifyInitializer = CrudifyInitializer.getInstance();
-
-// src/core/TokenManager.ts
-var import_crudify_browser3 = __toESM(require("@nocios/crudify-browser"));
-
-// 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 localStorage to sessionStorage for better security
-   * 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 && !secureSessionStorage.getToken()) {
-          console.log(`\u{1F510} TokenManager - Migrating token from localStorage key: ${key}`);
-          secureSessionStorage.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 session storage");
-      const storedToken = secureSessionStorage.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;
+                  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
+              });
+            }
+          }
+        });
       }
-      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");
-      secureSessionStorage.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");
+    if (errors.length === 0 && apiResponse.success === false) {
+      errors.push({
+        code: ERROR_CODES.BAD_REQUEST,
+        message: "Request failed",
+        severity: "warning"
+      });
     }
-    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;
+  } catch (error) {
+    errors.push({
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+      message: "Failed to parse error response",
+      severity: "error",
+      details: { originalError: error }
+    });
   }
-  /**
-   * 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;
+  return errors.length > 0 ? errors : [
+    {
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+      message: "Unknown error occurred",
+      severity: "error"
     }
-  }
-  /**
-   * 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");
-      secureSessionStorage.removeItem(this.TOKEN_KEY);
-      console.log("\u{1F510} TokenManager - CLEAR_TOKEN: Clearing from crudify");
-      import_crudify_browser3.default.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);
+  ];
+}
+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;
     }
+    return parseApiError(response);
+  } catch (error) {
+    return [
+      {
+        code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+        message: "Failed to parse transaction error",
+        severity: "error",
+        details: { originalError: error }
+      }
+    ];
   }
-  /**
-   * Synchronize token with crudify library
-   */
-  syncTokenWithCrudify(token) {
-    try {
-      import_crudify_browser3.default.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);
+}
+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"
+      };
     }
-  }
-  /**
-   * 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) {
+    if (error.message.includes("NetworkError") || error.message.includes("Failed to fetch")) {
       return {
-        email: null,
-        userId: null,
-        userIdentifier: null,
-        username: null
+        code: ERROR_CODES.NETWORK_ERROR,
+        message: getErrorMessage(ERROR_CODES.NETWORK_ERROR),
+        severity: "error"
       };
     }
     return {
-      email: parsed.email || null,
-      userId: parsed.sub || null,
-      userIdentifier: parsed["cognito:username"] || parsed.email || parsed.sub || null,
-      username: parsed["cognito:username"] || null
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+      message: error.message || "An unexpected error occurred",
+      severity: "error",
+      details: { originalError: error }
     };
   }
-  /**
-   * 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) : []
-    };
+  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)];
   }
-};
-_TokenManager.instance = null;
-var TokenManager = _TokenManager;
-var tokenManager = TokenManager.getInstance();
-
-// src/providers/CrudifyDataProvider.tsx
-var import_jsx_runtime4 = require("react/jsx-runtime");
-var CrudifyDataContext = (0, import_react5.createContext)(null);
-var CrudifyDataProvider = ({
-  children,
-  env,
-  publicApiKey,
-  loginActions,
-  appName,
-  logo,
-  colors
-}) => {
-  const [config, setConfig] = (0, import_react5.useState)(null);
-  const [isConfigured, setIsConfigured] = (0, import_react5.useState)(false);
-  const [configError, setConfigError] = (0, import_react5.useState)(null);
-  const [isInitialized, setIsInitialized] = (0, import_react5.useState)(false);
-  const [isInitializing, setIsInitializing] = (0, import_react5.useState)(false);
-  const [initializationError, setInitializationError] = (0, import_react5.useState)(null);
-  const [isAuthenticated, setIsAuthenticated] = (0, import_react5.useState)(false);
-  const [token, setTokenState] = (0, import_react5.useState)(null);
-  const [user, setUser] = (0, import_react5.useState)(null);
-  const [tokenExpiration, setTokenExpiration] = (0, import_react5.useState)(null);
-  const initializeConfiguration = (0, import_react5.useCallback)(() => {
-    try {
-      console.log("\u{1F30D} CrudifyDataProvider - Initializing configuration");
-      const propsConfig = {
-        env,
-        publicApiKey,
-        loginActions,
-        appName,
-        logo,
-        colors
-      };
-      const resolvedConfig = configurationManager.resolveConfig(propsConfig);
-      const error = configurationManager.getConfigError();
-      setConfig(resolvedConfig);
-      setConfigError(error);
-      setIsConfigured(configurationManager.isConfigured());
-      console.log("\u{1F30D} CrudifyDataProvider - Configuration initialized:", {
-        isConfigured: configurationManager.isConfigured(),
-        error,
-        sources: resolvedConfig.configSource
-      });
-      return resolvedConfig;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Configuration initialization failed";
-      console.error("\u{1F30D} CrudifyDataProvider - Configuration error:", errorMessage);
-      setConfigError(errorMessage);
-      setIsConfigured(false);
-      return null;
-    }
-  }, [env, publicApiKey, loginActions, appName, logo, colors]);
-  const initializeCrudify = (0, import_react5.useCallback)(async (resolvedConfig) => {
-    if (!resolvedConfig || !resolvedConfig.publicApiKey) {
-      setInitializationError("Cannot initialize crudify without valid configuration");
-      return;
-    }
-    try {
-      setIsInitializing(true);
-      setInitializationError(null);
-      console.log("\u{1F680} CrudifyDataProvider - Starting crudify initialization");
-      await crudifyInitializer.initialize({
-        env: resolvedConfig.env,
-        publicApiKey: resolvedConfig.publicApiKey,
-        loginActions: resolvedConfig.loginActions,
-        appName: resolvedConfig.appName,
-        logo: resolvedConfig.logo,
-        colors: resolvedConfig.colors
-      });
-      setIsInitialized(true);
-      console.log("\u{1F680} CrudifyDataProvider - Crudify initialization completed");
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Crudify initialization failed";
-      console.error("\u{1F680} CrudifyDataProvider - Initialization error:", errorMessage);
-      setInitializationError(errorMessage);
-      setIsInitialized(false);
-    } finally {
-      setIsInitializing(false);
-    }
-  }, []);
-  const updateAuthenticationState = (0, import_react5.useCallback)(() => {
-    console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Starting authentication state update");
-    try {
-      console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Getting token from TokenManager");
-      const currentToken = tokenManager.getToken();
-      console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Token retrieved:", !!currentToken);
-      console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Parsing token");
-      const parsedUser = tokenManager.parseToken();
-      console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Token parsed:", !!parsedUser);
-      console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Getting expiration");
-      const expiration = tokenManager.getTokenExpiration();
-      console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Expiration retrieved:", !!expiration);
-      console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Checking authentication");
-      const authenticated = tokenManager.isAuthenticated();
-      console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Authentication checked:", authenticated);
-      console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Updating state variables");
-      setTokenState(currentToken);
-      setUser(parsedUser);
-      setTokenExpiration(expiration);
-      setIsAuthenticated(authenticated);
-      console.log("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Authentication state updated successfully:", {
-        hasToken: !!currentToken,
-        isAuthenticated: authenticated,
-        userEmail: parsedUser?.email || null,
-        expiration: expiration?.toISOString() || null
-      });
-    } catch (error) {
-      console.error("\u{1F510} CrudifyDataProvider - UPDATE_AUTH_STATE: Error updating authentication state:", error);
-    }
-  }, []);
-  const setToken = (0, import_react5.useCallback)((newToken) => {
-    console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: ===== STARTING TOKEN SET =====");
-    console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: New token:", newToken ? `${newToken.substring(0, 20)}...` : "null");
-    console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: Setting token in TokenManager...");
-    tokenManager.setToken(newToken);
-    console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: Updating state using newToken directly");
-    if (newToken) {
-      const parsedUser = tokenManager.parseToken(newToken);
-      const expiration = tokenManager.getTokenExpiration();
-      const authenticated = tokenManager.isTokenValid(newToken);
-      console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: Setting state values:");
-      console.log("   - setTokenState:", newToken ? `${newToken.substring(0, 20)}...` : "null");
-      console.log("   - setUser:", parsedUser?.email || "null");
-      console.log("   - setIsAuthenticated:", authenticated);
-      setTokenState(newToken);
-      setUser(parsedUser);
-      setTokenExpiration(expiration);
-      setIsAuthenticated(authenticated);
-      console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: \u2705 Token set, state updated", {
-        hasToken: true,
-        isAuthenticated: authenticated,
-        userEmail: parsedUser?.email || null
-      });
-    } else {
-      console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: Clearing all states");
-      setTokenState(null);
-      setUser(null);
-      setTokenExpiration(null);
-      setIsAuthenticated(false);
-      console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: \u2705 Token cleared, state reset");
-    }
-    console.log("\u{1F510} CrudifyDataProvider - SET_TOKEN_CALLBACK: ===== TOKEN SET COMPLETE =====");
-  }, []);
-  const logout = (0, import_react5.useCallback)(() => {
-    console.log("\u{1F510} CrudifyDataProvider - LOGOUT_CALLBACK: Logging out user");
-    tokenManager.clearToken();
-    console.log("\u{1F510} CrudifyDataProvider - LOGOUT_CALLBACK: Updating state directly");
-    setTokenState(null);
-    setUser(null);
-    setTokenExpiration(null);
-    setIsAuthenticated(false);
-    console.log("\u{1F510} CrudifyDataProvider - LOGOUT_CALLBACK: User logged out, state cleared");
-  }, []);
-  const refreshConfig = (0, import_react5.useCallback)(() => {
-    console.log("\u{1F30D} CrudifyDataProvider - Refreshing configuration");
-    configurationManager.clearConfig();
-    const newConfig = initializeConfiguration();
-    if (newConfig && newConfig.publicApiKey) {
-      initializeCrudify(newConfig);
-    }
-  }, [initializeConfiguration, initializeCrudify]);
-  const reinitialize = (0, import_react5.useCallback)(async () => {
-    if (!config || !config.publicApiKey) {
-      console.warn("\u{1F680} CrudifyDataProvider - Cannot reinitialize without valid configuration");
-      return;
-    }
-    console.log("\u{1F680} CrudifyDataProvider - Force reinitializing crudify");
-    crudifyInitializer.reset();
-    await initializeCrudify(config);
-  }, [config, initializeCrudify]);
-  const getDebugInfo = (0, import_react5.useCallback)(() => {
-    return {
-      provider: {
-        isConfigured,
-        configError,
-        isInitialized,
-        isInitializing,
-        initializationError,
-        isAuthenticated
-      },
-      configuration: {
-        config: config ? {
-          env: config.env,
-          publicApiKey: `${config.publicApiKey.substring(0, 8)}...`,
-          appName: config.appName,
-          loginActionsCount: config.loginActions.length,
-          hasLogo: !!config.logo,
-          colorsCount: Object.keys(config.colors).length
-        } : null,
-        sources: config?.configSource || null,
-        rawConfig: config?.rawConfig || null
-      },
-      authentication: {
-        hasToken: !!token,
-        tokenLength: token?.length || 0,
-        userEmail: user?.email || null,
-        userId: user?.sub || null,
-        expiration: tokenExpiration?.toISOString() || null,
-        minutesUntilExpiry: tokenManager.getTimeUntilExpiration()
-      },
-      tokenManager: tokenManager.getDebugInfo(),
-      crudifyInitializer: crudifyInitializer.getStatus()
-    };
-  }, [isConfigured, configError, isInitialized, isInitializing, initializationError, isAuthenticated, config, token, user, tokenExpiration]);
-  (0, import_react5.useEffect)(() => {
-    console.log("\u{1F30D} CrudifyDataProvider - Provider mounting, starting initialization");
-    const resolvedConfig = initializeConfiguration();
-    updateAuthenticationState();
-    if (resolvedConfig && resolvedConfig.publicApiKey) {
-      initializeCrudify(resolvedConfig);
+  if (typeof error === "object" && error !== null) {
+    const response = error;
+    if (response.data && Array.isArray(response.data)) {
+      return parseTransactionError(error);
     }
-    return () => {
-      console.log("\u{1F30D} CrudifyDataProvider - Provider unmounting, cleaning up");
-      tokenManager.cleanup();
-    };
-  }, []);
-  (0, import_react5.useEffect)(() => {
-    console.log("\u{1F510} CrudifyDataProvider - INITIAL_AUTH_EFFECT: Loading initial authentication state");
-    updateAuthenticationState();
-  }, []);
-  const contextValue = {
-    // Configuration
-    config,
-    isConfigured,
-    configError,
-    configSource: config ? JSON.stringify(config.configSource) : "none",
-    // Initialization
-    isInitialized,
-    isInitializing,
-    initializationError,
-    // Authentication
-    isAuthenticated,
-    token,
-    user,
-    tokenExpiration,
-    // Actions
-    setToken,
-    logout,
-    refreshConfig,
-    reinitialize,
-    // Debug
-    getDebugInfo
-  };
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(CrudifyDataContext.Provider, { value: contextValue, children });
-};
-var useCrudifyDataContext = () => {
-  const context = (0, import_react5.useContext)(CrudifyDataContext);
-  if (!context) {
-    throw new Error(
-      "useCrudifyDataContext must be used within a CrudifyDataProvider. Make sure to wrap your app with <CrudifyDataProvider>."
-    );
+    return parseApiError(error);
   }
-  return context;
-};
+  return [
+    {
+      code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+      message: "An unknown error occurred",
+      severity: "error",
+      details: { originalError: error }
+    }
+  ];
+}
 
 // src/hooks/useCrudifyAuth.ts
+init_CrudifyDataProvider();
 var useCrudifyAuth = () => {
   const {
     isAuthenticated,
@@ -2718,6 +2776,7 @@ var CrudifyInitializer2 = ({ children, fallback }) => {
 
 // src/components/CrudifyLogin/hooks/useCrudifyLogin.ts
 var import_react10 = require("react");
+init_cookies();
 var useCrudifyLogin = (config, _options = {}) => {
   const finalConfig = (0, import_react10.useMemo)(() => {
     const publicApiKey = config.publicApiKey || getCookie("publicApiKey") || null;
@@ -2844,6 +2903,7 @@ var import_icons_material = require("@mui/icons-material");
 // src/hooks/useUserProfile.ts
 var import_react11 = require("react");
 var import_crudify_browser4 = __toESM(require("@nocios/crudify-browser"));
+init_jwtUtils();
 var useUserProfile = (options = {}) => {
   const { autoFetch = true, retryOnError = false, maxRetries = 3 } = options;
   const [userProfile, setUserProfile] = (0, import_react11.useState)(null);
@@ -3144,9 +3204,13 @@ var UserProfileDisplay = ({
 };
 var UserProfileDisplay_default = UserProfileDisplay;
 
+// src/index.ts
+init_CrudifyDataProvider();
+
 // src/hooks/useCrudifyUser.ts
 var import_react13 = require("react");
 var import_crudify_browser5 = __toESM(require("@nocios/crudify-browser"));
+init_CrudifyDataProvider();
 var useCrudifyUser = (options = {}) => {
   const { autoFetch = true, retryOnError = false, maxRetries = 3 } = options;
   const {
@@ -3351,6 +3415,7 @@ var useCrudifyUser = (options = {}) => {
 // src/hooks/useCrudifyData.ts
 var import_react14 = require("react");
 var import_crudify_browser6 = __toESM(require("@nocios/crudify-browser"));
+init_CrudifyDataProvider();
 var useCrudifyData = () => {
   const {
     isInitialized,
@@ -3502,6 +3567,7 @@ var useCrudifyData = () => {
 };
 
 // src/hooks/useCrudifyConfig.ts
+init_CrudifyDataProvider();
 var useCrudifyConfig = () => {
   const {
     config,
@@ -3525,6 +3591,7 @@ var useCrudifyConfig = () => {
 // src/hooks/useCrudifyInstance.ts
 var import_react15 = require("react");
 var import_crudify_browser7 = __toESM(require("@nocios/crudify-browser"));
+init_CrudifyDataProvider();
 var useCrudifyInstance = () => {
   const {
     isInitialized,
@@ -3533,28 +3600,32 @@ var useCrudifyInstance = () => {
   } = useCrudifyDataContext();
   const isReady = isInitialized && !initializationError && !isInitializing;
   const waitForReady = (0, import_react15.useCallback)(async () => {
-    if (isReady) return;
+    console.log("\u{1F504} useCrudifyInstance - waitForReady: Starting wait");
+    console.log("   - isReady:", isReady);
+    console.log("   - isInitialized:", isInitialized);
+    console.log("   - isInitializing:", isInitializing);
+    console.log("   - initializationError:", initializationError);
+    if (isReady) {
+      console.log("\u2705 useCrudifyInstance - waitForReady: Already ready, returning immediately");
+      return;
+    }
     if (initializationError) {
       throw new Error(`Crudify initialization failed: ${initializationError}`);
     }
-    return new Promise((resolve, reject) => {
-      const maxWaitTime = 1e4;
-      const checkInterval = 100;
-      let elapsed = 0;
-      const check = () => {
-        if (isInitialized && !initializationError && !isInitializing) {
-          resolve();
-        } else if (initializationError) {
-          reject(new Error(`Crudify initialization failed: ${initializationError}`));
-        } else if (elapsed >= maxWaitTime) {
-          reject(new Error("Timeout waiting for crudify initialization"));
-        } else {
-          elapsed += checkInterval;
-          setTimeout(check, checkInterval);
-        }
-      };
-      check();
-    });
+    try {
+      console.log("\u{1F504} useCrudifyInstance - waitForReady: Using CrudifyInitializer.waitForInitialization()");
+      const { crudifyInitializer: crudifyInitializer2 } = await Promise.resolve().then(() => (init_CrudifyDataProvider(), CrudifyDataProvider_exports));
+      await crudifyInitializer2.waitForInitialization();
+      console.log("\u2705 useCrudifyInstance - waitForReady: CrudifyInitializer completed");
+      if (!crudifyInitializer2.isReady()) {
+        const error = crudifyInitializer2.getError();
+        throw new Error(`Crudify initialization failed: ${error || "Unknown error"}`);
+      }
+      console.log("\u2705 useCrudifyInstance - waitForReady: Verification successful");
+    } catch (error) {
+      console.error("\u274C useCrudifyInstance - waitForReady: Error during wait:", error);
+      throw error;
+    }
   }, [isReady, initializationError, isInitialized, isInitializing]);
   const ensureReady = (0, import_react15.useCallback)(async (operationName) => {
     if (!isReady) {
@@ -3683,6 +3754,39 @@ var useCrudifyInstance = () => {
     waitForReady
   };
 };
+var getCrudifyInstanceAsync = async () => {
+  console.log("\u{1F504} getCrudifyInstanceAsync - Starting");
+  const { crudifyInitializer: crudifyInitializer2 } = await Promise.resolve().then(() => (init_CrudifyDataProvider(), CrudifyDataProvider_exports));
+  console.log("\u{1F504} getCrudifyInstanceAsync - Checking if ready");
+  console.log("   - crudifyInitializer.isReady():", crudifyInitializer2.isReady());
+  console.log("   - crudifyInitializer.getStatus():", crudifyInitializer2.getStatus());
+  if (!crudifyInitializer2.isReady()) {
+    console.log("\u{1F504} getCrudifyInstanceAsync - Waiting for crudify initialization...");
+    await crudifyInitializer2.waitForInitialization();
+    if (!crudifyInitializer2.isReady()) {
+      const error = crudifyInitializer2.getError();
+      throw new Error(`Crudify initialization failed: ${error || "Unknown error after waiting"}`);
+    }
+    console.log("\u2705 getCrudifyInstanceAsync - Crudify is ready after waiting");
+  } else {
+    console.log("\u2705 getCrudifyInstanceAsync - Already ready, no wait needed");
+  }
+  console.log("\u2705 getCrudifyInstanceAsync - Returning crudify instance");
+  return import_crudify_browser7.default;
+};
+var getCrudifyInstanceSync = async () => {
+  const { crudifyInitializer: crudifyInitializer2 } = await Promise.resolve().then(() => (init_CrudifyDataProvider(), CrudifyDataProvider_exports));
+  if (!crudifyInitializer2.isReady()) {
+    throw new Error("Crudify not ready. Use getCrudifyInstanceAsync() or call this from within a React component using useCrudifyInstance()");
+  }
+  return import_crudify_browser7.default;
+};
+
+// src/index.ts
+init_CrudifyDataProvider();
+init_jwtUtils();
+init_cookies();
+init_secureStorage();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CrudifyDataProvider,
@@ -3695,6 +3799,8 @@ var useCrudifyInstance = () => {
   crudifyInitializer,
   decodeJwtSafely,
   getCookie,
+  getCrudifyInstanceAsync,
+  getCrudifyInstanceSync,
   getCurrentUserEmail,
   getErrorMessage,
   handleCrudifyError,