@cloudsignal/pwa-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2051 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * CloudSignal PWA SDK v1.0.0
+ * https://cloudsignal.io
+ * MIT License
+ */
+
+// src/utils/fingerprint.ts
+async function generateBrowserFingerprint() {
+  try {
+    const components = [];
+    components.push(`${screen.width}x${screen.height}`);
+    components.push(`${screen.colorDepth}`);
+    components.push(Intl.DateTimeFormat().resolvedOptions().timeZone);
+    components.push(navigator.language);
+    components.push(navigator.platform);
+    if (navigator.hardwareConcurrency) {
+      components.push(navigator.hardwareConcurrency.toString());
+    }
+    if (navigator.deviceMemory) {
+      components.push(navigator.deviceMemory.toString());
+    }
+    const canvasFingerprint = getCanvasFingerprint();
+    if (canvasFingerprint) {
+      components.push(canvasFingerprint);
+    }
+    const webglFingerprint = getWebGLFingerprint();
+    if (webglFingerprint) {
+      components.push(webglFingerprint);
+    }
+    const audioFingerprint = await getAudioFingerprint();
+    if (audioFingerprint) {
+      components.push(audioFingerprint);
+    }
+    const combined = components.join("|");
+    const hash = await hashString(combined);
+    return hash;
+  } catch (error) {
+    console.warn("Browser fingerprint generation failed:", error);
+    return null;
+  }
+}
+function getCanvasFingerprint() {
+  try {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return null;
+    canvas.width = 200;
+    canvas.height = 50;
+    ctx.textBaseline = "alphabetic";
+    ctx.fillStyle = "#f60";
+    ctx.fillRect(125, 1, 62, 20);
+    ctx.fillStyle = "#069";
+    ctx.font = "11pt Arial";
+    ctx.fillText("CloudSignal PWA", 2, 15);
+    ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+    ctx.font = "18pt Arial";
+    ctx.fillText("CloudSignal PWA", 4, 45);
+    const dataUrl = canvas.toDataURL();
+    return dataUrl.slice(-50);
+  } catch {
+    return null;
+  }
+}
+function getWebGLFingerprint() {
+  try {
+    const canvas = document.createElement("canvas");
+    const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+    if (!gl) return null;
+    const webglCtx = gl;
+    const debugInfo = webglCtx.getExtension("WEBGL_debug_renderer_info");
+    if (debugInfo) {
+      const vendor2 = webglCtx.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+      const renderer2 = webglCtx.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+      return `${vendor2}~${renderer2}`;
+    }
+    const vendor = webglCtx.getParameter(webglCtx.VENDOR);
+    const renderer = webglCtx.getParameter(webglCtx.RENDERER);
+    return `${vendor}~${renderer}`;
+  } catch {
+    return null;
+  }
+}
+async function getAudioFingerprint() {
+  try {
+    const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+    if (!AudioContextClass) return null;
+    const audioContext = new AudioContextClass();
+    const oscillator = audioContext.createOscillator();
+    const analyser = audioContext.createAnalyser();
+    const gainNode = audioContext.createGain();
+    const scriptProcessor = audioContext.createScriptProcessor(4096, 1, 1);
+    gainNode.gain.value = 0;
+    oscillator.type = "triangle";
+    oscillator.connect(analyser);
+    analyser.connect(scriptProcessor);
+    scriptProcessor.connect(gainNode);
+    gainNode.connect(audioContext.destination);
+    oscillator.start(0);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const frequencyData = new Uint8Array(analyser.frequencyBinCount);
+    analyser.getByteFrequencyData(frequencyData);
+    let sum = 0;
+    for (let i = 0; i < frequencyData.length; i++) {
+      sum += frequencyData[i];
+    }
+    oscillator.stop();
+    await audioContext.close();
+    return sum.toString(36);
+  } catch {
+    return null;
+  }
+}
+async function hashString(str) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(str);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateTrackingId(os, osVersion, browser, browserVersion, deviceModel) {
+  const parts = [
+    os,
+    osVersion,
+    browser,
+    browserVersion,
+    deviceModel
+  ].filter(Boolean);
+  return parts.join("_").replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
+// src/DeviceDetector.ts
+var DeviceDetector = class {
+  constructor() {
+    this.cachedInfo = null;
+  }
+  /**
+   * Get comprehensive device information
+   */
+  getDeviceInfo() {
+    if (this.cachedInfo) {
+      return this.cachedInfo;
+    }
+    const platform = this.getPlatformInfo();
+    const screen2 = this.getScreenInfo();
+    const network = this.getNetworkInfo();
+    const capabilities = this.getCapabilities();
+    const info = {
+      // Operating System
+      os: platform.os,
+      osVersion: platform.osVersion,
+      // Device
+      deviceType: platform.deviceType,
+      deviceModel: platform.deviceModel,
+      isMobile: this.isMobile(),
+      isTablet: this.isTablet(),
+      isDesktop: this.isDesktop(),
+      isWebView: platform.isWebView,
+      // Browser
+      browser: platform.browser,
+      browserVersion: platform.browserVersion,
+      // Platform Flags
+      isIOS: platform.os === "iOS",
+      isAndroid: platform.os === "Android",
+      isMacOS: platform.os === "macOS",
+      isWindows: platform.os === "Windows",
+      isLinux: platform.os === "Linux",
+      // Screen
+      screenWidth: screen2.width,
+      screenHeight: screen2.height,
+      pixelRatio: screen2.pixelRatio,
+      // PWA Capabilities
+      supportLevel: capabilities.supportLevel,
+      hasNotificationPermission: capabilities.notifications,
+      hasPushManager: capabilities.push,
+      hasServiceWorker: capabilities.serviceWorker,
+      hasShareAPI: capabilities.share,
+      hasBadgeAPI: capabilities.badge,
+      // Permissions
+      notificationPermission: this.getNotificationPermission(),
+      // Network
+      isOnline: network.isOnline,
+      connectionType: network.connectionType,
+      // Analytics
+      platformIcon: this.getPlatformIcon(platform.os, platform.deviceType),
+      userAgent: platform.userAgent,
+      trackingId: generateTrackingId(
+        platform.os,
+        platform.osVersion,
+        platform.browser,
+        platform.browserVersion,
+        platform.deviceModel
+      )
+    };
+    this.cachedInfo = info;
+    return info;
+  }
+  /**
+   * Clear cached device info (useful when network/permissions change)
+   */
+  clearCache() {
+    this.cachedInfo = null;
+  }
+  /**
+   * Get platform-specific information
+   */
+  getPlatformInfo() {
+    const userAgent = navigator.userAgent;
+    const platform = navigator.platform;
+    let os = "Unknown";
+    let osVersion = "Unknown";
+    let browser = "Unknown";
+    let browserVersion = "Unknown";
+    let deviceType = "Unknown";
+    let deviceModel = "Unknown";
+    let isWebView = false;
+    if (/iPad|iPhone|iPod/.test(userAgent) && !window.MSStream) {
+      os = "iOS";
+      const iosMatch = userAgent.match(/OS (\d+)_(\d+)_?(\d+)?/);
+      if (iosMatch) {
+        osVersion = `${iosMatch[1]}.${iosMatch[2]}${iosMatch[3] ? "." + iosMatch[3] : ""}`;
+      }
+      if (/iPad/.test(userAgent)) {
+        deviceType = "iPad";
+        deviceModel = this.detectiPadModel(userAgent);
+      } else if (/iPhone/.test(userAgent)) {
+        deviceType = "iPhone";
+        deviceModel = this.detectiPhoneModel(userAgent);
+      } else if (/iPod/.test(userAgent)) {
+        deviceType = "iPod";
+        deviceModel = "iPod Touch";
+      }
+    } else if (/Android/.test(userAgent)) {
+      os = "Android";
+      const androidMatch = userAgent.match(/Android (\d+\.?\d*\.?\d*)/);
+      if (androidMatch) {
+        osVersion = androidMatch[1];
+      }
+      const deviceInfo = this.detectAndroidDevice(userAgent);
+      deviceType = deviceInfo.type;
+      deviceModel = deviceInfo.model;
+    } else if (/Mac/.test(platform)) {
+      os = "macOS";
+      const macMatch = userAgent.match(/Mac OS X (\d+)[_.](\d+)[_.]?(\d+)?/);
+      if (macMatch) {
+        osVersion = `${macMatch[1]}.${macMatch[2]}${macMatch[3] ? "." + macMatch[3] : ""}`;
+      }
+      deviceType = "Desktop";
+      deviceModel = "Mac";
+    } else if (/Win/.test(platform)) {
+      os = "Windows";
+      const winMatch = userAgent.match(/Windows NT (\d+\.\d+)/);
+      if (winMatch) {
+        osVersion = this.getWindowsVersion(winMatch[1]);
+      }
+      deviceType = "Desktop";
+      deviceModel = "PC";
+    } else if (/Linux/.test(platform)) {
+      os = "Linux";
+      deviceType = "Desktop";
+      deviceModel = "Linux PC";
+      if (/Ubuntu/.test(userAgent)) osVersion = "Ubuntu";
+      else if (/Fedora/.test(userAgent)) osVersion = "Fedora";
+      else if (/Debian/.test(userAgent)) osVersion = "Debian";
+    }
+    if (/Chrome/.test(userAgent) && !/Edg/.test(userAgent) && !/OPR/.test(userAgent)) {
+      browser = "Chrome";
+      const chromeMatch = userAgent.match(/Chrome\/(\d+\.?\d*\.?\d*\.?\d*)/);
+      if (chromeMatch) browserVersion = chromeMatch[1];
+    } else if (/Safari/.test(userAgent) && !/Chrome/.test(userAgent)) {
+      browser = "Safari";
+      const safariMatch = userAgent.match(/Version\/(\d+\.?\d*\.?\d*)/);
+      if (safariMatch) browserVersion = safariMatch[1];
+    } else if (/Firefox/.test(userAgent)) {
+      browser = "Firefox";
+      const firefoxMatch = userAgent.match(/Firefox\/(\d+\.?\d*\.?\d*)/);
+      if (firefoxMatch) browserVersion = firefoxMatch[1];
+    } else if (/Edg/.test(userAgent)) {
+      browser = "Edge";
+      const edgeMatch = userAgent.match(/Edg\/(\d+\.?\d*\.?\d*\.?\d*)/);
+      if (edgeMatch) browserVersion = edgeMatch[1];
+    } else if (/OPR/.test(userAgent) || /Opera/.test(userAgent)) {
+      browser = "Opera";
+      const operaMatch = userAgent.match(/(?:OPR|Opera)\/(\d+\.?\d*\.?\d*)/);
+      if (operaMatch) browserVersion = operaMatch[1];
+    } else if (/SamsungBrowser/.test(userAgent)) {
+      browser = "Samsung Internet";
+      const samsungMatch = userAgent.match(/SamsungBrowser\/(\d+\.?\d*)/);
+      if (samsungMatch) browserVersion = samsungMatch[1];
+    }
+    isWebView = this.detectWebView(userAgent);
+    return {
+      os,
+      osVersion,
+      browser,
+      browserVersion,
+      deviceType,
+      deviceModel,
+      isWebView,
+      userAgent
+    };
+  }
+  /**
+   * Get screen information
+   */
+  getScreenInfo() {
+    return {
+      width: screen.width,
+      height: screen.height,
+      pixelRatio: window.devicePixelRatio || 1,
+      orientation: screen.width > screen.height ? "landscape" : "portrait"
+    };
+  }
+  /**
+   * Get network information
+   */
+  getNetworkInfo() {
+    const connection = navigator.connection;
+    return {
+      isOnline: navigator.onLine,
+      connectionType: connection?.effectiveType || "unknown",
+      effectiveType: connection?.effectiveType,
+      downlink: connection?.downlink,
+      rtt: connection?.rtt,
+      saveData: connection?.saveData
+    };
+  }
+  /**
+   * Get PWA capabilities
+   */
+  getCapabilities() {
+    const capabilities = {
+      serviceWorker: "serviceWorker" in navigator,
+      push: "PushManager" in window,
+      notifications: "Notification" in window,
+      backgroundSync: "serviceWorker" in navigator && "SyncManager" in window,
+      badge: "setAppBadge" in navigator,
+      share: "share" in navigator,
+      shareTarget: "launchQueue" in window,
+      fileSystemAccess: "showOpenFilePicker" in window,
+      contactPicker: "ContactsManager" in window,
+      periodicSync: "serviceWorker" in navigator && "PeriodicSyncManager" in window,
+      supportLevel: "none"
+    };
+    if (capabilities.serviceWorker && capabilities.push && capabilities.notifications) {
+      capabilities.supportLevel = "full";
+    } else if (capabilities.serviceWorker && capabilities.notifications) {
+      capabilities.supportLevel = "partial";
+    } else if (capabilities.serviceWorker) {
+      capabilities.supportLevel = "basic";
+    }
+    return capabilities;
+  }
+  /**
+   * Get notification permission state
+   */
+  getNotificationPermission() {
+    if (!("Notification" in window)) {
+      return "denied";
+    }
+    return Notification.permission;
+  }
+  /**
+   * Check if device is mobile
+   */
+  isMobile() {
+    const userAgent = navigator.userAgent;
+    return /Android|webOS|iPhone|iPod|BlackBerry|IEMobile|Opera Mini/i.test(userAgent);
+  }
+  /**
+   * Check if device is tablet
+   */
+  isTablet() {
+    const userAgent = navigator.userAgent;
+    return /iPad|Android(?!.*Mobile)|Tablet/i.test(userAgent);
+  }
+  /**
+   * Check if device is desktop
+   */
+  isDesktop() {
+    return !this.isMobile() && !this.isTablet();
+  }
+  /**
+   * Get platform icon emoji
+   */
+  getPlatformIcon(os, deviceType) {
+    if (os === "iOS" || deviceType === "iPhone" || deviceType === "iPad") {
+      return "\u{1F4F1}";
+    }
+    if (os === "Android") {
+      return "\u{1F916}";
+    }
+    if (os === "macOS") {
+      return "\u{1F4BB}";
+    }
+    return "\u{1F5A5}\uFE0F";
+  }
+  /**
+   * Detect iPhone model from user agent
+   */
+  detectiPhoneModel(userAgent) {
+    const screenHeight = screen.height;
+    const screenWidth = screen.width;
+    if (screenHeight === 932 || screenWidth === 932) return "iPhone 15 Pro Max/14 Pro Max";
+    if (screenHeight === 896 || screenWidth === 896) return "iPhone 15 Pro/14 Pro/11 Pro Max";
+    if (screenHeight === 852 || screenWidth === 852) return "iPhone 15/14";
+    if (screenHeight === 844 || screenWidth === 844) return "iPhone 13/12";
+    if (screenHeight === 812 || screenWidth === 812) return "iPhone X/XS/11 Pro";
+    if (screenHeight === 736 || screenWidth === 736) return "iPhone 8 Plus";
+    if (screenHeight === 667 || screenWidth === 667) return "iPhone 8/SE";
+    if (screenHeight === 568 || screenWidth === 568) return "iPhone SE (1st)";
+    return "iPhone";
+  }
+  /**
+   * Detect iPad model from user agent
+   */
+  detectiPadModel(userAgent) {
+    const screenWidth = screen.width;
+    const screenHeight = screen.height;
+    const pixelRatio = window.devicePixelRatio || 1;
+    if ((screenHeight === 1366 || screenWidth === 1366) && pixelRatio === 2) {
+      return 'iPad Pro 12.9"';
+    }
+    if ((screenHeight === 1194 || screenWidth === 1194) && pixelRatio === 2) {
+      return 'iPad Pro 11"';
+    }
+    if ((screenHeight === 1180 || screenWidth === 1180) && pixelRatio === 2) {
+      return "iPad Air/10th Gen";
+    }
+    if ((screenHeight === 1133 || screenWidth === 1133) && pixelRatio === 2) {
+      return "iPad mini";
+    }
+    if (screenHeight === 1024 || screenWidth === 1024) {
+      return "iPad";
+    }
+    return "iPad";
+  }
+  /**
+   * Detect Android device model
+   */
+  detectAndroidDevice(userAgent) {
+    let type = "Phone";
+    let model = "Android Device";
+    if (/Tablet|SM-T|Tab|GT-P|MediaPad/i.test(userAgent)) {
+      type = "Tablet";
+    }
+    if (/SM-S9\d{2}/i.test(userAgent)) model = "Samsung Galaxy S24";
+    else if (/SM-S91\d/i.test(userAgent)) model = "Samsung Galaxy S23";
+    else if (/SM-S90\d/i.test(userAgent)) model = "Samsung Galaxy S22";
+    else if (/SM-G99\d/i.test(userAgent)) model = "Samsung Galaxy S21";
+    else if (/SM-N9\d{2}/i.test(userAgent)) model = "Samsung Galaxy Note";
+    else if (/SM-A\d{2}/i.test(userAgent)) model = "Samsung Galaxy A Series";
+    else if (/SM-/i.test(userAgent)) {
+      const match = userAgent.match(/SM-[A-Z]\d+/i);
+      if (match) model = `Samsung ${match[0]}`;
+    }
+    if (/Pixel 8/i.test(userAgent)) model = "Google Pixel 8";
+    else if (/Pixel 7/i.test(userAgent)) model = "Google Pixel 7";
+    else if (/Pixel 6/i.test(userAgent)) model = "Google Pixel 6";
+    else if (/Pixel/i.test(userAgent)) model = "Google Pixel";
+    if (/OnePlus/i.test(userAgent)) {
+      const match = userAgent.match(/OnePlus[\s]?(\w+)/i);
+      model = match ? `OnePlus ${match[1]}` : "OnePlus";
+    }
+    if (/Xiaomi|Redmi|POCO|Mi\s/i.test(userAgent)) {
+      if (/Redmi/i.test(userAgent)) model = "Xiaomi Redmi";
+      else if (/POCO/i.test(userAgent)) model = "Xiaomi POCO";
+      else model = "Xiaomi";
+    }
+    if (/HUAWEI|Honor/i.test(userAgent)) {
+      model = /Honor/i.test(userAgent) ? "Honor" : "Huawei";
+    }
+    if (/OPPO/i.test(userAgent)) model = "OPPO";
+    if (/vivo/i.test(userAgent)) model = "Vivo";
+    return { type, model };
+  }
+  /**
+   * Get Windows version from NT version
+   */
+  getWindowsVersion(ntVersion) {
+    const versionMap = {
+      "10.0": "Windows 10/11",
+      "6.3": "Windows 8.1",
+      "6.2": "Windows 8",
+      "6.1": "Windows 7",
+      "6.0": "Windows Vista",
+      "5.1": "Windows XP"
+    };
+    return versionMap[ntVersion] || `Windows NT ${ntVersion}`;
+  }
+  /**
+   * Detect if running in WebView
+   */
+  detectWebView(userAgent) {
+    if (/FBAN|FBAV/i.test(userAgent)) return true;
+    if (/Instagram/i.test(userAgent)) return true;
+    if (/LinkedIn/i.test(userAgent)) return true;
+    if (/Twitter/i.test(userAgent)) return true;
+    if (/MicroMessenger/i.test(userAgent)) return true;
+    if (/Snapchat/i.test(userAgent)) return true;
+    if (/BytedanceWebview|TikTok/i.test(userAgent)) return true;
+    if (/wv|WebView/i.test(userAgent)) return true;
+    return false;
+  }
+};
+var deviceDetector = new DeviceDetector();
+
+// src/ServiceWorkerManager.ts
+var ServiceWorkerManager = class {
+  constructor(options = {}) {
+    this.registration = null;
+    this.config = {
+      path: "/service-worker.js",
+      scope: "/",
+      autoRegister: true,
+      updateBehavior: "auto",
+      ...options.config
+    };
+    this.debug = options.debug ?? false;
+    this.onRegistered = options.onRegistered;
+    this.onUpdated = options.onUpdated;
+    this.onError = options.onError;
+  }
+  /**
+   * Check if service workers are supported
+   */
+  isSupported() {
+    return "serviceWorker" in navigator;
+  }
+  /**
+   * Get the current service worker registration
+   */
+  getRegistration() {
+    return this.registration;
+  }
+  /**
+   * Register the service worker
+   */
+  async register() {
+    if (!this.isSupported()) {
+      this.log("Service workers not supported");
+      return null;
+    }
+    try {
+      const { path, scope } = this.getPathAndScope();
+      this.log(`Registering service worker: ${path} with scope ${scope}`);
+      const registration = await navigator.serviceWorker.register(path, { scope });
+      this.registration = registration;
+      registration.addEventListener("updatefound", () => {
+        this.handleUpdateFound(registration);
+      });
+      await navigator.serviceWorker.ready;
+      this.log("Service worker registered successfully");
+      this.onRegistered?.(registration);
+      return registration;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.log(`Service worker registration failed: ${err.message}`, "error");
+      this.onError?.(err);
+      return null;
+    }
+  }
+  /**
+   * Unregister the service worker
+   */
+  async unregister() {
+    if (!this.registration) {
+      return false;
+    }
+    try {
+      const result = await this.registration.unregister();
+      if (result) {
+        this.registration = null;
+        this.log("Service worker unregistered");
+      }
+      return result;
+    } catch (error) {
+      this.log(`Failed to unregister service worker: ${error}`, "error");
+      return false;
+    }
+  }
+  /**
+   * Check for service worker updates
+   */
+  async checkForUpdate() {
+    if (!this.registration) {
+      return;
+    }
+    try {
+      await this.registration.update();
+      this.log("Checked for service worker update");
+    } catch (error) {
+      this.log(`Failed to check for update: ${error}`, "error");
+    }
+  }
+  /**
+   * Wait for service worker to be ready
+   */
+  async waitForReady(timeout = 5e3) {
+    if (!this.isSupported()) {
+      return null;
+    }
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => resolve(null), timeout);
+    });
+    try {
+      const registration = await Promise.race([
+        navigator.serviceWorker.ready,
+        timeoutPromise
+      ]);
+      if (registration) {
+        this.registration = registration;
+      }
+      return registration;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Send a message to the service worker
+   */
+  postMessage(message) {
+    if (!this.registration?.active) {
+      this.log("No active service worker to send message to", "warn");
+      return;
+    }
+    this.registration.active.postMessage(message);
+  }
+  /**
+   * Clear app badge via service worker
+   */
+  clearBadge() {
+    this.postMessage({ type: "CLEAR_BADGE" });
+  }
+  /**
+   * Set app badge via service worker
+   */
+  setBadge(count) {
+    this.postMessage({ type: "SET_BADGE", count });
+  }
+  /**
+   * Handle service worker update found
+   */
+  handleUpdateFound(registration) {
+    const newWorker = registration.installing;
+    if (!newWorker) {
+      return;
+    }
+    newWorker.addEventListener("statechange", () => {
+      if (newWorker.state === "installed" && navigator.serviceWorker.controller) {
+        this.log("New service worker available");
+        if (this.config.updateBehavior === "auto") {
+          newWorker.postMessage({ type: "SKIP_WAITING" });
+        }
+        this.onUpdated?.(registration);
+      }
+    });
+  }
+  /**
+   * Get service worker path and scope based on environment
+   * Handles Bubble.io version-live/version-test paths
+   */
+  getPathAndScope() {
+    if (this.config.path && this.config.scope) {
+      return { path: this.config.path, scope: this.config.scope };
+    }
+    try {
+      const pathname = window.location.pathname || "/";
+      if (pathname.startsWith("/version-live")) {
+        return {
+          path: "/version-live/service-worker.js",
+          scope: "/version-live/"
+        };
+      }
+      if (pathname.startsWith("/version-test")) {
+        return {
+          path: "/version-test/service-worker.js",
+          scope: "/version-test/"
+        };
+      }
+    } catch {
+    }
+    return {
+      path: this.config.path || "/service-worker.js",
+      scope: this.config.scope || "/"
+    };
+  }
+  /**
+   * Log message if debug is enabled
+   */
+  log(message, level = "log") {
+    if (!this.debug) return;
+    const prefix = "[CloudSignal PWA SW]";
+    console[level](`${prefix} ${message}`);
+  }
+};
+
+// src/InstallationManager.ts
+var InstallationManager = class {
+  constructor(options = {}) {
+    this.deferredPrompt = null;
+    this.isInstalled = false;
+    this.debug = options.debug ?? false;
+    this.onInstallAvailable = options.onInstallAvailable;
+    this.onInstallAccepted = options.onInstallAccepted;
+    this.onInstallDismissed = options.onInstallDismissed;
+    this.onInstalled = options.onInstalled;
+    this.detectInstallationStatus();
+  }
+  /**
+   * Initialize event listeners
+   */
+  initialize() {
+    window.addEventListener("beforeinstallprompt", (event) => {
+      event.preventDefault();
+      this.deferredPrompt = event;
+      this.log("Install prompt available");
+      this.onInstallAvailable?.(this.deferredPrompt);
+    });
+    window.addEventListener("appinstalled", () => {
+      this.isInstalled = true;
+      this.deferredPrompt = null;
+      this.log("PWA was installed");
+      this.onInstalled?.();
+    });
+    if (window.matchMedia) {
+      const standaloneQuery = window.matchMedia("(display-mode: standalone)");
+      standaloneQuery.addEventListener("change", (e) => {
+        if (e.matches) {
+          this.isInstalled = true;
+          this.log("App is now running in standalone mode");
+        }
+      });
+    }
+  }
+  /**
+   * Get current installation state
+   */
+  getState() {
+    const displayMode = this.getDisplayMode();
+    const isIOS = this.isIOSDevice();
+    const isSafari = this.isSafariBrowser();
+    return {
+      isInstalled: this.isInstalled || displayMode !== "browser",
+      canBeInstalled: this.deferredPrompt !== null,
+      needsManualInstall: isIOS && isSafari && !this.isInstalled,
+      showManualInstructions: isIOS && isSafari && !this.isInstalled,
+      installSteps: this.getInstallSteps(),
+      displayMode
+    };
+  }
+  /**
+   * Show the install prompt
+   */
+  async showInstallPrompt() {
+    if (!this.deferredPrompt) {
+      this.log("No install prompt available", "warn");
+      return {
+        accepted: false,
+        outcome: "dismissed"
+      };
+    }
+    try {
+      await this.deferredPrompt.prompt();
+      const { outcome, platform } = await this.deferredPrompt.userChoice;
+      const result = {
+        accepted: outcome === "accepted",
+        outcome,
+        platform
+      };
+      if (outcome === "accepted") {
+        this.log("User accepted install prompt");
+        this.isInstalled = true;
+        this.onInstallAccepted?.(result);
+      } else {
+        this.log("User dismissed install prompt");
+        this.onInstallDismissed?.(result);
+      }
+      this.deferredPrompt = null;
+      return result;
+    } catch (error) {
+      this.log(`Error showing install prompt: ${error}`, "error");
+      return {
+        accepted: false,
+        outcome: "dismissed"
+      };
+    }
+  }
+  /**
+   * Check if install prompt is available
+   */
+  canInstall() {
+    return this.deferredPrompt !== null;
+  }
+  /**
+   * Check if PWA is installed
+   */
+  isPWAInstalled() {
+    return this.isInstalled || this.getDisplayMode() !== "browser";
+  }
+  /**
+   * Get current display mode
+   */
+  getDisplayMode() {
+    if (window.matchMedia("(display-mode: standalone)").matches) {
+      return "standalone";
+    }
+    if (window.matchMedia("(display-mode: minimal-ui)").matches) {
+      return "minimal-ui";
+    }
+    if (window.matchMedia("(display-mode: fullscreen)").matches) {
+      return "fullscreen";
+    }
+    if (navigator.standalone === true) {
+      return "standalone";
+    }
+    return "browser";
+  }
+  /**
+   * Get installation steps for current platform
+   */
+  getInstallSteps() {
+    if (this.isIOSDevice()) {
+      return [
+        "Tap the Share button in Safari",
+        'Scroll down and tap "Add to Home Screen"',
+        'Tap "Add" to install the app'
+      ];
+    }
+    if (this.isAndroidDevice()) {
+      return [
+        "Tap the menu (three dots) in your browser",
+        'Tap "Install App" or "Add to Home Screen"',
+        "Follow the prompts to install"
+      ];
+    }
+    return [
+      "Click the install icon in the address bar",
+      "Or use the browser menu to install the app",
+      'Click "Install" when prompted'
+    ];
+  }
+  /**
+   * Detect initial installation status
+   */
+  detectInstallationStatus() {
+    if (this.getDisplayMode() !== "browser") {
+      this.isInstalled = true;
+      return;
+    }
+    if (navigator.standalone === true) {
+      this.isInstalled = true;
+      return;
+    }
+    if ("getInstalledRelatedApps" in navigator) {
+      navigator.getInstalledRelatedApps().then((apps) => {
+        if (apps.length > 0) {
+          this.isInstalled = true;
+        }
+      }).catch(() => {
+      });
+    }
+  }
+  /**
+   * Check if device is iOS
+   */
+  isIOSDevice() {
+    return /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+  }
+  /**
+   * Check if device is Android
+   */
+  isAndroidDevice() {
+    return /Android/i.test(navigator.userAgent);
+  }
+  /**
+   * Check if browser is Safari
+   */
+  isSafariBrowser() {
+    const userAgent = navigator.userAgent;
+    return /Safari/i.test(userAgent) && !/Chrome|CriOS|FxiOS/i.test(userAgent);
+  }
+  /**
+   * Log message if debug is enabled
+   */
+  log(message, level = "log") {
+    if (!this.debug) return;
+    const prefix = "[CloudSignal PWA Install]";
+    console[level](`${prefix} ${message}`);
+  }
+};
+
+// src/utils/hmac.ts
+function toHex(buffer) {
+  return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function toBase64(buffer) {
+  return btoa(String.fromCharCode(...new Uint8Array(buffer)));
+}
+async function generateHMACSignature(secret, organizationId, timestamp, method, url, body = "") {
+  const encoder = new TextEncoder();
+  let path;
+  let query;
+  try {
+    const urlObj = url.startsWith("http") ? new URL(url) : new URL(url, "https://pwa.cloudsignal.app");
+    path = urlObj.pathname;
+    query = urlObj.search ? urlObj.search.slice(1) : "";
+  } catch {
+    const queryIndex = url.indexOf("?");
+    if (queryIndex > -1) {
+      path = url.slice(0, queryIndex);
+      query = url.slice(queryIndex + 1);
+    } else {
+      path = url;
+      query = "";
+    }
+  }
+  const canonicalParts = [
+    method.toUpperCase(),
+    path,
+    query,
+    organizationId,
+    timestamp
+  ];
+  if (body && body.length > 0) {
+    const bodyHashBuffer = await crypto.subtle.digest("SHA-256", encoder.encode(body));
+    const bodyHashHex = toHex(bodyHashBuffer);
+    canonicalParts.push(bodyHashHex);
+  }
+  const canonicalString = canonicalParts.join("\n");
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(canonicalString));
+  return toBase64(signature);
+}
+async function generateAuthHeaders(organizationId, organizationSecret, method, url, body) {
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const signature = await generateHMACSignature(
+    organizationSecret,
+    organizationId,
+    timestamp,
+    method,
+    url,
+    body || ""
+  );
+  return {
+    "X-CloudSignal-Organization-ID": organizationId,
+    "X-CloudSignal-Timestamp": timestamp,
+    "X-CloudSignal-Signature": signature,
+    "Content-Type": "application/json"
+  };
+}
+async function makeAuthenticatedRequest(organizationId, organizationSecret, method, url, body) {
+  const bodyStr = body ? JSON.stringify(body) : void 0;
+  const headers = await generateAuthHeaders(
+    organizationId,
+    organizationSecret,
+    method,
+    url,
+    bodyStr
+  );
+  const options = {
+    method,
+    headers
+  };
+  if (bodyStr) {
+    options.body = bodyStr;
+  }
+  return fetch(url, options);
+}
+function isValidUUID(value) {
+  if (!value || typeof value !== "string") return false;
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+
+// src/utils/storage.ts
+var STORAGE_PREFIX = "cloudsignal_pwa_";
+function getStorageItem(key, defaultValue) {
+  try {
+    const fullKey = `${STORAGE_PREFIX}${key}`;
+    const item = localStorage.getItem(fullKey);
+    if (item === null) return defaultValue ?? null;
+    return JSON.parse(item);
+  } catch {
+    return defaultValue ?? null;
+  }
+}
+function setStorageItem(key, value) {
+  try {
+    const fullKey = `${STORAGE_PREFIX}${key}`;
+    localStorage.setItem(fullKey, JSON.stringify(value));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeStorageItem(key) {
+  try {
+    const fullKey = `${STORAGE_PREFIX}${key}`;
+    localStorage.removeItem(fullKey);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getRegistrationId(organizationId, serviceId) {
+  const key = `registration_${organizationId}_${serviceId}`;
+  return getStorageItem(key);
+}
+function setRegistrationId(organizationId, serviceId, registrationId) {
+  const key = `registration_${organizationId}_${serviceId}`;
+  return setStorageItem(key, registrationId);
+}
+function removeRegistrationId(organizationId, serviceId) {
+  const key = `registration_${organizationId}_${serviceId}`;
+  return removeStorageItem(key);
+}
+var IndexedDBStorage = class {
+  constructor(dbName = "CloudSignalPWA", dbVersion = 1) {
+    this.db = null;
+    this.dbName = dbName;
+    this.dbVersion = dbVersion;
+  }
+  /**
+   * Initialize the database
+   */
+  async init() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.dbVersion);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve(this.db);
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains("badge")) {
+          db.createObjectStore("badge");
+        }
+        if (!db.objectStoreNames.contains("notifications")) {
+          const notificationStore = db.createObjectStore("notifications", {
+            keyPath: "id",
+            autoIncrement: true
+          });
+          notificationStore.createIndex("timestamp", "timestamp", { unique: false });
+          notificationStore.createIndex("read", "read", { unique: false });
+        }
+        if (!db.objectStoreNames.contains("userPreferences")) {
+          db.createObjectStore("userPreferences");
+        }
+        if (!db.objectStoreNames.contains("syncQueue")) {
+          const syncStore = db.createObjectStore("syncQueue", {
+            keyPath: "id",
+            autoIncrement: true
+          });
+          syncStore.createIndex("timestamp", "timestamp", { unique: false });
+        }
+      };
+    });
+  }
+  /**
+   * Ensure database connection
+   */
+  async ensureConnection() {
+    if (!this.db) {
+      await this.init();
+    }
+  }
+  /**
+   * Promisify IDBRequest
+   */
+  promisifyRequest(request) {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  /**
+   * Get badge count
+   */
+  async getBadgeCount() {
+    await this.ensureConnection();
+    const transaction = this.db.transaction(["badge"], "readonly");
+    const store = transaction.objectStore("badge");
+    const count = await this.promisifyRequest(store.get("count"));
+    return count || 0;
+  }
+  /**
+   * Set badge count
+   */
+  async setBadgeCount(count) {
+    await this.ensureConnection();
+    const transaction = this.db.transaction(["badge"], "readwrite");
+    const store = transaction.objectStore("badge");
+    await this.promisifyRequest(store.put(count, "count"));
+  }
+  /**
+   * Increment badge count
+   */
+  async incrementBadgeCount(increment = 1) {
+    const currentCount = await this.getBadgeCount();
+    const newCount = Math.max(0, currentCount + increment);
+    await this.setBadgeCount(newCount);
+    return newCount;
+  }
+  /**
+   * Save notification to history
+   */
+  async saveNotification(notification) {
+    await this.ensureConnection();
+    const transaction = this.db.transaction(["notifications"], "readwrite");
+    const store = transaction.objectStore("notifications");
+    const notificationData = {
+      ...notification,
+      timestamp: Date.now(),
+      read: false
+    };
+    const key = await this.promisifyRequest(store.add(notificationData));
+    return key;
+  }
+  /**
+   * Get recent notifications
+   */
+  async getRecentNotifications(limit = 50) {
+    await this.ensureConnection();
+    const transaction = this.db.transaction(["notifications"], "readonly");
+    const store = transaction.objectStore("notifications");
+    const index = store.index("timestamp");
+    const notifications = [];
+    const cursor = index.openCursor(null, "prev");
+    return new Promise((resolve, reject) => {
+      cursor.onsuccess = (event) => {
+        const result = event.target.result;
+        if (result && notifications.length < limit) {
+          notifications.push(result.value);
+          result.continue();
+        } else {
+          resolve(notifications);
+        }
+      };
+      cursor.onerror = () => reject(cursor.error);
+    });
+  }
+  /**
+   * Mark notification as read
+   */
+  async markNotificationAsRead(notificationId) {
+    await this.ensureConnection();
+    const transaction = this.db.transaction(["notifications"], "readwrite");
+    const store = transaction.objectStore("notifications");
+    const notification = await this.promisifyRequest(store.get(notificationId));
+    if (notification) {
+      notification.read = true;
+      await this.promisifyRequest(store.put(notification));
+    }
+  }
+  /**
+   * Get user preference
+   */
+  async getUserPreference(key) {
+    await this.ensureConnection();
+    const transaction = this.db.transaction(["userPreferences"], "readonly");
+    const store = transaction.objectStore("userPreferences");
+    return this.promisifyRequest(store.get(key));
+  }
+  /**
+   * Set user preference
+   */
+  async setUserPreference(key, value) {
+    await this.ensureConnection();
+    const transaction = this.db.transaction(["userPreferences"], "readwrite");
+    const store = transaction.objectStore("userPreferences");
+    await this.promisifyRequest(store.put(value, key));
+  }
+  /**
+   * Add item to sync queue
+   */
+  async addToSyncQueue(action) {
+    await this.ensureConnection();
+    const transaction = this.db.transaction(["syncQueue"], "readwrite");
+    const store = transaction.objectStore("syncQueue");
+    const queueItem = {
+      ...action,
+      timestamp: Date.now(),
+      retries: 0
+    };
+    const key = await this.promisifyRequest(store.add(queueItem));
+    return key;
+  }
+  /**
+   * Get sync queue items
+   */
+  async getSyncQueue() {
+    await this.ensureConnection();
+    const transaction = this.db.transaction(["syncQueue"], "readonly");
+    const store = transaction.objectStore("syncQueue");
+    return this.promisifyRequest(store.getAll());
+  }
+  /**
+   * Remove item from sync queue
+   */
+  async removeFromSyncQueue(id) {
+    await this.ensureConnection();
+    const transaction = this.db.transaction(["syncQueue"], "readwrite");
+    const store = transaction.objectStore("syncQueue");
+    await this.promisifyRequest(store.delete(id));
+  }
+};
+
+// src/PushNotificationManager.ts
+var PushNotificationManager = class {
+  constructor(options) {
+    this.serviceWorkerRegistration = null;
+    this.pushSubscription = null;
+    this.registrationId = null;
+    this.vapidPublicKey = null;
+    this.serviceUrl = options.serviceUrl;
+    this.organizationId = options.organizationId;
+    this.organizationSecret = options.organizationSecret;
+    this.serviceId = options.serviceId;
+    this.debug = options.debug ?? false;
+    this.deviceDetector = new DeviceDetector();
+    this.onRegistered = options.onRegistered;
+    this.onUnregistered = options.onUnregistered;
+    this.onError = options.onError;
+    this.onPermissionDenied = options.onPermissionDenied;
+    this.registrationId = getRegistrationId(this.organizationId, this.serviceId);
+  }
+  /**
+   * Set service worker registration
+   */
+  setServiceWorkerRegistration(registration) {
+    this.serviceWorkerRegistration = registration;
+  }
+  /**
+   * Set VAPID public key from config
+   */
+  setVapidPublicKey(key) {
+    this.vapidPublicKey = key;
+  }
+  /**
+   * Get current registration ID
+   */
+  getRegistrationId() {
+    return this.registrationId;
+  }
+  /**
+   * Check if registered for push notifications
+   */
+  isRegistered() {
+    return this.registrationId !== null;
+  }
+  /**
+   * Register for push notifications
+   */
+  async register(options = {}) {
+    try {
+      if (!this.serviceWorkerRegistration) {
+        throw new Error("Service worker not registered");
+      }
+      if (!this.vapidPublicKey) {
+        throw new Error("VAPID public key not set. Call downloadConfig() first.");
+      }
+      const permission = await this.requestPermission();
+      if (permission !== "granted") {
+        this.log("Notification permission denied");
+        this.onPermissionDenied?.();
+        return null;
+      }
+      const subscription = await this.subscribeToPush();
+      if (!subscription) {
+        throw new Error("Failed to subscribe to push notifications");
+      }
+      this.pushSubscription = subscription;
+      const fingerprint = await generateBrowserFingerprint();
+      const deviceInfo = this.deviceDetector.getDeviceInfo();
+      const platformInfo = this.deviceDetector.getPlatformInfo();
+      const subscriptionJson = subscription.toJSON();
+      const registrationData = {
+        serviceId: this.serviceId,
+        userEmail: options.userEmail,
+        userId: isValidUUID(options.userId) ? options.userId : void 0,
+        endpoint: subscription.endpoint,
+        keys: {
+          p256dh: subscriptionJson.keys?.p256dh || "",
+          auth: subscriptionJson.keys?.auth || ""
+        },
+        browserFingerprint: fingerprint || void 0,
+        deviceType: deviceInfo.deviceType,
+        deviceModel: deviceInfo.deviceModel,
+        browserName: platformInfo.browser,
+        browserVersion: platformInfo.browserVersion,
+        osName: platformInfo.os,
+        osVersion: platformInfo.osVersion,
+        userAgent: platformInfo.userAgent,
+        displayMode: "standalone",
+        isInstalled: true,
+        timezone: options.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+        language: options.language || navigator.language || "en-US"
+      };
+      const url = `${this.serviceUrl}/api/v1/registration/register`;
+      const response = await makeAuthenticatedRequest(
+        this.organizationId,
+        this.organizationSecret,
+        "POST",
+        url,
+        registrationData
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Registration failed: ${response.status} - ${errorText}`);
+      }
+      const result = await response.json();
+      this.registrationId = result.registration_id;
+      setRegistrationId(this.organizationId, this.serviceId, this.registrationId);
+      const registration = {
+        registrationId: result.registration_id,
+        status: result.status || "active",
+        createdAt: result.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+        isActive: true
+      };
+      this.log(`Push registration successful: ${registration.registrationId}`);
+      this.onRegistered?.(registration);
+      return registration;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.log(`Push registration failed: ${err.message}`, "error");
+      this.onError?.(err);
+      return null;
+    }
+  }
+  /**
+   * Unregister from push notifications
+   */
+  async unregister() {
+    try {
+      if (!this.registrationId) {
+        this.log("No registration to unregister");
+        return true;
+      }
+      if (this.pushSubscription) {
+        await this.pushSubscription.unsubscribe();
+        this.pushSubscription = null;
+      }
+      const url = `${this.serviceUrl}/api/v1/registration/unregister`;
+      const response = await makeAuthenticatedRequest(
+        this.organizationId,
+        this.organizationSecret,
+        "POST",
+        url,
+        { registration_id: this.registrationId }
+      );
+      if (!response.ok) {
+        this.log(`Backend unregistration failed: ${response.status}`, "warn");
+      }
+      removeRegistrationId(this.organizationId, this.serviceId);
+      this.registrationId = null;
+      this.log("Push unregistration successful");
+      this.onUnregistered?.();
+      return true;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.log(`Push unregistration failed: ${err.message}`, "error");
+      this.onError?.(err);
+      return false;
+    }
+  }
+  /**
+   * Update notification preferences
+   */
+  async updatePreferences(preferences) {
+    try {
+      if (!this.registrationId) {
+        throw new Error("Not registered for push notifications");
+      }
+      const url = `${this.serviceUrl}/api/v1/registration/update`;
+      const response = await makeAuthenticatedRequest(
+        this.organizationId,
+        this.organizationSecret,
+        "POST",
+        url,
+        {
+          registration_id: this.registrationId,
+          notification_topics: preferences.topics,
+          timezone: preferences.timezone,
+          language: preferences.language,
+          is_active: preferences.isActive
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`Update failed: ${response.status}`);
+      }
+      this.log("Preferences updated successfully");
+      return true;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.log(`Failed to update preferences: ${err.message}`, "error");
+      this.onError?.(err);
+      return false;
+    }
+  }
+  /**
+   * Check registration status
+   */
+  async checkStatus() {
+    try {
+      if (!this.registrationId) {
+        return null;
+      }
+      const url = `${this.serviceUrl}/api/v1/registration/status/${this.registrationId}`;
+      const response = await makeAuthenticatedRequest(
+        this.organizationId,
+        this.organizationSecret,
+        "GET",
+        url
+      );
+      if (!response.ok) {
+        if (response.status === 404) {
+          removeRegistrationId(this.organizationId, this.serviceId);
+          this.registrationId = null;
+          return null;
+        }
+        throw new Error(`Status check failed: ${response.status}`);
+      }
+      const status = await response.json();
+      return {
+        registrationId: status.registration_id,
+        status: status.status,
+        isActive: status.is_active,
+        isOnline: status.is_online,
+        lastActive: status.last_active,
+        lastSeenOnline: status.last_seen_online,
+        lastHeartbeat: status.last_heartbeat,
+        installationDate: status.installation_date,
+        notificationCount: status.notification_count,
+        deviceInfo: status.device_info
+      };
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.log(`Status check failed: ${err.message}`, "error");
+      return null;
+    }
+  }
+  /**
+   * Request notification permission
+   */
+  async requestPermission() {
+    if (!("Notification" in window)) {
+      return "denied";
+    }
+    if (Notification.permission === "granted") {
+      return "granted";
+    }
+    if (Notification.permission === "denied") {
+      return "denied";
+    }
+    return await Notification.requestPermission();
+  }
+  /**
+   * Subscribe to push notifications
+   */
+  async subscribeToPush() {
+    if (!this.serviceWorkerRegistration || !this.vapidPublicKey) {
+      return null;
+    }
+    try {
+      let subscription = await this.serviceWorkerRegistration.pushManager.getSubscription();
+      if (!subscription) {
+        const applicationServerKey = this.urlBase64ToUint8Array(this.vapidPublicKey);
+        subscription = await this.serviceWorkerRegistration.pushManager.subscribe({
+          userVisibleOnly: true,
+          applicationServerKey: applicationServerKey.buffer
+        });
+      }
+      return subscription;
+    } catch (error) {
+      this.log(`Push subscription failed: ${error}`, "error");
+      return null;
+    }
+  }
+  /**
+   * Convert base64 VAPID key to Uint8Array
+   */
+  urlBase64ToUint8Array(base64String) {
+    const padding = "=".repeat((4 - base64String.length % 4) % 4);
+    const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");
+    const rawData = atob(base64);
+    const outputArray = new Uint8Array(rawData.length);
+    for (let i = 0; i < rawData.length; ++i) {
+      outputArray[i] = rawData.charCodeAt(i);
+    }
+    return outputArray;
+  }
+  /**
+   * Log message if debug is enabled
+   */
+  log(message, level = "log") {
+    if (!this.debug) return;
+    const prefix = "[CloudSignal PWA Push]";
+    console[level](`${prefix} ${message}`);
+  }
+};
+
+// src/HeartbeatManager.ts
+var HeartbeatManager = class {
+  constructor(options) {
+    this.registrationId = null;
+    this.intervalId = null;
+    this.isRunning = false;
+    this.visibilityHandler = null;
+    this.serviceUrl = options.serviceUrl;
+    this.organizationId = options.organizationId;
+    this.organizationSecret = options.organizationSecret;
+    this.debug = options.debug ?? false;
+    this.onHeartbeatSent = options.onHeartbeatSent;
+    this.onHeartbeatError = options.onHeartbeatError;
+    this.config = {
+      enabled: options.config?.enabled ?? true,
+      interval: options.config?.interval ?? 3e4,
+      // 30 seconds
+      autoStart: options.config?.autoStart ?? true,
+      stopOnHidden: options.config?.stopOnHidden ?? true
+    };
+  }
+  /**
+   * Set the registration ID for heartbeat requests
+   */
+  setRegistrationId(registrationId) {
+    this.registrationId = registrationId;
+    if (this.config.autoStart && !this.isRunning && this.config.enabled) {
+      this.start();
+    }
+  }
+  /**
+   * Start sending heartbeats
+   */
+  start() {
+    if (this.isRunning) {
+      this.log("Heartbeat already running");
+      return;
+    }
+    if (!this.registrationId || !isValidUUID(this.registrationId)) {
+      this.log("Cannot start heartbeat: no valid registration ID", "warn");
+      return;
+    }
+    if (!this.config.enabled) {
+      this.log("Heartbeat is disabled");
+      return;
+    }
+    this.isRunning = true;
+    this.log(`Starting heartbeat with interval ${this.config.interval}ms`);
+    this.sendHeartbeat();
+    this.intervalId = setInterval(() => {
+      this.sendHeartbeat();
+    }, this.config.interval);
+    if (this.config.stopOnHidden) {
+      this.setupVisibilityHandler();
+    }
+  }
+  /**
+   * Stop sending heartbeats
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    if (this.visibilityHandler) {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = null;
+    }
+    this.log("Heartbeat stopped");
+  }
+  /**
+   * Check if heartbeat is running
+   */
+  isHeartbeatRunning() {
+    return this.isRunning;
+  }
+  /**
+   * Send a single heartbeat
+   */
+  async sendHeartbeat() {
+    if (!this.registrationId || !isValidUUID(this.registrationId)) {
+      this.log("Cannot send heartbeat: no valid registration ID", "warn");
+      return false;
+    }
+    try {
+      const url = `${this.serviceUrl}/api/v1/registration/heartbeat/${this.registrationId}`;
+      const response = await makeAuthenticatedRequest(
+        this.organizationId,
+        this.organizationSecret,
+        "POST",
+        url
+      );
+      if (!response.ok) {
+        throw new Error(`Heartbeat failed: ${response.status}`);
+      }
+      this.log("Heartbeat sent successfully");
+      this.onHeartbeatSent?.();
+      return true;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.log(`Heartbeat failed: ${err.message}`, "error");
+      this.onHeartbeatError?.(err);
+      return false;
+    }
+  }
+  /**
+   * Update heartbeat configuration
+   */
+  updateConfig(config) {
+    const wasRunning = this.isRunning;
+    if (wasRunning) {
+      this.stop();
+    }
+    this.config = {
+      ...this.config,
+      ...config
+    };
+    if (wasRunning && this.config.enabled) {
+      this.start();
+    }
+  }
+  /**
+   * Set up visibility change handler
+   */
+  setupVisibilityHandler() {
+    this.visibilityHandler = () => {
+      if (document.hidden) {
+        if (this.intervalId) {
+          clearInterval(this.intervalId);
+          this.intervalId = null;
+        }
+        this.log("Heartbeat paused (page hidden)");
+      } else {
+        if (this.isRunning && !this.intervalId) {
+          this.sendHeartbeat();
+          this.intervalId = setInterval(() => {
+            this.sendHeartbeat();
+          }, this.config.interval);
+          this.log("Heartbeat resumed (page visible)");
+        }
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+  /**
+   * Log message if debug is enabled
+   */
+  log(message, level = "log") {
+    if (!this.debug) return;
+    const prefix = "[CloudSignal PWA Heartbeat]";
+    console[level](`${prefix} ${message}`);
+  }
+};
+
+// src/CloudSignalPWA.ts
+var DEFAULT_SERVICE_URL = "https://pwa.cloudsignal.app";
+var SDK_VERSION = "1.0.0";
+var CloudSignalPWA = class {
+  constructor(config) {
+    this.initialized = false;
+    this.serviceConfig = null;
+    // Event emitter
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.serviceUrl = config.serviceUrl || DEFAULT_SERVICE_URL;
+    this.debug = config.debug ?? false;
+    this.deviceDetector = new DeviceDetector();
+    this.serviceWorkerManager = new ServiceWorkerManager({
+      config: config.serviceWorker,
+      debug: this.debug,
+      onRegistered: (reg) => this.emit("sw:registered", { registration: reg }),
+      onUpdated: (reg) => this.emit("sw:updated", { registration: reg }),
+      onError: (err) => this.emit("sw:error", { error: err })
+    });
+    this.installationManager = new InstallationManager({
+      debug: this.debug,
+      onInstallAvailable: (event) => this.emit("install:available", { platforms: event.platforms }),
+      onInstallAccepted: (result) => this.emit("install:accepted", result),
+      onInstallDismissed: (result) => this.emit("install:dismissed", result),
+      onInstalled: () => this.emit("install:completed", {})
+    });
+    this.pushNotificationManager = new PushNotificationManager({
+      serviceUrl: this.serviceUrl,
+      organizationId: config.organizationId,
+      organizationSecret: config.organizationSecret,
+      serviceId: config.serviceId,
+      debug: this.debug,
+      onRegistered: (reg) => {
+        this.emit("push:registered", { registrationId: reg.registrationId, endpoint: "" });
+        this.heartbeatManager.setRegistrationId(reg.registrationId);
+      },
+      onUnregistered: () => {
+        this.emit("push:unregistered", {});
+        this.heartbeatManager.stop();
+      },
+      onError: (err) => this.emit("push:error", { error: err }),
+      onPermissionDenied: () => this.emit("permission:denied", { permission: "denied" })
+    });
+    this.heartbeatManager = new HeartbeatManager({
+      serviceUrl: this.serviceUrl,
+      organizationId: config.organizationId,
+      organizationSecret: config.organizationSecret,
+      config: config.heartbeat,
+      debug: this.debug,
+      onHeartbeatSent: () => this.emit("heartbeat:sent", { timestamp: Date.now() }),
+      onHeartbeatError: (err) => this.emit("heartbeat:error", { timestamp: Date.now(), error: err.message })
+    });
+    this.log(`CloudSignal PWA SDK v${SDK_VERSION} initialized`);
+  }
+  // ============================================
+  // Initialization
+  // ============================================
+  /**
+   * Initialize the PWA client
+   * Downloads config, registers service worker, and sets up event listeners
+   */
+  async initialize() {
+    try {
+      this.log("Initializing PWA client...");
+      this.installationManager.initialize();
+      const swReg = await this.serviceWorkerManager.register();
+      if (swReg) {
+        this.pushNotificationManager.setServiceWorkerRegistration(swReg);
+      }
+      const serviceConfig = await this.downloadConfig();
+      this.setupNetworkListeners();
+      this.initialized = true;
+      const result = {
+        success: true,
+        config: serviceConfig || void 0,
+        deviceInfo: this.deviceDetector.getDeviceInfo(),
+        installationState: this.installationManager.getState()
+      };
+      this.log("PWA client initialized successfully");
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.log(`Initialization failed: ${err.message}`, "error");
+      return {
+        success: false,
+        error: err.message
+      };
+    }
+  }
+  /**
+   * Download PWA service configuration from backend
+   */
+  async downloadConfig() {
+    try {
+      const url = `${this.serviceUrl}/api/v1/config/download`;
+      const response = await makeAuthenticatedRequest(
+        this.config.organizationId,
+        this.config.organizationSecret,
+        "POST",
+        url,
+        { organization_id: this.config.organizationId }
+      );
+      if (!response.ok) {
+        throw new Error(`Config download failed: ${response.status}`);
+      }
+      const config = await response.json();
+      this.serviceConfig = config;
+      if (config.vapid_public_key) {
+        this.pushNotificationManager.setVapidPublicKey(config.vapid_public_key);
+      }
+      if (config.manifest_url) {
+        this.injectManifest(config.manifest_url);
+      }
+      this.emit("config:loaded", { config });
+      this.log("Configuration downloaded successfully");
+      return config;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.log(`Config download failed: ${err.message}`, "error");
+      this.emit("config:error", { error: err });
+      return null;
+    }
+  }
+  // ============================================
+  // Installation
+  // ============================================
+  /**
+   * Show the PWA install prompt
+   */
+  async showInstallPrompt() {
+    return this.installationManager.showInstallPrompt();
+  }
+  /**
+   * Get current installation state
+   */
+  getInstallationState() {
+    return this.installationManager.getState();
+  }
+  /**
+   * Check if PWA can be installed
+   */
+  canInstall() {
+    return this.installationManager.canInstall();
+  }
+  /**
+   * Check if PWA is installed
+   */
+  isInstalled() {
+    return this.installationManager.isPWAInstalled();
+  }
+  /**
+   * Get installation steps for current platform
+   */
+  getInstallSteps() {
+    return this.installationManager.getInstallSteps();
+  }
+  // ============================================
+  // Push Notifications
+  // ============================================
+  /**
+   * Register for push notifications
+   */
+  async registerForPush(options) {
+    return this.pushNotificationManager.register(options);
+  }
+  /**
+   * Unregister from push notifications
+   */
+  async unregisterFromPush() {
+    return this.pushNotificationManager.unregister();
+  }
+  /**
+   * Update notification preferences
+   */
+  async updatePreferences(preferences) {
+    return this.pushNotificationManager.updatePreferences(preferences);
+  }
+  /**
+   * Check registration status
+   */
+  async checkRegistrationStatus() {
+    return this.pushNotificationManager.checkStatus();
+  }
+  /**
+   * Get current registration ID
+   */
+  getRegistrationId() {
+    return this.pushNotificationManager.getRegistrationId();
+  }
+  /**
+   * Check if registered for push notifications
+   */
+  isRegistered() {
+    return this.pushNotificationManager.isRegistered();
+  }
+  /**
+   * Request notification permission
+   */
+  async requestPermission() {
+    return this.pushNotificationManager.requestPermission();
+  }
+  // ============================================
+  // Device Information
+  // ============================================
+  /**
+   * Get comprehensive device information
+   */
+  getDeviceInfo() {
+    return this.deviceDetector.getDeviceInfo();
+  }
+  /**
+   * Get PWA capabilities
+   */
+  getCapabilities() {
+    return this.deviceDetector.getCapabilities();
+  }
+  // ============================================
+  // Heartbeat
+  // ============================================
+  /**
+   * Start heartbeat for online status tracking
+   */
+  startHeartbeat() {
+    const regId = this.pushNotificationManager.getRegistrationId();
+    if (regId) {
+      this.heartbeatManager.setRegistrationId(regId);
+      this.heartbeatManager.start();
+      this.emit("heartbeat:started", { timestamp: Date.now() });
+    } else {
+      this.log("Cannot start heartbeat: not registered", "warn");
+    }
+  }
+  /**
+   * Stop heartbeat
+   */
+  stopHeartbeat() {
+    this.heartbeatManager.stop();
+    this.emit("heartbeat:stopped", { timestamp: Date.now() });
+  }
+  // ============================================
+  // Service Worker
+  // ============================================
+  /**
+   * Clear app badge
+   */
+  clearBadge() {
+    this.serviceWorkerManager.clearBadge();
+  }
+  /**
+   * Set app badge count
+   */
+  setBadge(count) {
+    this.serviceWorkerManager.setBadge(count);
+  }
+  /**
+   * Check for service worker updates
+   */
+  async checkForUpdates() {
+    return this.serviceWorkerManager.checkForUpdate();
+  }
+  // ============================================
+  // Events
+  // ============================================
+  /**
+   * Subscribe to an event
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  /**
+   * Emit an event
+   */
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (error) {
+          this.log(`Event handler error for ${event}: ${error}`, "error");
+        }
+      });
+    }
+  }
+  // ============================================
+  // Utility Methods
+  // ============================================
+  /**
+   * Get SDK version
+   */
+  getVersion() {
+    return SDK_VERSION;
+  }
+  /**
+   * Get service configuration
+   */
+  getServiceConfig() {
+    return this.serviceConfig;
+  }
+  /**
+   * Check if client is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Inject PWA manifest link
+   */
+  injectManifest(manifestUrl) {
+    let manifestLink = document.querySelector('link[rel="manifest"]');
+    if (!manifestLink) {
+      manifestLink = document.createElement("link");
+      manifestLink.setAttribute("rel", "manifest");
+      document.head.appendChild(manifestLink);
+    }
+    manifestLink.setAttribute("href", manifestUrl);
+    this.log(`Manifest injected: ${manifestUrl}`);
+  }
+  /**
+   * Set up network status listeners
+   */
+  setupNetworkListeners() {
+    window.addEventListener("online", () => {
+      this.deviceDetector.clearCache();
+      this.emit("network:online", { isOnline: true });
+    });
+    window.addEventListener("offline", () => {
+      this.deviceDetector.clearCache();
+      this.emit("network:offline", { isOnline: false });
+    });
+  }
+  /**
+   * Log message if debug is enabled
+   */
+  log(message, level = "log") {
+    if (!this.debug && level === "log") return;
+    const prefix = "[CloudSignal PWA]";
+    console[level](`${prefix} ${message}`);
+  }
+};
+var CloudSignalPWA_default = CloudSignalPWA;
+
+// src/index.ts
+var VERSION = "1.0.0";
+
+exports.CloudSignalPWA = CloudSignalPWA;
+exports.DeviceDetector = DeviceDetector;
+exports.HeartbeatManager = HeartbeatManager;
+exports.IndexedDBStorage = IndexedDBStorage;
+exports.InstallationManager = InstallationManager;
+exports.PushNotificationManager = PushNotificationManager;
+exports.ServiceWorkerManager = ServiceWorkerManager;
+exports.VERSION = VERSION;
+exports.default = CloudSignalPWA_default;
+exports.deviceDetector = deviceDetector;
+exports.generateAuthHeaders = generateAuthHeaders;
+exports.generateBrowserFingerprint = generateBrowserFingerprint;
+exports.generateHMACSignature = generateHMACSignature;
+exports.generateTrackingId = generateTrackingId;
+exports.getRegistrationId = getRegistrationId;
+exports.getStorageItem = getStorageItem;
+exports.isValidUUID = isValidUUID;
+exports.makeAuthenticatedRequest = makeAuthenticatedRequest;
+exports.removeRegistrationId = removeRegistrationId;
+exports.removeStorageItem = removeStorageItem;
+exports.setRegistrationId = setRegistrationId;
+exports.setStorageItem = setStorageItem;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map