web-manager 3.2.74 → 4.0.0

package/dist/modules/service-worker.js

@@ -0,0 +1,321 @@
+class ServiceWorker {
+  constructor(manager) {
+    this.manager = manager;
+    this._registration = null;
+    this._updateCallbacks = [];
+    this._messageHandlers = new Map();
+  }
+
+  // Check if service workers are supported
+  isSupported() {
+    return 'serviceWorker' in navigator;
+  }
+
+  // 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 = {
+        app: this.manager.config.brand?.id,
+        environment: this.manager.config.environment,
+        buildTime: this.manager.config.buildTime,
+        firebase: this.manager.config.firebase?.app?.config || null
+      };
+
+      // Get service worker URL with config
+      const swUrl = `${swPath}?config=${encodeURIComponent(JSON.stringify(config))}`;
+
+      // Get existing registrations
+      const registrations = await navigator.serviceWorker.getRegistrations();
+
+      // Check if service worker is already registered for this scope
+      let registration = registrations.find(reg =>
+        reg.scope === new URL(scope, window.location.href).href
+      );
+
+      // This helps the .register() method NOT HANG FOREVER
+      if (registration) {
+        console.log('Using existing service worker registration');
+        // Check for updates on existing registration
+        registration.update();
+      } else {
+        console.log('Registering new service worker');
+        // Register with config in URL
+        registration = await navigator.serviceWorker.register(swUrl, {
+          scope,
+          updateViaCache: options.updateViaCache || 'imports'
+        });
+      }
+
+      this._registration = registration;
+      this.manager.state.serviceWorker = registration;
+
+      // Set up update handlers
+      this._setupUpdateHandlers(registration);
+
+      // Check for updates
+      if (options.checkForUpdate !== false) {
+        registration.update();
+      }
+
+      // Set up message channel
+      if (registration.active) {
+        this._setupMessageChannel();
+      }
+
+      return registration;
+    } catch (error) {
+      console.error('Service Worker registration failed:', error);
+      throw error;
+    }
+  }
+
+  // Unregister service worker
+  async unregister() {
+    try {
+      if (!this._registration) {
+        const registrations = await navigator.serviceWorker.getRegistrations();
+        for (const registration of registrations) {
+          await registration.unregister();
+        }
+      } else {
+        await this._registration.unregister();
+      }
+
+      this._registration = null;
+      this.manager.state.serviceWorker = null;
+
+      return true;
+    } catch (error) {
+      console.error('Service Worker unregistration failed:', error);
+      return false;
+    }
+  }
+
+  // Get current registration
+  getRegistration() {
+    return this._registration;
+  }
+
+  // Check for updates
+  async update() {
+    try {
+      if (!this._registration) {
+        throw new Error('No service worker registered');
+      }
+
+      await this._registration.update();
+      return true;
+    } catch (error) {
+      console.error('Service Worker update failed:', error);
+      return false;
+    }
+  }
+
+  // Post message to service worker
+  postMessage(message, options = {}) {
+    return new Promise((resolve, reject) => {
+      if (!this.isSupported()) {
+        return reject(new Error('Service Workers not supported'));
+      }
+
+      const controller = this._registration?.active || navigator.serviceWorker.controller;
+
+      if (!controller) {
+        return reject(new Error('No active service worker'));
+      }
+
+      const messageChannel = new MessageChannel();
+      const timeout = options.timeout || 5000;
+      let timeoutId;
+
+      // Set up timeout
+      if (timeout > 0) {
+        timeoutId = setTimeout(() => {
+          messageChannel.port1.close();
+          reject(new Error('Service worker message timeout'));
+        }, timeout);
+      }
+
+      // Listen for response
+      messageChannel.port1.onmessage = (event) => {
+        clearTimeout(timeoutId);
+
+        if (event.data.error) {
+          reject(new Error(event.data.error));
+        } else {
+          resolve(event.data);
+        }
+      };
+
+      // Send message
+      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);
+        }
+      }
+    };
+  }
+
+  // Skip waiting and activate new service worker
+  async skipWaiting() {
+    try {
+      if (!this._registration?.waiting) {
+        throw new Error('No service worker waiting');
+      }
+
+      // Post message to skip waiting
+      await this.postMessage({ action: 'skipWaiting' });
+
+      // Reload page after activation
+      let refreshing = false;
+      navigator.serviceWorker.addEventListener('controllerchange', () => {
+        if (!refreshing) {
+          refreshing = true;
+          window.location.reload();
+        }
+      });
+
+      return true;
+    } catch (error) {
+      console.error('Skip waiting failed:', error);
+      return false;
+    }
+  }
+
+  // Listen for update events
+  onUpdateFound(callback) {
+    this._updateCallbacks.push(callback);
+
+    return () => {
+      const index = this._updateCallbacks.indexOf(callback);
+      if (index > -1) {
+        this._updateCallbacks.splice(index, 1);
+      }
+    };
+  }
+
+  // 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: Set up update handlers
+  _setupUpdateHandlers(registration) {
+    // Listen for updates
+    registration.addEventListener('updatefound', () => {
+      const newWorker = registration.installing;
+
+      if (!newWorker) return;
+
+      newWorker.addEventListener('statechange', () => {
+        if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
+          // New service worker available
+          this._notifyUpdateCallbacks({
+            type: 'update-available',
+            worker: newWorker
+          });
+          
+          // Automatically skip waiting and activate new worker
+          if (this.manager.config.serviceWorker?.autoUpdate !== false) {
+            this.skipWaiting();
+          }
+        }
+      });
+    });
+
+    // Listen for controller changes
+    let refreshing = false;
+    navigator.serviceWorker.addEventListener('controllerchange', () => {
+      if (!refreshing) {
+        this._notifyUpdateCallbacks({
+          type: 'controller-change'
+        });
+      }
+    });
+  }
+
+  // Private: Notify update callbacks
+  _notifyUpdateCallbacks(event) {
+    this._updateCallbacks.forEach(callback => {
+      try {
+        callback(event);
+      } catch (error) {
+        console.error('Update callback error:', error);
+      }
+    });
+  }
+
+  // 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);
+        }
+      });
+    }
+  }
+
+  // Private: Set up message channel
+  _setupMessageChannel() {
+    // This ensures we can communicate with the service worker
+    navigator.serviceWorker.ready.then(() => {
+      console.log('Service Worker ready for messaging');
+    });
+  }
+}
+
+export default ServiceWorker;

