web-manager 4.3.1 → 4.3.3

package/src/modules/service-worker.js

@@ -0,0 +1,196 @@
+class ServiceWorker {
+  constructor(manager) {
+    this.manager = manager;
+    this._registration = null;
+    this._messageHandlers = new Map();
+  }
+
+  // Check if service workers are supported
+  isSupported() {
+    return 'serviceWorker' in navigator;
+  }
+
+  // Return promise that resolves when service worker is ready
+  async ready() {
+    if (!this.isSupported()) {
+      throw new Error('Service Workers not supported');
+    }
+
+    // If already registered and active
+    if (this._registration?.active) {
+      return this._registration;
+    }
+
+    // Wait for service worker to be ready
+    const registration = await navigator.serviceWorker.ready;
+    return registration;
+  }
+
+  // Register service worker
+  async register(options = {}) {
+    try {
+      if (!this.isSupported()) {
+        console.warn('Service Workers are not supported');
+        return null;
+      }
+
+      const swPath = options.path || this.manager.config.serviceWorker?.config?.path || '/service-worker.js';
+      const scope = options.scope || '/';
+
+      // Build config object to pass to service worker
+      const config = {
+        brand: this.manager.config.brand?.id,
+        environment: this.manager.config.environment,
+        buildTime: this.manager.config.buildTime,
+        firebase: this.manager._resolveFirebaseConfig()
+      };
+
+      // Register service worker
+      const registration = await navigator.serviceWorker.register(swPath, {
+        scope,
+        updateViaCache: 'none'
+      });
+
+      // Store registration
+      this._registration = registration;
+      this.manager.state.serviceWorker = registration;
+
+      // Wait for service worker to be ready and send config
+      await navigator.serviceWorker.ready;
+
+      // Send config to active service worker
+      // Removed due to issues init'ing firebase asynchronously in SW (now config is fetched directly in SW)
+      // if (registration.active) {
+      //   try {
+      //     this.postMessage({
+      //       command: 'update-config',
+      //       payload: config
+      //     });
+      //   } catch (error) {
+      //     console.warn('Could not send config to service worker:', error);
+      //   }
+      // }
+
+      // Resolve with registration
+      return registration;
+    } catch (error) {
+      console.error('Service Worker registration failed:', error);
+      throw error;
+    }
+  }
+
+  // Get current registration
+  getRegistration() {
+    return this._registration;
+  }
+
+  // Post message to service worker
+  postMessage(message, options = {}) {
+    return new Promise((resolve, reject) => {
+      // Check support
+      if (!this.isSupported()) {
+        return reject(new Error('Service Workers not supported'));
+      }
+
+      // Get active service worker
+      const controller = this._registration?.active || navigator.serviceWorker.controller;
+
+      if (!controller) {
+        return reject(new Error('No active service worker'));
+      }
+
+      // Create message channel for two-way communication
+      const messageChannel = new MessageChannel();
+      const timeout = options.timeout || 5000;
+      let timeoutId;
+
+      // Set up timeout to prevent hanging
+      if (timeout > 0) {
+        timeoutId = setTimeout(() => {
+          messageChannel.port1.close();
+          reject(new Error('Service worker message timeout'));
+        }, timeout);
+      }
+
+      // Listen for response from service worker
+      messageChannel.port1.onmessage = (event) => {
+        clearTimeout(timeoutId);
+
+        if (event.data.error) {
+          reject(new Error(event.data.error));
+        } else {
+          resolve(event.data);
+        }
+      };
+
+      // Send message with port for reply
+      controller.postMessage(message, [messageChannel.port2]);
+    });
+  }
+
+  // Listen for messages from service worker
+  onMessage(type, handler) {
+    if (!this.isSupported()) {
+      return () => {};
+    }
+
+    // Store handler
+    if (!this._messageHandlers.has(type)) {
+      this._messageHandlers.set(type, new Set());
+    }
+    this._messageHandlers.get(type).add(handler);
+
+    // Set up global message listener if not already done
+    if (this._messageHandlers.size === 1) {
+      navigator.serviceWorker.addEventListener('message', this._handleMessage.bind(this));
+    }
+
+    // Return unsubscribe function
+    return () => {
+      const handlers = this._messageHandlers.get(type);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          this._messageHandlers.delete(type);
+        }
+      }
+    };
+  }
+
+  // Get service worker state
+  getState() {
+    if (!this._registration) {
+      return 'none';
+    }
+
+    if (this._registration.installing) {
+      return 'installing';
+    } else if (this._registration.waiting) {
+      return 'waiting';
+    } else if (this._registration.active) {
+      return 'active';
+    }
+
+    return 'unknown';
+  }
+
+  // Private: Handle incoming messages
+  _handleMessage(event) {
+    const { type, ...data } = event.data || {};
+
+    if (!type) return;
+
+    const handlers = this._messageHandlers.get(type);
+    if (handlers) {
+      handlers.forEach(handler => {
+        try {
+          handler(data, event);
+        } catch (error) {
+          console.error('Message handler error:', error);
+        }
+      });
+    }
+  }
+}
+
+export default ServiceWorker;

