web-manager 4.0.36 → 4.0.38

package/README.md

@@ -249,7 +249,7 @@ Manager.utilities();      // Utility functions
 Manager.isDevelopment();                        // Check if in development mode
 Manager.getFunctionsUrl();                      // Get Firebase Functions URL
 Manager.getFunctionsUrl('development');         // Force development URL
-Manager.getApiUrl();                            // Get API URL (derived from authDomain)
+Manager.getApiUrl();                            // Get API URL (derived from firebase authDomain)
 Manager.isValidRedirectUrl('https://...');      // Validate redirect URL
 
 // Firebase instances (after initialization)

package/dist/index.js

@@ -1,12 +1,14 @@
 import Storage from './modules/storage.js';
-import * as utilities from './modules/utilities.js';
+import Utilities from './modules/utilities.js';
 import * as domUtils from './modules/dom.js';
+import Analytics from './modules/analytics.js';
 import Auth from './modules/auth.js';
 import Bindings from './modules/bindings.js';
 import Firestore from './modules/firestore.js';
 import Notifications from './modules/notifications.js';
 import ServiceWorker from './modules/service-worker.js';
 import Sentry from './modules/sentry.js';
+import Usage from './modules/usage.js';
 
 class Manager {
   constructor() {
@@ -23,12 +25,15 @@ class Manager {
 
     // Initialize modules
     this._storage = new Storage();
+    this._utilities = new Utilities(this);
+    this._analytics = new Analytics(this);
     this._auth = new Auth(this);
     this._bindings = new Bindings(this);
     this._firestore = new Firestore(this);
     this._notifications = new Notifications(this);
     this._serviceWorker = new ServiceWorker(this);
     this._sentry = new Sentry(this);
+    this._usage = new Usage(this);
   }
 
   // Module getters
@@ -60,13 +65,21 @@ class Manager {
     return this._sentry;
   }
 
+  usage() {
+    return this._usage;
+  }
+
+  analytics() {
+    return this._analytics;
+  }
+
   // DOM utilities
   dom() {
     return domUtils;
   }
 
   utilities() {
-    return utilities;
+    return this._utilities;
   }
 
   // Initialize the manager
@@ -88,6 +101,16 @@ class Manager {
         await this._sentry.init(this.config.sentry.config);
       }
 
+      // Initialize Analytics if tracking ID and secret are provided
+      if (this.config.tracking?.['google-analytics'] && this.config.tracking?.['google-analytics-secret']) {
+        this._analytics.init({
+          id: this.config.tracking['google-analytics'],
+          secret: this.config.tracking['google-analytics-secret'],
+        });
+      } else {
+        console.log('[Analytics] Skipped: missing google-analytics ID or secret');
+      }
+
       // Initialize service worker if enabled
       if (this.config.serviceWorker?.enabled) {
         this._serviceWorker.register({
@@ -111,8 +134,14 @@ class Manager {
       // Old IE force polyfill
       // await this._loadPolyfillsIfNeeded();
 
-      // Update bindings with config
-      this.bindings().update({ config: this.config });
+      // Initialize usage tracking
+      await this._usage.initialize();
+
+      // Update bindings with config and usage data
+      this.bindings().update({
+        config: this.config,
+        usage: this._usage.getBindingData(),
+      });
 
       return this;
     } catch (error) {
@@ -124,6 +153,7 @@ class Manager {
   _processConfiguration(configuration) {
     // Default configuration structure
     const defaults = {
+      runtime: null, // Auto-detect if not provided (web, browser-extension, electron, node)
       environment: 'production',
       buildTime: Date.now(),
       brand: {
@@ -266,6 +296,12 @@ class Manager {
           path: '/service-worker.js'
         }
       },
+      tracking: {
+        'google-analytics': '',
+        'google-analytics-secret': '',
+        'meta-pixel': '',
+        'tiktok-pixel': '',
+      },
     };
 
     // Deep merge configuration with defaults
@@ -284,6 +320,11 @@ class Manager {
       merged.refreshNewVersion.config.interval = safeEvaluate(merged.refreshNewVersion.config.interval);
     }
 
+    // Calculate buildTimeISO from buildTime
+    if (merged.buildTime) {
+      merged.buildTimeISO = new Date(merged.buildTime).toISOString();
+    }
+
     // Return merged configuration
     return merged;
   }
@@ -318,13 +359,13 @@ class Manager {
     const $html = document.documentElement;
 
     // Set platform (OS) - windows, mac, linux, ios, android, chromeos, unknown
-    $html.dataset.platform = utilities.getPlatform();
+    $html.dataset.platform = this._utilities.getPlatform();
 
-    // Set runtime - web, extension, electron, node
-    $html.dataset.runtime = utilities.getRuntime();
+    // Set runtime - web, browser-extension, electron, node
+    $html.dataset.runtime = this._utilities.getRuntime();
 
     // Set device type - mobile, tablet, desktop
-    $html.dataset.device = utilities.getDeviceType();
+    $html.dataset.device = this._utilities.getDeviceType();
   }
 
   async _initializeFirebase() {
@@ -417,8 +458,9 @@ class Manager {
       return 'http://localhost:5002';
     }
 
-    const authDomain = this.config.firebase.app.config.authDomain;
-    const baseUrl = url || (authDomain ? `https://${authDomain}` : window.location.origin);
+    const apiDomain = this.config.firebase.app.config.authDomain; // Has to be this since some projects like Clockii use ITW Universal Auth
+    // const apiDomain = this.config.brand.url;
+    const baseUrl = url || (apiDomain ? `https://${apiDomain}` : window.location.origin);
     const urlObj = new URL(baseUrl);
     const hostnameParts = urlObj.hostname.split('.');
 

package/dist/modules/analytics.js

@@ -0,0 +1,250 @@
+// Dev mode credentials by runtime
+const DEV_CREDENTIALS = {
+  'browser-extension': {
+    id: 'G-5NWE9SPEEM',
+    secret: '33E5W1cCQGKPK4lyMMOWOQ',
+  },
+  'electron': {
+    id: 'G-WMNERKK9J2',
+    secret: 'UeKzq8UvS3GD5D2aHcuZgQ',
+  },
+};
+
+// Supported runtimes for analytics
+const SUPPORTED_RUNTIMES = ['browser-extension', 'electron'];
+
+class Analytics {
+  constructor(manager) {
+    this.manager = manager;
+    this.initialized = false;
+    this.devMode = false;
+    this.runtime = null;
+    this.config = null;
+    this.measurementId = null;
+    this.secret = null;
+    this.clientId = null;
+  }
+
+  // Check if runtime is supported
+  _isSupported() {
+    return SUPPORTED_RUNTIMES.includes(this.runtime);
+  }
+
+  // Initialize analytics
+  init(config = {}) {
+    // Store config
+    this.config = config;
+
+    // Get runtime
+    this.runtime = this.manager.utilities().getRuntime();
+
+    // TODO: Add web runtime support
+    if (!this._isSupported()) {
+      console.log(`[Analytics] Runtime "${this.runtime}" not supported yet, skipping`);
+      return;
+    }
+
+    // Skip if already initialized
+    if (this.initialized) {
+      console.log('[Analytics] Already initialized');
+      return;
+    }
+
+    // Check for development mode
+    this.devMode = this.manager.isDevelopment();
+
+    // Get measurement ID and secret (use dev credentials in dev mode)
+    if (this.devMode) {
+      const devCreds = DEV_CREDENTIALS[this.runtime];
+      if (devCreds) {
+        this.measurementId = devCreds.id;
+        this.secret = devCreds.secret;
+        console.log(`[Analytics] Dev mode: using ${this.runtime} dev credentials`);
+      } else {
+        // No dev credentials for this runtime, use provided config
+        this.measurementId = config.measurementId || config.id;
+        this.secret = config.secret;
+      }
+    } else {
+      this.measurementId = config.measurementId || config.id;
+      this.secret = config.secret;
+    }
+
+    // Skip if no measurement ID
+    if (!this.measurementId) {
+      console.log('[Analytics] No measurement ID provided, skipping initialization');
+      return;
+    }
+
+    // Generate or retrieve client ID
+    this.clientId = this._getClientId();
+
+    // Log initialization
+    console.log(`[Analytics] Initializing with measurement ID: ${this.measurementId}${this.devMode ? ' (dev mode)' : ''} [${this.runtime}]`);
+
+    // Mark as initialized
+    this.initialized = true;
+
+    // Send initial pageview
+    this.event('page_view');
+  }
+
+  // Get or generate client ID
+  _getClientId() {
+    const storageKey = '_ga_client_id';
+
+    // Try to get existing client ID
+    let clientId = null;
+    try {
+      clientId = localStorage.getItem(storageKey);
+    } catch (e) {
+      // localStorage not available
+    }
+
+    // Generate new client ID if needed
+    if (!clientId) {
+      clientId = `${Math.random().toString(36).substring(2)}.${Date.now()}`;
+      try {
+        localStorage.setItem(storageKey, clientId);
+      } catch (e) {
+        // localStorage not available
+      }
+    }
+
+    return clientId;
+  }
+
+  // Get page data to include with all events
+  _getPageData() {
+    return {
+      page_path: window.location.pathname,
+      page_title: document.title,
+      page_location: window.location.href,
+    };
+  }
+
+  // Track an event
+  event(eventName, params = {}) {
+    // TODO: Add web runtime support
+    if (!this._isSupported()) {
+      return;
+    }
+
+    if (!this.initialized) {
+      return;
+    }
+
+    // Merge page data with provided params
+    const eventParams = {
+      ...this._getPageData(),
+      ...params,
+    };
+
+    // Log event
+    console.log(`[Analytics] Event: ${eventName}${this.devMode ? ' (dev mode)' : ''}`, eventParams);
+
+    // Send via Measurement Protocol (fetch)
+    this._sendViaFetch(eventName, eventParams);
+  }
+
+  // Send event via Measurement Protocol (fetch)
+  _sendViaFetch(eventName, params = {}) {
+    // Measurement Protocol requires api_secret
+    if (!this.secret) {
+      console.warn('[Analytics] No API secret provided, cannot send via Measurement Protocol');
+      return;
+    }
+
+    const url = `https://www.google-analytics.com/mp/collect?measurement_id=${this.measurementId}&api_secret=${this.secret}`;
+
+    const payload = {
+      client_id: this.clientId,
+      events: [{
+        name: eventName,
+        params: {
+          ...params,
+          engagement_time_msec: 100,
+          session_id: this._getSessionId(),
+        },
+      }],
+    };
+
+    // Send via fetch (fire and forget)
+    fetch(url, {
+      method: 'POST',
+      body: JSON.stringify(payload),
+    }).catch((err) => {
+      console.warn('[Analytics] Failed to send event:', err);
+    });
+  }
+
+  // Get or generate session ID
+  _getSessionId() {
+    const storageKey = '_ga_session_id';
+    const sessionTimeout = 30 * 60 * 1000; // 30 minutes
+
+    let sessionData = null;
+    try {
+      sessionData = JSON.parse(sessionStorage.getItem(storageKey) || 'null');
+    } catch (e) {
+      // sessionStorage not available
+    }
+
+    const now = Date.now();
+
+    // Check if session is still valid
+    if (sessionData && (now - sessionData.lastActive) < sessionTimeout) {
+      sessionData.lastActive = now;
+      try {
+        sessionStorage.setItem(storageKey, JSON.stringify(sessionData));
+      } catch (e) {
+        // sessionStorage not available
+      }
+      return sessionData.id;
+    }
+
+    // Create new session
+    const newSession = {
+      id: `${Date.now()}`,
+      lastActive: now,
+    };
+
+    try {
+      sessionStorage.setItem(storageKey, JSON.stringify(newSession));
+    } catch (e) {
+      // sessionStorage not available
+    }
+
+    return newSession.id;
+  }
+
+  // Set user properties
+  setUserProperties(properties = {}) {
+    // TODO: Add web runtime support
+    if (!this._isSupported()) {
+      return;
+    }
+
+    if (!this.initialized) {
+      return;
+    }
+
+    // TODO: Implement for Measurement Protocol
+  }
+
+  // Set user ID
+  setUserId(userId) {
+    // TODO: Add web runtime support
+    if (!this._isSupported()) {
+      return;
+    }
+
+    if (!this.initialized) {
+      return;
+    }
+
+    // TODO: Implement for Measurement Protocol
+  }
+}
+
+export default Analytics;

package/dist/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;

package/dist/modules/utilities.js

@@ -1,222 +1,209 @@
-// 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(() => {
+class Utilities {
+  constructor(manager) {
+    this.manager = manager;
+  }
+
+  // Copy text to clipboard
+  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);
-    });
-  } 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();
+    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');
-    }
+      try {
+        document.execCommand('copy');
+      } catch (e) {
+        console.error('Failed to copy to clipboard');
+      }
 
-    document.body.removeChild(el);
+      document.body.removeChild(el);
+    }
   }
-}
 
-// Escape HTML to prevent XSS
-let shadowElement;
-export function escapeHTML(str) {
-  if (typeof str !== 'string') {
-    return '';
-  }
+  // Escape HTML to prevent XSS
+  escapeHTML(str) {
+    if (typeof str !== 'string') {
+      return '';
+    }
 
-  shadowElement = shadowElement || document.createElement('p');
-  shadowElement.innerHTML = '';
+    this._shadowElement = this._shadowElement || document.createElement('p');
+    this._shadowElement.innerHTML = '';
 
-  // This automatically escapes HTML entities like <, >, &, etc.
-  shadowElement.appendChild(document.createTextNode(str));
+    // This automatically escapes HTML entities like <, >, &, etc.
+    this._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;';
-    }
-  });
-}
+    // This is needed to escape quotes to prevent attribute injection
+    return this._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';
+  // Show notification
+  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';
-  }
+    // 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;
-  }
+    // 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;
+    // 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>
-  `;
+    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);
+    document.body.appendChild($notification);
 
-  // Auto-remove after timeout (unless timeout is 0)
-  if (timeout > 0) {
-    setTimeout(() => {
-      $notification.remove();
-    }, timeout);
+    // Auto-remove after timeout (unless timeout is 0)
+    if (timeout > 0) {
+      setTimeout(() => {
+        $notification.remove();
+      }, timeout);
+    }
   }
-}
 
-// Get platform (OS)
-export function getPlatform() {
-  const ua = navigator.userAgent.toLowerCase();
-  const platform = (navigator.userAgentData?.platform || navigator.platform || '').toLowerCase();
+  // Get platform (OS)
+  getPlatform() {
+    const ua = navigator.userAgent.toLowerCase();
+    const platform = (navigator.userAgentData?.platform || navigator.platform || '').toLowerCase();
 
-  // Check userAgent for mobile platforms (more reliable than platform string)
-  if (/iphone|ipad|ipod/.test(ua)) {
-    return 'ios';
-  }
-  if (/android/.test(ua)) {
-    return 'android';
-  }
+    // Check userAgent for mobile platforms (more reliable than platform string)
+    if (/iphone|ipad|ipod/.test(ua)) {
+      return 'ios';
+    }
+    if (/android/.test(ua)) {
+      return 'android';
+    }
 
-  // Check platform string for desktop OS
-  if (/win/.test(platform)) {
-    return 'windows';
-  }
-  if (/mac/.test(platform)) {
-    return 'mac';
-  }
-  if (/cros/.test(ua)) {
-    return 'chromeos';
-  }
-  if (/linux/.test(platform)) {
-    return 'linux';
+    // Check platform string for desktop OS
+    if (/win/.test(platform)) {
+      return 'windows';
+    }
+    if (/mac/.test(platform)) {
+      return 'mac';
+    }
+    if (/cros/.test(ua)) {
+      return 'chromeos';
+    }
+    if (/linux/.test(platform)) {
+      return 'linux';
+    }
+
+    return 'unknown';
   }
 
-  return 'unknown';
-}
+  // Get runtime environment
+  getRuntime() {
+    // Use config runtime if provided
+    if (this.manager?.config?.runtime) {
+      return this.manager.config.runtime;
+    }
 
-// Get runtime environment
-export function getRuntime() {
-  // Browser extension (Chrome, Edge, Opera, Brave, Firefox, Safari, etc.)
-  if (
-    (typeof chrome !== 'undefined' && chrome.runtime?.id)
-    || (typeof browser !== 'undefined' && browser.runtime?.id)
-    || (typeof safari !== 'undefined' && safari.extension)
-  ) {
-    return 'browser-extension';
+    // Browser extension (Chrome, Edge, Opera, Brave, Firefox, Safari, etc.)
+    if (
+      (typeof chrome !== 'undefined' && chrome.runtime?.id)
+      || (typeof browser !== 'undefined' && browser.runtime?.id)
+      || (typeof safari !== 'undefined' && safari.extension)
+    ) {
+      return 'browser-extension';
+    }
+
+    // Default: web browser
+    return 'web';
   }
 
-  // // Electron (main process, or renderer with nodeIntegration, or via userAgent)
-  // if (
-  //   (typeof process !== 'undefined' && process.versions?.electron) ||
-  //   (typeof navigator !== 'undefined' && /electron/i.test(navigator.userAgent))
-  // ) {
-  //   return 'electron';
-  // }
-
-  // // Node.js (no window)
-  // if (typeof window === 'undefined') {
-  //   return 'node';
-  // }
-
-  // Default: web browser
-  return 'web';
-}
+  // Check if mobile device
+  isMobile() {
+    try {
+      // Try modern API first
+      const m = navigator.userAgentData?.mobile;
+      if (typeof m !== 'undefined') {
+        return m === true;
+      }
+    } catch (e) {
+      // Silent fail
+    }
 
-// Check if mobile device
-export function isMobile() {
-  try {
-    // Try modern API first
-    const m = navigator.userAgentData?.mobile;
-    if (typeof m !== 'undefined') {
-      return m === true;
+    // Fallback to media query
+    try {
+      return window.matchMedia('(max-width: 767px)').matches;
+    } catch (e) {
+      return false;
     }
-  } catch (e) {
-    // Silent fail
   }
 
-  // Fallback to media query
-  try {
-    return window.matchMedia('(max-width: 767px)').matches;
-  } catch (e) {
-    return false;
-  }
-}
+  // Get device type based on screen width
+  getDeviceType() {
+    const width = window.innerWidth;
 
-// Get device type based on screen width
-export function getDeviceType() {
-  const width = window.innerWidth;
+    // Mobile: < 768px (Bootstrap's md breakpoint)
+    if (width < 768) {
+      return 'mobile';
+    }
 
-  // Mobile: < 768px (Bootstrap's md breakpoint)
-  if (width < 768) {
-    return 'mobile';
-  }
+    // Tablet: 768px - 1199px (between md and xl)
+    if (width < 1200) {
+      return 'tablet';
+    }
 
-  // Tablet: 768px - 1199px (between md and xl)
-  if (width < 1200) {
-    return 'tablet';
+    // Desktop: >= 1200px
+    return 'desktop';
+  }
+
+  // Get context information
+  getContext() {
+    // Return context information
+    return {
+      client: {
+        language: navigator.language,
+        mobile: this.isMobile(),
+        deviceType: this.getDeviceType(),
+        platform: this.getPlatform(),
+        runtime: this.getRuntime(),
+        userAgent: navigator.userAgent,
+        url: window.location.href,
+      },
+      browser: {
+        vendor: navigator.vendor,
+      },
+    };
   }
-
-  // Desktop: >= 1200px
-  return 'desktop';
 }
 
-// Get context information
-export function getContext() {
-  // Return context information
-  return {
-    client: {
-      language: navigator.language,
-      mobile: isMobile(),
-      deviceType: getDeviceType(),
-      platform: getPlatform(),
-      runtime: getRuntime(),
-      userAgent: navigator.userAgent,
-      url: window.location.href,
-    },
-    browser: {
-      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,
-    // },
-  };
-}
+export default Utilities;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-manager",
-  "version": "4.0.36",
+  "version": "4.0.38",
   "description": "Easily access important variables such as the query string, current domain, and current page in a single object.",
   "main": "dist/index.js",
   "module": "src/index.js",