@a-cube-io/ereceipts-js-sdk 1.0.0

package/dist/chunk-24ZJ6SNG.cjs

@@ -0,0 +1,624 @@
+'use strict';
+
+var chunkXQKCXG4I_cjs = require('./chunk-XQKCXG4I.cjs');
+var AsyncStorage = require('@react-native-async-storage/async-storage');
+var Keychain = require('react-native-keychain');
+var idbKeyval = require('idb-keyval');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var AsyncStorage__default = /*#__PURE__*/_interopDefault(AsyncStorage);
+var Keychain__namespace = /*#__PURE__*/_interopNamespace(Keychain);
+
+/* A-Cube SDK - Professional TypeScript SDK for Italian e-receipt system */
+
+// src/utils/logger.ts
+var LogLevel = /* @__PURE__ */ function(LogLevel2) {
+  LogLevel2[LogLevel2["ERROR"] = 0] = "ERROR";
+  LogLevel2[LogLevel2["WARN"] = 1] = "WARN";
+  LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 3] = "DEBUG";
+  return LogLevel2;
+}({});
+var _a;
+var Logger = (_a = class {
+  constructor() {
+    chunkXQKCXG4I_cjs.__publicField(this, "level", 2);
+    chunkXQKCXG4I_cjs.__publicField(this, "enableConsoleOutput", true);
+    chunkXQKCXG4I_cjs.__publicField(this, "listeners", /* @__PURE__ */ new Set());
+    chunkXQKCXG4I_cjs.__publicField(this, "logHistory", []);
+    chunkXQKCXG4I_cjs.__publicField(this, "maxHistorySize", 1e3);
+    {
+      this.level = 3;
+    }
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  setConsoleOutput(enabled) {
+    this.enableConsoleOutput = enabled;
+  }
+  setMaxHistorySize(size) {
+    this.maxHistorySize = size;
+    this.trimHistory();
+  }
+  shouldLog(level) {
+    return level <= this.level;
+  }
+  createLogEntry(level, message, data, source) {
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      data,
+      source
+    };
+  }
+  logToConsole(entry) {
+    if (!this.enableConsoleOutput) return;
+    const prefix = `[${entry.timestamp}] ${entry.source ? `[${entry.source}]` : ""}`;
+    const message = `${prefix} ${entry.message}`;
+    switch (entry.level) {
+      case 0:
+        console.error(message, entry.data || "");
+        break;
+      case 1:
+        console.warn(message, entry.data || "");
+        break;
+      case 2:
+        console.info(message, entry.data || "");
+        break;
+      case 3:
+        console.log(message, entry.data || "");
+        break;
+    }
+  }
+  addToHistory(entry) {
+    this.logHistory.push(entry);
+    this.trimHistory();
+  }
+  trimHistory() {
+    if (this.logHistory.length > this.maxHistorySize) {
+      this.logHistory = this.logHistory.slice(-this.maxHistorySize);
+    }
+  }
+  notifyListeners(entry) {
+    this.listeners.forEach((listener) => {
+      try {
+        listener(entry);
+      } catch (error) {
+        console.error("Logger listener error:", error);
+      }
+    });
+  }
+  log(level, message, data, source) {
+    if (!this.shouldLog(level)) return;
+    const entry = this.createLogEntry(level, message, data, source);
+    this.logToConsole(entry);
+    this.addToHistory(entry);
+    this.notifyListeners(entry);
+  }
+  error(message, data, source) {
+    this.log(0, message, data, source);
+  }
+  warn(message, data, source) {
+    this.log(1, message, data, source);
+  }
+  info(message, data, source) {
+    this.log(2, message, data, source);
+  }
+  debug(message, data, source) {
+    this.log(3, message, data, source);
+  }
+  // API-specific logging methods
+  apiRequest(url, method, data) {
+    this.debug(`API Request: ${method.toUpperCase()} ${url}`, data, "API");
+  }
+  apiResponse(url, status, data) {
+    const level = status >= 400 ? 0 : 3;
+    this.log(level, `API Response: ${status} ${url}`, data, "API");
+  }
+  apiError(url, error) {
+    this.error(`API Error: ${url}`, error, "API");
+  }
+  // Authentication logging
+  authSuccess(method, userInfo) {
+    this.info(`Authentication successful: ${method}`, userInfo, "AUTH");
+  }
+  authFailure(method, error) {
+    this.error(`Authentication failed: ${method}`, error, "AUTH");
+  }
+  // Storage logging
+  storageSet(key, isSecure = false) {
+    this.debug(`Storage set: ${key} (secure: ${isSecure})`, void 0, "STORAGE");
+  }
+  storageGet(key, found) {
+    this.debug(`Storage get: ${key} (found: ${found})`, void 0, "STORAGE");
+  }
+  storageError(operation, key, error) {
+    this.error(`Storage ${operation} error: ${key}`, error, "STORAGE");
+  }
+  // Network logging
+  networkStateChange(isConnected, connectionType) {
+    this.info(`Network state changed: ${isConnected ? "connected" : "disconnected"}`, {
+      connectionType
+    }, "NETWORK");
+  }
+  retryAttempt(attempt, maxAttempts, delay) {
+    this.warn(`Retry attempt ${attempt}/${maxAttempts} in ${delay}ms`, void 0, "RETRY");
+  }
+  // Utility methods
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  removeListener(listener) {
+    this.listeners.delete(listener);
+  }
+  getHistory(level) {
+    if (level !== void 0) {
+      return this.logHistory.filter((entry) => entry.level === level);
+    }
+    return [
+      ...this.logHistory
+    ];
+  }
+  clearHistory() {
+    this.logHistory = [];
+  }
+  // Export logs (useful for debugging)
+  exportLogs() {
+    return this.logHistory.map((entry) => {
+      const levelName = LogLevel[entry.level];
+      const dataStr = entry.data ? ` ${JSON.stringify(entry.data)}` : "";
+      const sourceStr = entry.source ? ` [${entry.source}]` : "";
+      return `${entry.timestamp} ${levelName}${sourceStr}: ${entry.message}${dataStr}`;
+    }).join("\n");
+  }
+  // Create a scoped logger for specific components
+  createScope(source) {
+    return new ScopedLogger(this, source);
+  }
+}, chunkXQKCXG4I_cjs.__name(_a, "Logger"), _a);
+var _a2;
+var ScopedLogger = (_a2 = class {
+  constructor(logger2, source) {
+    chunkXQKCXG4I_cjs.__publicField(this, "logger");
+    chunkXQKCXG4I_cjs.__publicField(this, "source");
+    this.logger = logger2;
+    this.source = source;
+  }
+  error(message, data) {
+    this.logger.error(message, data, this.source);
+  }
+  warn(message, data) {
+    this.logger.warn(message, data, this.source);
+  }
+  info(message, data) {
+    this.logger.info(message, data, this.source);
+  }
+  debug(message, data) {
+    this.logger.debug(message, data, this.source);
+  }
+  // API-specific logging methods
+  apiRequest(url, method, data) {
+    this.logger.apiRequest(url, method, data);
+  }
+  apiResponse(url, status, data) {
+    this.logger.apiResponse(url, status, data);
+  }
+  apiError(url, error) {
+    this.logger.apiError(url, error);
+  }
+  // Authentication logging
+  authSuccess(method, userInfo) {
+    this.logger.authSuccess(method, userInfo);
+  }
+  authFailure(method, error) {
+    this.logger.authFailure(method, error);
+  }
+  // Storage logging
+  storageSet(key, isSecure = false) {
+    this.logger.storageSet(key, isSecure);
+  }
+  storageGet(key, found) {
+    this.logger.storageGet(key, found);
+  }
+  storageError(operation, key, error) {
+    this.logger.storageError(operation, key, error);
+  }
+  // Network logging
+  networkStateChange(isConnected, connectionType) {
+    this.logger.networkStateChange(isConnected, connectionType);
+  }
+  retryAttempt(attempt, maxAttempts, delay) {
+    this.logger.retryAttempt(attempt, maxAttempts, delay);
+  }
+}, chunkXQKCXG4I_cjs.__name(_a2, "ScopedLogger"), _a2);
+var logger = new Logger();
+var logError = /* @__PURE__ */ chunkXQKCXG4I_cjs.__name((message, data, source) => logger.error(message, data, source), "logError");
+var logWarn = /* @__PURE__ */ chunkXQKCXG4I_cjs.__name((message, data, source) => logger.warn(message, data, source), "logWarn");
+var logInfo = /* @__PURE__ */ chunkXQKCXG4I_cjs.__name((message, data, source) => logger.info(message, data, source), "logInfo");
+var logDebug = /* @__PURE__ */ chunkXQKCXG4I_cjs.__name((message, data, source) => logger.debug(message, data, source), "logDebug");
+var apiLogger = logger.createScope("API");
+var authLogger = logger.createScope("AUTH");
+var storageLogger = logger.createScope("STORAGE");
+var networkLogger = logger.createScope("NETWORK");
+var uiLogger = logger.createScope("UI");
+
+// src/storage/token.ts
+var isWeb = typeof window !== "undefined" && !!window?.document;
+var isReactNative = !isWeb;
+var DEFAULT_CONFIG = {
+  encryptionKeyId: "acube-default-key",
+  storeNamespace: "acube-secure-store"
+};
+var currentConfig = {
+  ...DEFAULT_CONFIG
+};
+var _a3;
+var WebSecureStorage = (_a3 = class {
+  static getStore() {
+    if (!this.customStore) {
+      try {
+        this.customStore = idbKeyval.createStore(currentConfig.storeNamespace, "secure-data");
+      } catch (error) {
+        apiLogger.warn("Failed to create IndexedDB store, using default", error);
+        this.customStore = null;
+        this.isIndexedDBAvailable = false;
+      }
+    }
+    return this.customStore;
+  }
+  static async setItem(key, value) {
+    const secureKey = `${currentConfig.encryptionKeyId}_${key}`;
+    if (this.isIndexedDBAvailable) {
+      try {
+        const store = this.getStore();
+        if (store) {
+          await idbKeyval.set(secureKey, value, store);
+          return;
+        }
+      } catch (error) {
+        apiLogger.warn("IndexedDB failed, falling back to localStorage", {
+          key: secureKey,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+        this.isIndexedDBAvailable = false;
+      }
+    }
+    try {
+      localStorage.setItem(`secure_${secureKey}`, value);
+    } catch (error) {
+      apiLogger.error("Failed to store secure item in localStorage", {
+        key: secureKey,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      throw error;
+    }
+  }
+  static async getItem(key) {
+    const secureKey = `${currentConfig.encryptionKeyId}_${key}`;
+    if (this.isIndexedDBAvailable) {
+      try {
+        const store = this.getStore();
+        if (store) {
+          const value = await idbKeyval.get(secureKey, store);
+          return value ?? null;
+        }
+      } catch (error) {
+        apiLogger.warn("IndexedDB read failed, trying localStorage", {
+          key: secureKey,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+        this.isIndexedDBAvailable = false;
+      }
+    }
+    try {
+      const value = localStorage.getItem(`secure_${secureKey}`);
+      return value;
+    } catch (error) {
+      apiLogger.error("Failed to get secure item from localStorage", {
+        key: secureKey,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      return null;
+    }
+  }
+  static async removeItem(key) {
+    const secureKey = `${currentConfig.encryptionKeyId}_${key}`;
+    if (this.isIndexedDBAvailable) {
+      try {
+        const store = this.getStore();
+        if (store) {
+          await idbKeyval.del(secureKey, store);
+        }
+      } catch (error) {
+        apiLogger.warn("IndexedDB delete failed", {
+          key: secureKey,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+    try {
+      localStorage.removeItem(`secure_${secureKey}`);
+    } catch (error) {
+      apiLogger.warn("localStorage delete failed", {
+        key: secureKey,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  // Reset IndexedDB availability for testing/recovery
+  static resetIndexedDBStatus() {
+    this.isIndexedDBAvailable = true;
+    this.customStore = null;
+  }
+}, chunkXQKCXG4I_cjs.__name(_a3, "WebSecureStorage"), chunkXQKCXG4I_cjs.__publicField(_a3, "customStore", null), chunkXQKCXG4I_cjs.__publicField(_a3, "isIndexedDBAvailable", true), _a3);
+var _SecureTokenStorage = class _SecureTokenStorage {
+  // Configuration method
+  static configure(config) {
+    currentConfig = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    if (isWeb) {
+      WebSecureStorage.resetIndexedDBStatus();
+    }
+    apiLogger.info("SecureTokenStorage configured", {
+      encryptionKeyId: currentConfig.encryptionKeyId,
+      storeNamespace: currentConfig.storeNamespace
+    });
+  }
+  // Get current configuration
+  static getConfig() {
+    return {
+      ...currentConfig
+    };
+  }
+  // Store data securely based on platform
+  static async setSecureItem(key, value) {
+    if (isReactNative) {
+      await Keychain__namespace.setInternetCredentials(key, key, value);
+    } else {
+      await WebSecureStorage.setItem(key, value);
+    }
+  }
+  static async getSecureItem(key) {
+    try {
+      if (isReactNative) {
+        const credentials = await Keychain__namespace.getInternetCredentials(key);
+        return credentials ? credentials.password : null;
+      } else {
+        return await WebSecureStorage.getItem(key);
+      }
+    } catch (error) {
+      apiLogger.warn("Failed to get secure item", {
+        key,
+        platform: isReactNative ? "react-native" : "web",
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      return null;
+    }
+  }
+  static async removeSecureItem(key) {
+    try {
+      if (isReactNative) {
+        await Keychain__namespace.resetInternetCredentials(key);
+      } else {
+        await WebSecureStorage.removeItem(key);
+      }
+    } catch (error) {
+      apiLogger.warn("Failed to remove secure item", {
+        key,
+        platform: isReactNative ? "react-native" : "web",
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  // Store data using appropriate method based on sensitivity
+  static async setItem(key, value) {
+    const isSecure = chunkXQKCXG4I_cjs.SECURE_KEYS.has(key);
+    if (isSecure) {
+      await this.setSecureItem(key, value);
+    } else {
+      await AsyncStorage__default.default.setItem(key, value);
+    }
+  }
+  static async getItem(key) {
+    const isSecure = chunkXQKCXG4I_cjs.SECURE_KEYS.has(key);
+    if (isSecure) {
+      return await this.getSecureItem(key);
+    } else {
+      return await AsyncStorage__default.default.getItem(key);
+    }
+  }
+  static async removeItem(key) {
+    const isSecure = chunkXQKCXG4I_cjs.SECURE_KEYS.has(key);
+    if (isSecure) {
+      await this.removeSecureItem(key);
+    } else {
+      await AsyncStorage__default.default.removeItem(key);
+    }
+  }
+  // Token-specific methods
+  static async storeToken(token) {
+    await this.setItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.ACCESS_TOKEN, token.access_token);
+    if (token.expires_in) {
+      const expiryTime = Date.now() + token.expires_in * 1e3;
+      await this.setItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.TOKEN_EXPIRY, expiryTime.toString());
+    }
+  }
+  static async getToken() {
+    return await this.getItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.ACCESS_TOKEN);
+  }
+  static async isTokenValid() {
+    const token = await this.getToken();
+    if (!token) return false;
+    const expiryStr = await this.getItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.TOKEN_EXPIRY);
+    if (!expiryStr) return true;
+    const expiry = parseInt(expiryStr, 10);
+    return Date.now() < expiry;
+  }
+  static async removeToken() {
+    await Promise.all([
+      this.removeItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.ACCESS_TOKEN),
+      this.removeItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.TOKEN_EXPIRY),
+      this.removeItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.USER_ROLE),
+      this.removeItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.USER_EMAIL)
+    ]);
+  }
+  // JWT payload extraction
+  static parseJWT(token) {
+    try {
+      const base64Url = token.split(".")[1];
+      const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
+      const jsonPayload = decodeURIComponent(atob(base64).split("").map((c) => `%${`00${c.charCodeAt(0).toString(16)}`.slice(-2)}`).join(""));
+      return JSON.parse(jsonPayload);
+    } catch (error) {
+      apiLogger.warn("Failed to parse JWT", {
+        tokenLength: token?.length ?? 0,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      return null;
+    }
+  }
+  // Store user info from JWT
+  static async storeUserInfo(token) {
+    const payload = this.parseJWT(token);
+    if (payload) {
+      await Promise.all([
+        this.setItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.USER_ROLE, payload.role || ""),
+        this.setItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.USER_EMAIL, payload.email || "")
+      ]);
+      apiLogger.info("User info stored successfully", {
+        email: payload.email,
+        role: payload.role,
+        hasExpiry: !!payload.exp
+      });
+    } else {
+      apiLogger.warn("Failed to store user info: invalid token payload");
+    }
+  }
+  static async getUserRole() {
+    return await this.getItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.USER_ROLE);
+  }
+  static async getUserEmail() {
+    return await this.getItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.USER_EMAIL);
+  }
+  // Clear all stored data
+  static async clearAll() {
+    const keysToRemove = Object.values(chunkXQKCXG4I_cjs.STORAGE_KEYS);
+    await Promise.all(keysToRemove.map((key) => this.removeItem(key)));
+    apiLogger.info("All stored data cleared", {
+      keysCleared: keysToRemove.length
+    });
+  }
+  // Advanced utility methods
+  // Get token expiry information
+  static async getTokenExpiryInfo() {
+    const expiryStr = await this.getItem(chunkXQKCXG4I_cjs.STORAGE_KEYS.TOKEN_EXPIRY);
+    const expiresAt = expiryStr ? parseInt(expiryStr, 10) : null;
+    const now = Date.now();
+    return {
+      expiresAt,
+      isExpired: expiresAt ? now >= expiresAt : false,
+      expiresInMs: expiresAt ? Math.max(0, expiresAt - now) : null
+    };
+  }
+  // Check if storage is properly configured and accessible
+  static async checkStorageHealth() {
+    const issues = [];
+    let storageType;
+    if (isReactNative) {
+      storageType = "keychain";
+      try {
+        await this.setItem("__health_check__", "test");
+        await this.getItem("__health_check__");
+        await this.removeItem("__health_check__");
+      } catch (error) {
+        issues.push("Keychain access failed");
+        storageType = "asyncStorage";
+      }
+    } else {
+      try {
+        await WebSecureStorage.setItem("__health_check__", "test");
+        await WebSecureStorage.getItem("__health_check__");
+        await WebSecureStorage.removeItem("__health_check__");
+        storageType = "indexeddb";
+      } catch (error) {
+        issues.push("IndexedDB access failed, using localStorage fallback");
+        storageType = "localStorage";
+      }
+    }
+    const result = {
+      isHealthy: issues.length === 0,
+      platform: isReactNative ? "react-native" : "web",
+      storageType,
+      issues
+    };
+    apiLogger.info("Storage health check completed", result);
+    return result;
+  }
+  // Get storage statistics
+  static async getStorageStats() {
+    const [token, userRole, userEmail, tokenExpiryInfo] = await Promise.all([
+      this.getToken(),
+      this.getUserRole(),
+      this.getUserEmail(),
+      this.getTokenExpiryInfo()
+    ]);
+    return {
+      hasToken: !!token,
+      hasUserInfo: !!(userRole ?? userEmail),
+      tokenExpiryInfo,
+      configuredNamespace: currentConfig.storeNamespace,
+      encryptionKeyId: currentConfig.encryptionKeyId
+    };
+  }
+  // Import/Export for migration purposes (development only)
+  static async exportData() {
+    const keys = Object.values(chunkXQKCXG4I_cjs.STORAGE_KEYS);
+    const data = {};
+    await Promise.all(keys.map(async (key) => {
+      data[key] = await this.getItem(key);
+    }));
+    apiLogger.info("Data exported", {
+      keysExported: Object.keys(data).length
+    });
+    return data;
+  }
+};
+chunkXQKCXG4I_cjs.__name(_SecureTokenStorage, "SecureTokenStorage");
+var SecureTokenStorage = _SecureTokenStorage;
+
+exports.SecureTokenStorage = SecureTokenStorage;
+exports.apiLogger = apiLogger;
+exports.authLogger = authLogger;
+exports.logDebug = logDebug;
+exports.logError = logError;
+exports.logInfo = logInfo;
+exports.logWarn = logWarn;
+exports.networkLogger = networkLogger;
+exports.storageLogger = storageLogger;
+exports.uiLogger = uiLogger;
+//# sourceMappingURL=chunk-24ZJ6SNG.cjs.map
+//# sourceMappingURL=chunk-24ZJ6SNG.cjs.map