package/src/modules/storage.js

@@ -0,0 +1,133 @@
+import lodash from 'lodash';
+const { get: _get, set: _set } = lodash;
+
+class Storage {
+  constructor() {
+    this.storageKey = '_manager';
+    this.pseudoStorage = {};
+  }
+
+  get(path, defaultValue) {
+    let usableStorage;
+
+    // Try to parse the localStorage object
+    try {
+      usableStorage = JSON.parse(window.localStorage.getItem(this.storageKey) || '{}');
+    } catch (e) {
+      usableStorage = this.pseudoStorage;
+    }
+
+    // If there's no path, return the entire storage object
+    if (!path) {
+      return usableStorage || defaultValue;
+    }
+
+    // Return the value at the path
+    return _get(usableStorage, path, defaultValue);
+  }
+
+  set(path, value) {
+    let usableStorage;
+
+    // Try to get the current storage
+    try {
+      usableStorage = this.get();
+    } catch (e) {
+      usableStorage = this.pseudoStorage;
+    }
+
+    // If there's no path, replace the entire storage object
+    if (!path) {
+      usableStorage = value || {};
+    } else {
+      // Set the value at the path
+      _set(usableStorage, path, value);
+    }
+
+    // Try to set the localStorage object
+    try {
+      window.localStorage.setItem(this.storageKey, JSON.stringify(usableStorage));
+    } catch (e) {
+      this.pseudoStorage = usableStorage;
+    }
+
+    return usableStorage;
+  }
+
+  remove(path) {
+    if (!path) {
+      this.clear();
+    } else {
+      this.set(path, undefined);
+    }
+  }
+
+  clear() {
+    try {
+      window.localStorage.setItem(this.storageKey, '{}');
+    } catch (e) {
+      this.pseudoStorage = {};
+    }
+  }
+
+  // Session storage methods
+  session = {
+    get: (path, defaultValue) => {
+      let usableStorage;
+
+      try {
+        usableStorage = JSON.parse(window.sessionStorage.getItem(this.storageKey) || '{}');
+      } catch (e) {
+        return defaultValue;
+      }
+
+      if (!path) {
+        return usableStorage || defaultValue;
+      }
+
+      return _get(usableStorage, path, defaultValue);
+    },
+
+    set: (path, value) => {
+      let usableStorage;
+
+      try {
+        usableStorage = this.session.get();
+      } catch (e) {
+        usableStorage = {};
+      }
+
+      if (!path) {
+        usableStorage = value || {};
+      } else {
+        _set(usableStorage, path, value);
+      }
+
+      try {
+        window.sessionStorage.setItem(this.storageKey, JSON.stringify(usableStorage));
+      } catch (e) {
+        // Silent fail
+      }
+
+      return usableStorage;
+    },
+
+    remove: (path) => {
+      if (!path) {
+        this.session.clear();
+      } else {
+        this.session.set(path, undefined);
+      }
+    },
+
+    clear: () => {
+      try {
+        window.sessionStorage.setItem(this.storageKey, '{}');
+      } catch (e) {
+        // Silent fail
+      }
+    }
+  };
+}
+
+export default Storage;

package/src/modules/usage.js

