workbox-broadcast-update - npm Package Compare versions

Comparing version 5.0.0-alpha.0 to 5.0.0-alpha.1

build/workbox-broadcast-update.dev.js

 this.workbox = this.workbox || {};
-this.workbox.broadcastUpdate = (function (exports, assert_mjs, getFriendlyURL_mjs, logger_mjs, Deferred_mjs, WorkboxError_mjs) {
-  'use strict';
+this.workbox.broadcastUpdate = (function (exports, assert_js, getFriendlyURL_js, logger_js, Deferred_js, WorkboxError_js) {
+    'use strict';
 
-  try {
-    self['workbox:broadcast-update:5.0.0-alpha.0'] && _();
-  } catch (e) {} // eslint-disable-line
+    // @ts-ignore
+    try {
+      self['workbox:broadcast-update:5.0.0-alpha.1'] && _();
+    } catch (e) {}
 
-  /*
-    Copyright 2018 Google LLC
+    /*
+      Copyright 2018 Google LLC
 
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  /**
-   * Given two `Response's`, compares several header values to see if they are
-   * the same or not.
-   *
-   * @param {Response} firstResponse
-   * @param {Response} secondResponse
-   * @param {Array<string>} headersToCheck
-   * @return {boolean}
-   *
-   * @memberof workbox.broadcastUpdate
-   * @private
-   */
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
+    /**
+     * Given two `Response's`, compares several header values to see if they are
+     * the same or not.
+     *
+     * @param {Response} firstResponse
+     * @param {Response} secondResponse
+     * @param {Array<string>} headersToCheck
+     * @return {boolean}
+     *
+     * @memberof workbox.broadcastUpdate
+     * @private
+     */
 
-  const responsesAreSame = (firstResponse, secondResponse, headersToCheck) => {
-    {
-      if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
-        throw new WorkboxError_mjs.WorkboxError('invalid-responses-are-same-args');
+    const responsesAreSame = (firstResponse, secondResponse, headersToCheck) => {
+      {
+        if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
+          throw new WorkboxError_js.WorkboxError('invalid-responses-are-same-args');
+        }
       }
-    }
 
-    const atLeastOneHeaderAvailable = headersToCheck.some(header => {
-      return firstResponse.headers.has(header) && secondResponse.headers.has(header);
-    });
+      const atLeastOneHeaderAvailable = headersToCheck.some(header => {
+        return firstResponse.headers.has(header) && secondResponse.headers.has(header);
+      });
 
-    if (!atLeastOneHeaderAvailable) {
-      {
-        logger_mjs.logger.warn(`Unable to determine where the response has been updated ` + `because none of the headers that would be checked are present.`);
-        logger_mjs.logger.debug(`Attempting to compare the following: `, firstResponse, secondResponse, headersToCheck);
-      } // Just return true, indicating the that responses are the same, since we
-      // can't determine otherwise.
+      if (!atLeastOneHeaderAvailable) {
+        {
+          logger_js.logger.warn(`Unable to determine where the response has been updated ` + `because none of the headers that would be checked are present.`);
+          logger_js.logger.debug(`Attempting to compare the following: `, firstResponse, secondResponse, headersToCheck);
+        } // Just return true, indicating the that responses are the same, since we
+        // can't determine otherwise.
 
 
-      return true;
-    }
+        return true;
+      }
 
-    return headersToCheck.every(header => {
-      const headerStateComparison = firstResponse.headers.has(header) === secondResponse.headers.has(header);
-      const headerValueComparison = firstResponse.headers.get(header) === secondResponse.headers.get(header);
-      return headerStateComparison && headerValueComparison;
-    });
-  };
-
-  /*
-    Copyright 2018 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  const CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';
-  const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';
-  const DEFAULT_BROADCAST_CHANNEL_NAME = 'workbox';
-  const DEFAULT_DEFER_NOTIFICATION_TIMEOUT = 10000;
-  const DEFAULT_HEADERS_TO_CHECK = ['content-length', 'etag', 'last-modified'];
-
-  /*
-    Copyright 2018 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  /**
-   * You would not normally call this method directly; it's called automatically
-   * by an instance of the {@link BroadcastCacheUpdate} class. It's exposed here
-   * for the benefit of developers who would rather not use the full
-   * `BroadcastCacheUpdate` implementation.
-   *
-   * Calling this will dispatch a message on the provided
-   * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel}
-   * to notify interested subscribers about a change to a cached resource.
-   *
-   * The message that's posted has a formation inspired by the
-   * [Flux standard action](https://github.com/acdlite/flux-standard-action#introduction)
-   * format like so:
-   *
-   * ```
-   * {
-   *   type: 'CACHE_UPDATED',
-   *   meta: 'workbox-broadcast-update',
-   *   payload: {
-   *     cacheName: 'the-cache-name',
-   *     updatedURL: 'https://example.com/'
-   *   }
-   * }
-   * ```
-   *
-   * (Usage of [Flux](https://facebook.github.io/flux/) itself is not at
-   * all required.)
-   *
-   * @param {Object} options
-   * @param {string} options.cacheName The name of the cache in which the updated
-   *     `Response` was stored.
-   * @param {string} options.url The URL associated with the updated `Response`.
-   * @param {BroadcastChannel} [options.channel] The `BroadcastChannel` to use.
-   *     If no channel is set or the browser doesn't support the BroadcastChannel
-   *     api, then an attempt will be made to `postMessage` each window client.
-   *
-   * @memberof workbox.broadcastUpdate
-   */
-
-  const broadcastUpdate = async ({
-    channel,
-    cacheName,
-    url
-  }) => {
-    {
-      assert_mjs.assert.isType(cacheName, 'string', {
-        moduleName: 'workbox-broadcast-update',
-        className: '~',
-        funcName: 'broadcastUpdate',
-        paramName: 'cacheName'
+      return headersToCheck.every(header => {
+        const headerStateComparison = firstResponse.headers.has(header) === secondResponse.headers.has(header);
+        const headerValueComparison = firstResponse.headers.get(header) === secondResponse.headers.get(header);
+        return headerStateComparison && headerValueComparison;
       });
-      assert_mjs.assert.isType(url, 'string', {
-        moduleName: 'workbox-broadcast-update',
-        className: '~',
-        funcName: 'broadcastUpdate',
-        paramName: 'url'
-      });
-    }
-
-    const data = {
-      type: CACHE_UPDATED_MESSAGE_TYPE,
-      meta: CACHE_UPDATED_MESSAGE_META,
-      payload: {
-        cacheName: cacheName,
-        updatedURL: url
-      }
     };
 
-    if (channel) {
-      channel.postMessage(data);
-    } else {
-      const windows = await clients.matchAll({
-        type: 'window'
-      });
+    /*
+      Copyright 2018 Google LLC
 
-      for (const win of windows) {
-        win.postMessage(data);
-      }
-    }
-  };
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
+    const CACHE_UPDATED_MESSAGE_TYPE = 'CACHE_UPDATED';
+    const CACHE_UPDATED_MESSAGE_META = 'workbox-broadcast-update';
+    const DEFAULT_BROADCAST_CHANNEL_NAME = 'workbox';
+    const DEFAULT_DEFER_NOTIFICATION_TIMEOUT = 10000;
+    const DEFAULT_HEADERS_TO_CHECK = ['content-length', 'etag', 'last-modified'];
 
-  /*
-    Copyright 2018 Google LLC
+    /*
+      Copyright 2018 Google LLC
 
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  /**
-   * Uses the [Broadcast Channel API]{@link https://developers.google.com/web/updates/2016/09/broadcastchannel}
-   * to notify interested parties when a cached response has been updated.
-   * In browsers that do not support the Broadcast Channel API, the instance
-   * falls back to sending the update via `postMessage()` to all window clients.
-   *
-   * For efficiency's sake, the underlying response bodies are not compared;
-   * only specific response headers are checked.
-   *
-   * @memberof workbox.broadcastUpdate
-   */
-
-  class BroadcastCacheUpdate {
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
     /**
-     * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
-     * broadcast messages on
+     * You would not normally call this method directly; it's called automatically
+     * by an instance of the {@link BroadcastCacheUpdate} class. It's exposed here
+     * for the benefit of developers who would rather not use the full
+     * `BroadcastCacheUpdate` implementation.
      *
+     * Calling this will dispatch a message on the provided
+     * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel}
+     * to notify interested subscribers about a change to a cached resource.
+     *
+     * The message that's posted has a formation inspired by the
+     * [Flux standard action](https://github.com/acdlite/flux-standard-action#introduction)
+     * format like so:
+     *
+     * ```
+     * {
+     *   type: 'CACHE_UPDATED',
+     *   meta: 'workbox-broadcast-update',
+     *   payload: {
+     *     cacheName: 'the-cache-name',
+     *     updatedURL: 'https://example.com/'
+     *   }
+     * }
+     * ```
+     *
+     * (Usage of [Flux](https://facebook.github.io/flux/) itself is not at
+     * all required.)
+     *
      * @param {Object} options
-     * @param {Array<string>}
-     *     [options.headersToCheck=['content-length', 'etag', 'last-modified']]
-     *     A list of headers that will be used to determine whether the responses
-     *     differ.
-     * @param {string} [options.channelName='workbox'] The name that will be used
-     *.    when creating the `BroadcastChannel`, which defaults to 'workbox' (the
-     *     channel name used by the `workbox-window` package).
-     * @param {string} [options.deferNoticationTimeout=10000] The amount of time
-     *     to wait for a ready message from the window on navigation requests
-     *     before sending the update.
+     * @param {string} options.cacheName The name of the cache in which the updated
+     *     `Response` was stored.
+     * @param {string} options.url The URL associated with the updated `Response`.
+     * @param {BroadcastChannel} [options.channel] The `BroadcastChannel` to use.
+     *     If no channel is set or the browser doesn't support the BroadcastChannel
+     *     api, then an attempt will be made to `postMessage` each window client.
+     *
+     * @memberof workbox.broadcastUpdate
      */
-    constructor({
-      headersToCheck,
-      channelName,
-      deferNoticationTimeout
-    } = {}) {
-      this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;
-      this._channelName = channelName || DEFAULT_BROADCAST_CHANNEL_NAME;
-      this._deferNoticationTimeout = deferNoticationTimeout || DEFAULT_DEFER_NOTIFICATION_TIMEOUT;
 
+    const broadcastUpdate = async ({
+      channel,
+      cacheName,
+      url
+    }) => {
       {
-        assert_mjs.assert.isType(this._channelName, 'string', {
+        assert_js.assert.isType(cacheName, 'string', {
           moduleName: 'workbox-broadcast-update',
-          className: 'BroadcastCacheUpdate',
-          funcName: 'constructor',
-          paramName: 'channelName'
+          className: '~',
+          funcName: 'broadcastUpdate',
+          paramName: 'cacheName'
         });
-        assert_mjs.assert.isArray(this._headersToCheck, {
+        assert_js.assert.isType(url, 'string', {
           moduleName: 'workbox-broadcast-update',
-          className: 'BroadcastCacheUpdate',
-          funcName: 'constructor',
-          paramName: 'headersToCheck'
+          className: '~',
+          funcName: 'broadcastUpdate',
+          paramName: 'url'
         });
       }
 
-      this._initWindowReadyDeferreds();
-    }
+      const data = {
+        type: CACHE_UPDATED_MESSAGE_TYPE,
+        meta: CACHE_UPDATED_MESSAGE_META,
+        payload: {
+          cacheName: cacheName,
+          updatedURL: url
+        }
+      };
+
+      if (channel) {
+        channel.postMessage(data);
+      } else {
+        const windows = await self.clients.matchAll({
+          type: 'window'
+        });
+
+        for (const win of windows) {
+          win.postMessage(data);
+        }
+      }
+    };
+
+    /*
+      Copyright 2018 Google LLC
+
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
     /**
-     * Compare two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
-     * and send a message via the
-     * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel API}
-     * if they differ.
+     * Uses the [Broadcast Channel API]{@link https://developers.google.com/web/updates/2016/09/broadcastchannel}
+     * to notify interested parties when a cached response has been updated.
+     * In browsers that do not support the Broadcast Channel API, the instance
+     * falls back to sending the update via `postMessage()` to all window clients.
      *
-     * Neither of the Responses can be {@link http://stackoverflow.com/questions/39109789|opaque}.
+     * For efficiency's sake, the underlying response bodies are not compared;
+     * only specific response headers are checked.
      *
-     * @param {Object} options
-     * @param {Response} options.oldResponse Cached response to compare.
-     * @param {Response} options.newResponse Possibly updated response to compare.
-     * @param {string} options.url The URL of the request.
-     * @param {string} options.cacheName Name of the cache the responses belong
-     *     to. This is included in the broadcast message.
-     * @param {Event} [options.event] event An optional event that triggered
-     *     this possible cache update.
-     * @return {Promise} Resolves once the update is sent.
+     * @memberof workbox.broadcastUpdate
      */
 
+    class BroadcastCacheUpdate {
+      /**
+       * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
+       * broadcast messages on
+       *
+       * @param {Object} options
+       * @param {Array<string>}
+       *     [options.headersToCheck=['content-length', 'etag', 'last-modified']]
+       *     A list of headers that will be used to determine whether the responses
+       *     differ.
+       * @param {string} [options.channelName='workbox'] The name that will be used
+       *.    when creating the `BroadcastChannel`, which defaults to 'workbox' (the
+       *     channel name used by the `workbox-window` package).
+       * @param {string} [options.deferNoticationTimeout=10000] The amount of time
+       *     to wait for a ready message from the window on navigation requests
+       *     before sending the update.
+       */
+      constructor({
+        headersToCheck,
+        channelName,
+        deferNoticationTimeout
+      } = {}) {
+        this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;
+        this._channelName = channelName || DEFAULT_BROADCAST_CHANNEL_NAME;
+        this._deferNoticationTimeout = deferNoticationTimeout || DEFAULT_DEFER_NOTIFICATION_TIMEOUT;
 
-    notifyIfUpdated({
-      oldResponse,
-      newResponse,
-      url,
-      cacheName,
-      event
-    }) {
-      if (!responsesAreSame(oldResponse, newResponse, this._headersToCheck)) {
         {
-          logger_mjs.logger.log(`Newer response found (and cached) for:`, url);
+          assert_js.assert.isType(this._channelName, 'string', {
+            moduleName: 'workbox-broadcast-update',
+            className: 'BroadcastCacheUpdate',
+            funcName: 'constructor',
+            paramName: 'channelName'
+          });
+          assert_js.assert.isArray(this._headersToCheck, {
+            moduleName: 'workbox-broadcast-update',
+            className: 'BroadcastCacheUpdate',
+            funcName: 'constructor',
+            paramName: 'headersToCheck'
+          });
         }
 
-        const sendUpdate = async () => {
-          // In the case of a navigation request, the requesting page will likely
-          // not have loaded its JavaScript in time to recevied the update
-          // notification, so we defer it until ready (or we timeout waiting).
-          if (event && event.request && event.request.mode === 'navigate') {
-            {
-              logger_mjs.logger.debug(`Original request was a navigation request, ` + `waiting for a ready message from the window`, event.request);
-            }
+        this._initWindowReadyDeferreds();
+      }
+      /**
+       * Compare two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+       * and send a message via the
+       * {@link https://developers.google.com/web/updates/2016/09/broadcastchannel|Broadcast Channel API}
+       * if they differ.
+       *
+       * Neither of the Responses can be {@link http://stackoverflow.com/questions/39109789|opaque}.
+       *
+       * @param {Object} options
+       * @param {Response} options.oldResponse Cached response to compare.
+       * @param {Response} options.newResponse Possibly updated response to compare.
+       * @param {string} options.url The URL of the request.
+       * @param {string} options.cacheName Name of the cache the responses belong
+       *     to. This is included in the broadcast message.
+       * @param {Event} [options.event] event An optional event that triggered
+       *     this possible cache update.
+       * @return {Promise} Resolves once the update is sent.
+       */
 
-            await this._windowReadyOrTimeout(event);
+
+      notifyIfUpdated({
+        oldResponse,
+        newResponse,
+        url,
+        cacheName,
+        event
+      }) {
+        if (!responsesAreSame(oldResponse, newResponse, this._headersToCheck)) {
+          {
+            logger_js.logger.log(`Newer response found (and cached) for:`, url);
           }
 
-          await this._broadcastUpdate({
-            channel: this._getChannel(),
-            cacheName,
-            url
-          });
-        }; // Send the update and ensure the SW stays alive until it's sent.
+          const sendUpdate = async () => {
+            // In the case of a navigation request, the requesting page will likely
+            // not have loaded its JavaScript in time to recevied the update
+            // notification, so we defer it until ready (or we timeout waiting).
+            if (event && event.request && event.request.mode === 'navigate') {
+              {
+                logger_js.logger.debug(`Original request was a navigation request, ` + `waiting for a ready message from the window`, event.request);
+              }
 
+              await this._windowReadyOrTimeout(event);
+            }
 
-        const done = sendUpdate();
+            await this._broadcastUpdate({
+              channel: this._getChannel(),
+              cacheName,
+              url
+            });
+          }; // Send the update and ensure the SW stays alive until it's sent.
 
-        if (event) {
-          try {
-            event.waitUntil(done);
-          } catch (error) {
-            {
-              logger_mjs.logger.warn(`Unable to ensure service worker stays alive ` + `when broadcasting cache update for ` + `${getFriendlyURL_mjs.getFriendlyURL(event.request.url)}'.`);
+
+          const done = sendUpdate();
+
+          if (event) {
+            try {
+              event.waitUntil(done);
+            } catch (error) {
+              {
+                logger_js.logger.warn(`Unable to ensure service worker stays alive ` + `when broadcasting cache update for ` + `${getFriendlyURL_js.getFriendlyURL(event.request.url)}'.`);
+              }
             }
           }
+
+          return done;
         }
+      }
+      /**
+       * NOTE: this is exposed on the instance primarily so it can be spied on
+       * in tests.
+       *
+       * @param {Object} opts
+       * @private
+       */
 
-        return done;
+
+      async _broadcastUpdate(opts) {
+        await broadcastUpdate(opts);
       }
-    }
-    /**
-     * NOTE: this is exposed on the instance primarily so it can be spied on
-     * in tests.
-     *
-     * @param {Object} opts
-     * @private
-     */
+      /**
+       * @return {BroadcastChannel|undefined} The BroadcastChannel instance used for
+       * broadcasting updates, or undefined if the browser doesn't support the
+       * Broadcast Channel API.
+       *
+       * @private
+       */
 
 
-    async _broadcastUpdate(opts) {
-      await broadcastUpdate(opts);
-    }
-    /**
-     * @return {BroadcastChannel|undefined} The BroadcastChannel instance used for
-     * broadcasting updates, or undefined if the browser doesn't support the
-     * Broadcast Channel API.
-     *
-     * @private
-     */
+      _getChannel() {
+        if ('BroadcastChannel' in self && !this._channel) {
+          this._channel = new BroadcastChannel(this._channelName);
+        }
 
-
-    _getChannel() {
-      if ('BroadcastChannel' in self && !this._channel) {
-        this._channel = new BroadcastChannel(this._channelName);
+        return this._channel;
       }
+      /**
+       * Waits for a message from the window indicating that it's capable of
+       * receiving broadcasts. By default, this will only wait for the amount of
+       * time specified via the `deferNoticationTimeout` option.
+       *
+       * @param {Event} event The navigation fetch event.
+       * @return {Promise}
+       * @private
+       */
 
-      return this._channel;
-    }
-    /**
-     * Waits for a message from the window indicating that it's capable of
-     * receiving broadcasts. By default, this will only wait for the amount of
-     * time specified via the `deferNoticationTimeout` option.
-     *
-     * @param {Event} event The navigation fetch event.
-     * @return {Promise}
-     * @private
-     */
 
+      _windowReadyOrTimeout(event) {
+        if (!this._navigationEventsDeferreds.has(event)) {
+          const deferred = new Deferred_js.Deferred(); // Set the deferred on the `_navigationEventsDeferreds` map so it will
+          // be resolved when the next ready message event comes.
 
-    _windowReadyOrTimeout(event) {
-      if (!this._navigationEventsDeferreds.has(event)) {
-        const deferred = new Deferred_mjs.Deferred(); // Set the deferred on the `_navigationEventsDeferreds` map so it will
-        // be resolved when the next ready message event comes.
+          this._navigationEventsDeferreds.set(event, deferred); // But don't wait too long for the message since it may never come.
 
-        this._navigationEventsDeferreds.set(event, deferred); // But don't wait too long for the message since it may never come.
 
+          const timeout = setTimeout(() => {
+            {
+              logger_js.logger.debug(`Timed out after ${this._deferNoticationTimeout}` + `ms waiting for message from window`);
+            }
 
-        const timeout = setTimeout(() => {
-          {
-            logger_mjs.logger.debug(`Timed out after ${this._deferNoticationTimeout}` + `ms waiting for message from window`);
-          }
+            deferred.resolve();
+          }, this._deferNoticationTimeout); // Ensure the timeout is cleared if the deferred promise is resolved.
 
-          deferred.resolve();
-        }, this._deferNoticationTimeout); // Ensure the timeout is cleared if the deferred promise is resolved.
+          deferred.promise.then(() => clearTimeout(timeout));
+        }
 
-        deferred.promise.then(() => clearTimeout(timeout));
+        return this._navigationEventsDeferreds.get(event).promise;
       }
+      /**
+       * Creates a mapping between navigation fetch events and deferreds, and adds
+       * a listener for message events from the window. When message events arrive,
+       * all deferreds in the mapping are resolved.
+       *
+       * Note: it would be easier if we could only resolve the deferred of
+       * navigation fetch event whose client ID matched the source ID of the
+       * message event, but currently client IDs are not exposed on navigation
+       * fetch events: https://www.chromestatus.com/feature/4846038800138240
+       *
+       * @private
+       */
 
-      return this._navigationEventsDeferreds.get(event).promise;
-    }
-    /**
-     * Creates a mapping between navigation fetch events and deferreds, and adds
-     * a listener for message events from the window. When message events arrive,
-     * all deferreds in the mapping are resolved.
-     *
-     * Note: it would be easier if we could only resolve the deferred of
-     * navigation fetch event whose client ID matched the source ID of the
-     * message event, but currently client IDs are not exposed on navigation
-     * fetch events: https://www.chromestatus.com/feature/4846038800138240
-     *
-     * @private
-     */
 
+      _initWindowReadyDeferreds() {
+        // A mapping between navigation events and their deferreds.
+        this._navigationEventsDeferreds = new Map(); // The message listener needs to be added in the initial run of the
+        // service worker, but since we don't actually need to be listening for
+        // messages until the cache updates, we only invoke the callback if set.
 
-    _initWindowReadyDeferreds() {
-      // A mapping between navigation events and their deferreds.
-      this._navigationEventsDeferreds = new Map(); // The message listener needs to be added in the initial run of the
-      // service worker, but since we don't actually need to be listening for
-      // messages until the cache updates, we only invoke the callback if set.
+        self.addEventListener('message', event => {
+          if (event.data.type === 'WINDOW_READY' && event.data.meta === 'workbox-window' && this._navigationEventsDeferreds.size > 0) {
+            {
+              logger_js.logger.debug(`Received WINDOW_READY event: `, event);
+            } // Resolve any pending deferreds.
 
-      self.addEventListener('message', event => {
-        if (event.data.type === 'WINDOW_READY' && event.data.meta === 'workbox-window' && this._navigationEventsDeferreds.size > 0) {
-          {
-            logger_mjs.logger.debug(`Received WINDOW_READY event: `, event);
-          } // Resolve any pending deferreds.
 
+            for (const deferred of this._navigationEventsDeferreds.values()) {
+              deferred.resolve();
+            }
 
-          for (const deferred of this._navigationEventsDeferreds.values()) {
-            deferred.resolve();
+            this._navigationEventsDeferreds.clear();
           }
+        });
+      }
 
-          this._navigationEventsDeferreds.clear();
-        }
-      });
     }
 
-  }
+    /*
+      Copyright 2018 Google LLC
 
-  /*
-    Copyright 2018 Google LLC
-
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
-  /**
-   * This plugin will automatically broadcast a message whenever a cached response
-   * is updated.
-   *
-   * @memberof workbox.broadcastUpdate
-   */
-
-  class Plugin {
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
     /**
-     * Construct a BroadcastCacheUpdate instance with the passed options and
-     * calls its `notifyIfUpdated()` method whenever the plugin's
-     * `cacheDidUpdate` callback is invoked.
+     * This plugin will automatically broadcast a message whenever a cached response
+     * is updated.
      *
-     * @param {Object} options
-     * @param {Array<string>}
-     *     [options.headersToCheck=['content-length', 'etag', 'last-modified']]
-     *     A list of headers that will be used to determine whether the responses
-     *     differ.
-     * @param {string} [options.channelName='workbox'] The name that will be used
-     *.    when creating the `BroadcastChannel`, which defaults to 'workbox' (the
-     *     channel name used by the `workbox-window` package).
-     * @param {string} [options.deferNoticationTimeout=10000] The amount of time
-     *     to wait for a ready message from the window on navigation requests
-     *     before sending the update.
+     * @memberof workbox.broadcastUpdate
      */
-    constructor(options) {
-      this._broadcastUpdate = new BroadcastCacheUpdate(options);
-    }
-    /**
-     * A "lifecycle" callback that will be triggered automatically by the
-     * `workbox-sw` and `workbox-runtime-caching` handlers when an entry is
-     * added to a cache.
-     *
-     * @private
-     * @param {Object} options The input object to this function.
-     * @param {string} options.cacheName Name of the cache being updated.
-     * @param {Response} [options.oldResponse] The previous cached value, if any.
-     * @param {Response} options.newResponse The new value in the cache.
-     * @param {Request} options.request The request that triggered the udpate.
-     * @param {Request} [options.event] The event that triggered the update.
-     */
 
+    class Plugin {
+      /**
+       * Construct a BroadcastCacheUpdate instance with the passed options and
+       * calls its `notifyIfUpdated()` method whenever the plugin's
+       * `cacheDidUpdate` callback is invoked.
+       *
+       * @param {Object} options
+       * @param {Array<string>}
+       *     [options.headersToCheck=['content-length', 'etag', 'last-modified']]
+       *     A list of headers that will be used to determine whether the responses
+       *     differ.
+       * @param {string} [options.channelName='workbox'] The name that will be used
+       *.    when creating the `BroadcastChannel`, which defaults to 'workbox' (the
+       *     channel name used by the `workbox-window` package).
+       * @param {string} [options.deferNoticationTimeout=10000] The amount of time
+       *     to wait for a ready message from the window on navigation requests
+       *     before sending the update.
+       */
+      constructor(options) {
+        /**
+         * A "lifecycle" callback that will be triggered automatically by the
+         * `workbox-sw` and `workbox-runtime-caching` handlers when an entry is
+         * added to a cache.
+         *
+         * @private
+         * @param {Object} options The input object to this function.
+         * @param {string} options.cacheName Name of the cache being updated.
+         * @param {Response} [options.oldResponse] The previous cached value, if any.
+         * @param {Response} options.newResponse The new value in the cache.
+         * @param {Request} options.request The request that triggered the udpate.
+         * @param {Request} [options.event] The event that triggered the update.
+         */
+        this.cacheDidUpdate = async ({
+          cacheName,
+          oldResponse,
+          newResponse,
+          request,
+          event
+        }) => {
+          {
+            assert_js.assert.isType(cacheName, 'string', {
+              moduleName: 'workbox-broadcast-update',
+              className: 'Plugin',
+              funcName: 'cacheDidUpdate',
+              paramName: 'cacheName'
+            });
+            assert_js.assert.isInstance(newResponse, Response, {
+              moduleName: 'workbox-broadcast-update',
+              className: 'Plugin',
+              funcName: 'cacheDidUpdate',
+              paramName: 'newResponse'
+            });
+            assert_js.assert.isInstance(request, Request, {
+              moduleName: 'workbox-broadcast-update',
+              className: 'Plugin',
+              funcName: 'cacheDidUpdate',
+              paramName: 'request'
+            });
+          } // Without a two responses there is nothing to compare.
 
-    cacheDidUpdate({
-      cacheName,
-      oldResponse,
-      newResponse,
-      request,
-      event
-    }) {
-      {
-        assert_mjs.assert.isType(cacheName, 'string', {
-          moduleName: 'workbox-broadcast-update',
-          className: 'Plugin',
-          funcName: 'cacheDidUpdate',
-          paramName: 'cacheName'
-        });
-        assert_mjs.assert.isInstance(newResponse, Response, {
-          moduleName: 'workbox-broadcast-update',
-          className: 'Plugin',
-          funcName: 'cacheDidUpdate',
-          paramName: 'newResponse'
-        });
-        assert_mjs.assert.isInstance(request, Request, {
-          moduleName: 'workbox-broadcast-update',
-          className: 'Plugin',
-          funcName: 'cacheDidUpdate',
-          paramName: 'request'
-        });
-      }
 
-      if (!oldResponse) {
-        // Without a two responses there is nothing to compare.
-        return;
+          if (oldResponse) {
+            this._broadcastUpdate.notifyIfUpdated({
+              cacheName,
+              oldResponse,
+              newResponse,
+              event,
+              url: request.url
+            });
+          }
+        };
+
+        this._broadcastUpdate = new BroadcastCacheUpdate(options);
       }
 
-      this._broadcastUpdate.notifyIfUpdated({
-        cacheName,
-        oldResponse,
-        newResponse,
-        event,
-        url: request.url
-      });
     }
 
-  }
+    /*
+      Copyright 2018 Google LLC
 
-  /*
-    Copyright 2018 Google LLC
+      Use of this source code is governed by an MIT-style
+      license that can be found in the LICENSE file or at
+      https://opensource.org/licenses/MIT.
+    */
 
-    Use of this source code is governed by an MIT-style
-    license that can be found in the LICENSE file or at
-    https://opensource.org/licenses/MIT.
-  */
+    exports.BroadcastCacheUpdate = BroadcastCacheUpdate;
+    exports.Plugin = Plugin;
+    exports.broadcastUpdate = broadcastUpdate;
+    exports.responsesAreSame = responsesAreSame;
 
-  exports.BroadcastCacheUpdate = BroadcastCacheUpdate;
-  exports.Plugin = Plugin;
-  exports.broadcastUpdate = broadcastUpdate;
-  exports.responsesAreSame = responsesAreSame;
+    return exports;
 
-  return exports;
-
 }({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
 //# sourceMappingURL=workbox-broadcast-update.dev.js.map

build/workbox-broadcast-update.prod.js

@@ -1,2 +0,2 @@
-this.workbox=this.workbox||{},this.workbox.broadcastUpdate=function(e,t){"use strict";try{self["workbox:broadcast-update:5.0.0-alpha.0"]&&_()}catch(e){}const s=(e,t,s)=>{return!s.some(s=>e.headers.has(s)&&t.headers.has(s))||s.every(s=>{const n=e.headers.has(s)===t.headers.has(s),a=e.headers.get(s)===t.headers.get(s);return n&&a})},n="workbox",a=1e4,i=["content-length","etag","last-modified"],o=async({channel:e,cacheName:t,url:s})=>{const n={type:"CACHE_UPDATED",meta:"workbox-broadcast-update",payload:{cacheName:t,updatedURL:s}};if(e)e.postMessage(n);else{const e=await clients.matchAll({type:"window"});for(const t of e)t.postMessage(n)}};class c{constructor({headersToCheck:e,channelName:t,deferNoticationTimeout:s}={}){this.t=e||i,this.s=t||n,this.i=s||a,this.o()}notifyIfUpdated({oldResponse:e,newResponse:t,url:n,cacheName:a,event:i}){if(!s(e,t,this.t)){const e=(async()=>{i&&i.request&&"navigate"===i.request.mode&&await this.h(i),await this.l({channel:this.u(),cacheName:a,url:n})})();if(i)try{i.waitUntil(e)}catch(e){}return e}}async l(e){await o(e)}u(){return"BroadcastChannel"in self&&!this.p&&(this.p=new BroadcastChannel(this.s)),this.p}h(e){if(!this.m.has(e)){const s=new t.Deferred;this.m.set(e,s);const n=setTimeout(()=>{s.resolve()},this.i);s.promise.then(()=>clearTimeout(n))}return this.m.get(e).promise}o(){this.m=new Map,self.addEventListener("message",e=>{if("WINDOW_READY"===e.data.type&&"workbox-window"===e.data.meta&&this.m.size>0){for(const e of this.m.values())e.resolve();this.m.clear()}})}}return e.BroadcastCacheUpdate=c,e.Plugin=class{constructor(e){this.l=new c(e)}cacheDidUpdate({cacheName:e,oldResponse:t,newResponse:s,request:n,event:a}){t&&this.l.notifyIfUpdated({cacheName:e,oldResponse:t,newResponse:s,event:a,url:n.url})}},e.broadcastUpdate=o,e.responsesAreSame=s,e}({},workbox.core._private);
+this.workbox=this.workbox||{},this.workbox.broadcastUpdate=function(e,t){"use strict";try{self["workbox:broadcast-update:5.0.0-alpha.1"]&&_()}catch(e){}const s=(e,t,s)=>{return!s.some(s=>e.headers.has(s)&&t.headers.has(s))||s.every(s=>{const n=e.headers.has(s)===t.headers.has(s),a=e.headers.get(s)===t.headers.get(s);return n&&a})},n="workbox",a=1e4,i=["content-length","etag","last-modified"],o=async({channel:e,cacheName:t,url:s})=>{const n={type:"CACHE_UPDATED",meta:"workbox-broadcast-update",payload:{cacheName:t,updatedURL:s}};if(e)e.postMessage(n);else{const e=await self.clients.matchAll({type:"window"});for(const t of e)t.postMessage(n)}};class c{constructor({headersToCheck:e,channelName:t,deferNoticationTimeout:s}={}){this.t=e||i,this.s=t||n,this.i=s||a,this.o()}notifyIfUpdated({oldResponse:e,newResponse:t,url:n,cacheName:a,event:i}){if(!s(e,t,this.t)){const e=(async()=>{i&&i.request&&"navigate"===i.request.mode&&await this.h(i),await this.l({channel:this.u(),cacheName:a,url:n})})();if(i)try{i.waitUntil(e)}catch(e){}return e}}async l(e){await o(e)}u(){return"BroadcastChannel"in self&&!this.m&&(this.m=new BroadcastChannel(this.s)),this.m}h(e){if(!this.p.has(e)){const s=new t.Deferred;this.p.set(e,s);const n=setTimeout(()=>{s.resolve()},this.i);s.promise.then(()=>clearTimeout(n))}return this.p.get(e).promise}o(){this.p=new Map,self.addEventListener("message",e=>{if("WINDOW_READY"===e.data.type&&"workbox-window"===e.data.meta&&this.p.size>0){for(const e of this.p.values())e.resolve();this.p.clear()}})}}return e.BroadcastCacheUpdate=c,e.Plugin=class{constructor(e){this.cacheDidUpdate=(async({cacheName:e,oldResponse:t,newResponse:s,request:n,event:a})=>{t&&this.l.notifyIfUpdated({cacheName:e,oldResponse:t,newResponse:s,event:a,url:n.url})}),this.l=new c(e)}},e.broadcastUpdate=o,e.responsesAreSame=s,e}({},workbox.core._private);
 //# sourceMappingURL=workbox-broadcast-update.prod.js.map

package.json

 {
   "name": "workbox-broadcast-update",
-  "version": "5.0.0-alpha.0",
+  "version": "5.0.0-alpha.1",
   "license": "MIT",
@@ -26,8 +26,9 @@ "author": "Google's Web DevRel Team",
   },
-  "main": "build/workbox-broadcast-update.prod.js",
+  "main": "index.js",
   "module": "index.mjs",
+  "types": "index.d.ts",
   "dependencies": {
-    "workbox-core": "^5.0.0-alpha.0"
+    "workbox-core": "^5.0.0-alpha.1"
   },
-  "gitHead": "7f231c04023669bc42d5a939d1359b0867e2efda"
+  "gitHead": "20d2110ddace710a46af06addd4977cae08f5942"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Unidentified License

License

(Experimental) Something that seems like a license was found, but its contents could not be matched with a known license.

Found 5 instances in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Unidentified License

License

(Experimental) Something that seems like a license was found, but its contents could not be matched with a known license.

Found 3 instances in 1 package

Improved metrics

Total package byte prevSize

146737

increased by71.97%

Number of package files

37

increased by164.29%

Lines of code

1641

increased by82.33%

Worsened metrics

Number of low license alerts

7

increased by40%

License quality

60

decreased by-25%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• Updatedworkbox-core@^5.0.0-alpha.1