@nocios/crudify-ui 2.0.0 → 3.0.0

package/dist/chunk-M7V4UGCN.mjs

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