@@ -0,0 +1,264 @@
+// Unit multipliers
+const UNITS = {
+  milliseconds: 1,
+  seconds: 1000,
+  minutes: 1000 * 60,
+  hours: 1000 * 60 * 60,
+  days: 1000 * 60 * 60 * 24,
+};
+
+// Storage key
+const STORAGE_KEY = 'wm_usage';
+
+// Session timeout (30 minutes of inactivity = new session)
+const SESSION_TIMEOUT = 30 * 60 * 1000;
+
+class Usage {
+  constructor(manager) {
+    this.manager = manager;
+    this.data = null;
+    this.initialized = false;
+    this.isNewVersion = false;
+  }
+
+  // Check if we're in a browser extension context
+  _isExtension() {
+    return this.manager.utilities().getRuntime() === 'browser-extension';
+  }
+
+  // Get extension storage API
+  _getExtensionStorage() {
+    if (typeof chrome !== 'undefined' && chrome.storage?.local) {
+      return chrome.storage.local;
+    }
+    if (typeof browser !== 'undefined' && browser.storage?.local) {
+      return browser.storage.local;
+    }
+    return null;
+  }
+
+  // Initialize - loads or creates usage data (async for extensions)
+  async initialize() {
+    // Skip if already initialized
+    if (this.initialized) {
+      return this.data;
+    }
+
+    // Load existing data based on runtime
+    let existing = null;
+
+    if (this._isExtension()) {
+      existing = await this._loadFromExtensionStorage();
+    } else {
+      existing = this._loadFromLocalStorage();
+    }
+
+    const now = Date.now();
+    const currentVersion = this.manager.config?.version || null;
+
+    if (existing) {
+      this.data = existing;
+
+      // Check if this is a new session (last activity was more than SESSION_TIMEOUT ago)
+      const timeSinceLastActive = now - (this.data.lastActive || 0);
+      if (timeSinceLastActive > SESSION_TIMEOUT) {
+        this.data.session.count = (this.data.session?.count || 0) + 1;
+        this.data.session.started = now;
+      }
+
+      // Update lastActive
+      this.data.lastActive = now;
+
+      // Check for version change
+      if (currentVersion && this.data.version?.current !== currentVersion) {
+        this.data.version = this.data.version || {};
+        this.data.version.previous = this.data.version.current;
+        this.data.version.current = currentVersion;
+        this.isNewVersion = true;
+      }
+
+      await this._save();
+    } else {
+      // First time usage
+      this.data = {
+        installed: now,
+        lastActive: now,
+        session: {
+          started: now,
+          count: 1,
+        },
+        version: {
+          initial: currentVersion,
+          current: currentVersion,
+          previous: null,
+        },
+      };
+      await this._save();
+    }
+
+    this.initialized = true;
+    return this.data;
+  }
+
+  // Load from extension storage (async)
+  async _loadFromExtensionStorage() {
+    const storage = this._getExtensionStorage();
+    if (!storage) {
+      return null;
+    }
+
+    try {
+      const result = await storage.get(STORAGE_KEY);
+      return result[STORAGE_KEY] || null;
+    } catch (e) {
+      console.warn('[Usage] Failed to load from extension storage:', e);
+      return null;
+    }
+  }
+
+  // Load from localStorage (sync)
+  _loadFromLocalStorage() {
+    try {
+      const data = localStorage.getItem(STORAGE_KEY);
+      return data ? JSON.parse(data) : null;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  // Save data to storage
+  async _save() {
+    if (this._isExtension()) {
+      await this._saveToExtensionStorage();
+    } else {
+      this._saveToLocalStorage();
+    }
+
+    return this.data;
+  }
+
+  // Save to extension storage (async)
+  async _saveToExtensionStorage() {
+    const storage = this._getExtensionStorage();
+    if (!storage) {
+      return;
+    }
+
+    try {
+      await storage.set({ [STORAGE_KEY]: this.data });
+    } catch (e) {
+      console.warn('[Usage] Failed to save to extension storage:', e);
+    }
+  }
+
+  // Save to localStorage (sync)
+  _saveToLocalStorage() {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(this.data));
+    } catch (e) {
+      // localStorage not available
+    }
+  }
+
+  // Calculate duration from a timestamp in specified units
+  _calculateDuration(timestamp, unit) {
+    if (!timestamp) {
+      return 0;
+    }
+
+    // Default to milliseconds
+    unit = unit || 'milliseconds';
+
+    // Get multiplier
+    const multiplier = UNITS[unit];
+    if (!multiplier) {
+      throw new Error(`Invalid unit: ${unit}. Valid units: ${Object.keys(UNITS).join(', ')}`);
+    }
+
+    return (Date.now() - timestamp) / multiplier;
+  }
+
+  // Get total usage duration in specified units (since installed)
+  getUsageDuration(unit) {
+    return this._calculateDuration(this.data?.installed, unit);
+  }
+
+  // Get current session duration in specified units
+  getSessionDuration(unit) {
+    return this._calculateDuration(this.data?.session?.started, unit);
+  }
+
+  // Get installed date
+  getInstalledDate() {
+    if (!this.data?.installed) {
+      return null;
+    }
+
+    return new Date(this.data.installed);
+  }
+
+  // Get session count
+  getSessionCount() {
+    return this.data?.session?.count || 0;
+  }
+
+  // Reset usage data (for testing or user request)
+  async reset() {
+    const now = Date.now();
+    const currentVersion = this.manager.config?.version || null;
+
+    this.data = {
+      installed: now,
+      lastActive: now,
+      session: {
+        started: now,
+        count: 1,
+      },
+      version: {
+        initial: currentVersion,
+        current: currentVersion,
+        previous: null,
+      },
+    };
+
+    this.isNewVersion = false;
+    await this._save();
+    return this.data;
+  }
+
+  // Get binding-friendly data object for bindings system
+  getBindingData() {
+    return {
+      installed: this.data?.installed || null,
+      lastActive: this.data?.lastActive || null,
+      session: {
+        started: this.data?.session?.started || null,
+        count: this.getSessionCount(),
+      },
+      version: {
+        initial: this.data?.version?.initial || null,
+        current: this.data?.version?.current || null,
+        previous: this.data?.version?.previous || null,
+        isNew: this.isNewVersion,
+      },
+      duration: {
+        total: {
+          milliseconds: this.getUsageDuration('milliseconds'),
+          seconds: this.getUsageDuration('seconds'),
+          minutes: this.getUsageDuration('minutes'),
+          hours: this.getUsageDuration('hours'),
+          days: this.getUsageDuration('days'),
+        },
+        session: {
+          milliseconds: this.getSessionDuration('milliseconds'),
+          seconds: this.getSessionDuration('seconds'),
+          minutes: this.getSessionDuration('minutes'),
+          hours: this.getSessionDuration('hours'),
+          days: this.getSessionDuration('days'),
+        },
+      },
+    };
+  }
+}
+
+export default Usage;