web-manager 4.3.1 → 4.3.3

package/_legacy/service-worker copy.js

@@ -1,347 +0,0 @@
-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 just cache breaker
-      const cacheBreaker = config.buildTime || Date.now();
-      const swUrl = `${swPath}?cb=${cacheBreaker}`;
-
-      // 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
-      );
-
-      // Always register/re-register to ensure we have the correct URL with config
-      console.log('----WM SW 1');
-
-      if (registration) {
-      console.log('----WM SW 2');
-        console.log('Unregistering existing service worker to update config');
-        await registration.unregister();
-        // Wait a bit for unregistration to complete
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }
-      console.log('----WM SW 3');
-
-      console.log('Registering service worker with cache breaker');
-      registration = await navigator.serviceWorker.register(swUrl, {
-        scope,
-        updateViaCache: options.updateViaCache || 'imports'
-      });
-
-      // Wait for the service worker to be ready
-      await navigator.serviceWorker.ready;
-
-      // Send the full config via postMessage after registration
-      console.log('----WM SW 4');
-      if (registration.active) {
-      console.log('----WM SW 5');
-        try {
-          this.postMessage({
-            command: 'update-config',
-            payload: config
-          });
-        } catch (error) {
-          console.warn('Could not send config to service worker:', error);
-        }
-      }
-
-      this._registration = registration;
-      this.manager.state.serviceWorker = registration;
-      console.log('----WM SW 6');
-
-      // Set up update handlers
-      this._setupUpdateHandlers(registration);
-      console.log('----WM SW 7');
-
-      // Check for updates
-      if (options.checkForUpdate !== false) {
-        registration.update();
-      }
-      console.log('----WM SW 8');
-
-      // Set up message channel
-      if (registration.active) {
-        this._setupMessageChannel();
-      }
-      console.log('----WM SW 9');
-
-      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/_legacy/test/test.js

@@ -1,158 +0,0 @@
-const package = require('../package.json');
-const assert = require('assert');
-
-beforeEach(() => {
-});
-
-before(() => {
-});
-
-after(() => {
-});
-
-/*
- * ============
- *  Test Cases
- * ============
- */
-describe(`${package.name}`, () => {
-  const _ = require('../lib/utilities.js');
-  const lodash = require('lodash');
-
-  // Utilities
-  describe('.utilities()', () => {
-    const sample = {
-      main: {
-        true: true,
-        false: false,
-        zero: 0,
-        one: 1,
-        string: 'string',
-        stringEmpty: '',
-        object: {},
-        array: [],
-        null: null,
-        undefined: undefined,
-        nan: NaN,
-        infinity: Infinity,
-        negativeInfinity: -Infinity,
-        function: function () {},
-      }
-    }
-
-    // Normal Cases
-    describe('.get()', () => {
-      it('should return true', () => {
-        // console.log('---lodash', lodash.get(sample, 'main.true'));
-        // console.log('---_.get', _.get(sample, 'main.true'));
-        // console.log('---_.get2', _.get2(sample, 'main.true'));
-
-        assert.strictEqual(_.get(sample, 'main.true'), true);
-      });
-
-      it('should return false', () => {
-        assert.strictEqual(_.get(sample, 'main.false'), false);
-      });
-
-      it('should return 0', () => {
-        assert.strictEqual(_.get(sample, 'main.zero'), 0);
-      });
-
-      it('should return 1', () => {
-        assert.strictEqual(_.get(sample, 'main.one'), 1);
-      });
-
-      it('should return a string', () => {
-        assert.strictEqual(_.get(sample, 'main.string'), 'string');
-      });
-
-      it('should return an empty string', () => {
-        assert.strictEqual(_.get(sample, 'main.stringEmpty'), '');
-      });
-
-      it('should return an object', () => {
-        assert.deepStrictEqual(_.get(sample, 'main.object'), {});
-      });
-
-      it('should return an array', () => {
-        assert.deepStrictEqual(_.get(sample, 'main.array'), []);
-      });
-
-      it('should return null', () => {
-        assert.strictEqual(_.get(sample, 'main.null'), null);
-      });
-
-      it('should return undefined', () => {
-        assert.strictEqual(_.get(sample, 'main.undefined'), undefined);
-      });
-
-      it('should return NaN', () => {
-        assert.strictEqual(Number.isNaN(_.get(sample, 'main.nan')), true);
-      });
-
-      it('should return Infinity', () => {
-        assert.strictEqual(_.get(sample, 'main.infinity'), Infinity);
-      });
-
-      it('should return -Infinity', () => {
-        assert.strictEqual(_.get(sample, 'main.negativeInfinity'), -Infinity);
-      });
-
-      it('should return a function', () => {
-        assert.strictEqual(typeof _.get(sample, 'main.function'), 'function');
-      });
-
-      // Non-existent
-      it('should return undefined', () => {
-        assert.strictEqual(_.get(sample, 'main.nonexistent'), undefined);
-      });
-
-      // No path
-      it('should return undefined', () => {
-        assert.strictEqual(_.get(sample), undefined);
-      });
-
-      // Empty path
-      it('should return undefined', () => {
-        assert.strictEqual(_.get(sample, ''), undefined);
-      });
-
-      // Default value
-      it('should return default value', () => {
-        assert.strictEqual(_.get(sample, 'main.nonexistent', 'default'), 'default');
-      });
-
-      it('should return actual value', () => {
-        assert.strictEqual(_.get(sample, 'main.false', 'default'), false);
-      });
-
-      it('should return actual value', () => {
-        assert.strictEqual(_.get(sample, 'main.null', 'default'), null);
-      });
-
-      it('should return default value', () => {
-        assert.strictEqual(_.get(sample, 'main.undefined', 'default'), 'default');
-      });
-
-      // Non-object for object
-      it('should return undefined', () => {
-        assert.strictEqual(_.get(undefined, 'main.true'), undefined);
-      });
-
-      it('should return undefined', () => {
-        assert.strictEqual(_.get(null, 'main.true'), undefined);
-      });
-
-      it('should return undefined', () => {
-        assert.strictEqual(_.get(false, 'main.true'), undefined);
-      });
-
-      it('should return undefined', () => {
-        assert.strictEqual(_.get('', 'main.true'), undefined);
-      });
-
-    });
-
-  });
-
-})