package/dist/modules/storage.js

@@ -0,0 +1,132 @@
+import { get as _get, set as _set } from '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/dist/modules/utilities.js

@@ -0,0 +1,143 @@
+// Copy text to clipboard
+export function clipboardCopy(input) {
+  // Get the text from the input
+  const text = input && input.nodeType
+    ? input.value || input.innerText || input.innerHTML
+    : input;
+
+  // Try to use the modern clipboard API
+  if (navigator.clipboard && navigator.clipboard.writeText) {
+    return navigator.clipboard.writeText(text).catch(() => {
+      fallbackCopy(text);
+    });
+  } else {
+    fallbackCopy(text);
+  }
+
+  function fallbackCopy(text) {
+    const el = document.createElement('textarea');
+    el.setAttribute('style', 'width:1px;border:0;opacity:0;');
+    el.value = text;
+    document.body.appendChild(el);
+    el.select();
+
+    try {
+      document.execCommand('copy');
+    } catch (e) {
+      console.error('Failed to copy to clipboard');
+    }
+
+    document.body.removeChild(el);
+  }
+}
+
+// Escape HTML to prevent XSS
+let shadowElement;
+export function escapeHTML(str) {
+  if (typeof str !== 'string') {
+    return '';
+  }
+
+  shadowElement = shadowElement || document.createElement('p');
+  shadowElement.innerHTML = '';
+
+  // This automatically escapes HTML entities like <, >, &, etc.
+  shadowElement.appendChild(document.createTextNode(str));
+
+  // This is needed to escape quotes to prevent attribute injection
+  return shadowElement.innerHTML.replace(/["']/g, (m) => {
+    switch (m) {
+      case '"':
+        return '&quot;';
+      default:
+        return '&#039;';
+    }
+  });
+}
+
+// Show notification
+export function showNotification(message, options = {}) {
+  // Handle different input types
+  let text = message;
+  let type = options.type || 'info';
+  
+  // If message is an Error object, extract message and default to danger
+  if (message instanceof Error) {
+    text = message.message;
+    type = options.type || 'danger';
+  }
+  
+  // Handle string as second parameter for backwards compatibility
+  if (typeof options === 'string') {
+    options = { type: options };
+    type = options.type;
+  }
+  
+  // Extract options
+  const timeout = options.timeout !== undefined ? options.timeout : 5000;
+  
+  const $notification = document.createElement('div');
+  $notification.className = `alert alert-${type} alert-dismissible fade show position-fixed top-0 start-50 translate-middle-x mt-5`;
+  $notification.style.zIndex = '9999';
+  $notification.innerHTML = `
+    ${text}
+    <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
+  `;
+
+  document.body.appendChild($notification);
+
+  // Auto-remove after timeout (unless timeout is 0)
+  if (timeout > 0) {
+    setTimeout(() => {
+      $notification.remove();
+    }, timeout);
+  }
+}
+
+// Get context information
+export function getContext() {
+  // Check if mobile
+  function isMobile() {
+    try {
+      // Try modern API first
+      const m = navigator.userAgentData?.mobile;
+      if (typeof m !== 'undefined') {
+        return m === true;
+      }
+    } catch (e) {
+      // Silent fail
+    }
+
+    // Fallback to media query
+    try {
+      return window.matchMedia('(max-width: 767px)').matches;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  // Return context information
+  return {
+    client: {
+      mobile: isMobile(),
+    },
+    browser: {
+      userAgent: navigator.userAgent,
+      language: navigator.language,
+      platform: navigator.platform,
+      vendor: navigator.vendor,
+    },
+    screen: {
+      width: window.screen?.width,
+      height: window.screen?.height,
+      availWidth: window.screen?.availWidth,
+      availHeight: window.screen?.availHeight,
+      colorDepth: window.screen?.colorDepth,
+      pixelRatio: window.devicePixelRatio || 1,
+    },
+    viewport: {
+      width: window.innerWidth,
+      height: window.innerHeight,
+    }
+  };
+}

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "web-manager",
-  "version": "3.2.74",
+  "version": "4.0.0",
   "description": "Easily access important variables such as the query string, current domain, and current page in a single object.",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "module": "src/index.js",
   "scripts": {
     "test": "./node_modules/mocha/bin/mocha test/ --recursive --timeout=10000",
     "test_": "npm run prepare && ./node_modules/mocha/bin/mocha test/ --recursive --timeout=10000",
     "prepare_": "node -e 'require(`prepare-package`)()'",
     "prepare": "node -e \"require('prepare-package')()\"",
-    "prepare:watch": "nodemon -w ./src -e '*' --exec 'npm run prepare'"
+    "prepare:watch": "node -e \"require('prepare-package/watch')()\""
   },
   "engines": {
     "node": ">=12"
@@ -40,15 +41,15 @@
     "replace": {}
   },
   "dependencies": {
-    "@sentry/browser": "^8.54.0",
-    "cookieconsent": "^3.1.1",
-    "firebase": "^9.23.0",
+    "@sentry/browser": "^10.8.0",
+    "firebase": "^12.2.1",
     "itwcw-package-analytics": "^1.0.6",
-    "lazysizes": "^5.3.2"
+    "lodash": "^4.17.21",
+    "resolve-account": "^2.0.0"
   },
   "devDependencies": {
     "lodash": "^4.17.21",
     "mocha": "^8.4.0",
-    "prepare-package": "^1.1.13"
+    "prepare-package": "^1.2.2"
   }
 }