| this.workbox = this.workbox || {}; |
| this.workbox.broadcastUpdate = (function (exports, assert_mjs, getFriendlyURL_mjs, logger_mjs, Deferred_mjs, WorkboxError_mjs) { |
| 'use strict'; |
| |
| try { |
| self['workbox:broadcast-update:4.3.1'] && _(); |
| } catch (e) {} // eslint-disable-line |
| |
| /* |
| 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 |
| */ |
| |
| const responsesAreSame = (firstResponse, secondResponse, headersToCheck) => { |
| { |
| if (!(firstResponse instanceof Response && secondResponse instanceof Response)) { |
| throw new WorkboxError_mjs.WorkboxError('invalid-responses-are-same-args'); |
| } |
| } |
| |
| 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. |
| |
| |
| 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' |
| }); |
| 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' |
| }); |
| |
| 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. |
| */ |
| /** |
| * 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 { |
| /** |
| * 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; |
| |
| { |
| assert_mjs.assert.isType(this._channelName, 'string', { |
| moduleName: 'workbox-broadcast-update', |
| className: 'BroadcastCacheUpdate', |
| funcName: 'constructor', |
| paramName: 'channelName' |
| }); |
| assert_mjs.assert.isArray(this._headersToCheck, { |
| moduleName: 'workbox-broadcast-update', |
| className: 'BroadcastCacheUpdate', |
| funcName: 'constructor', |
| paramName: 'headersToCheck' |
| }); |
| } |
| |
| 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. |
| */ |
| |
| |
| notifyIfUpdated({ |
| oldResponse, |
| newResponse, |
| url, |
| cacheName, |
| event |
| }) { |
| if (!responsesAreSame(oldResponse, newResponse, this._headersToCheck)) { |
| { |
| logger_mjs.logger.log(`Newer response found (and cached) for:`, url); |
| } |
| |
| 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); |
| } |
| |
| await this._windowReadyOrTimeout(event); |
| } |
| |
| await this._broadcastUpdate({ |
| channel: this._getChannel(), |
| cacheName, |
| url |
| }); |
| }; // Send the update and ensure the SW stays alive until it's sent. |
| |
| |
| const done = sendUpdate(); |
| |
| 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)}'.`); |
| } |
| } |
| } |
| |
| return done; |
| } |
| } |
| /** |
| * NOTE: this is exposed on the instance primarily so it can be spied on |
| * in tests. |
| * |
| * @param {Object} opts |
| * @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); |
| } |
| |
| 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_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. |
| |
| |
| 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.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 |
| */ |
| |
| |
| _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_mjs.logger.debug(`Received WINDOW_READY event: `, event); |
| } // Resolve any pending deferreds. |
| |
| |
| for (const deferred of this._navigationEventsDeferreds.values()) { |
| deferred.resolve(); |
| } |
| |
| this._navigationEventsDeferreds.clear(); |
| } |
| }); |
| } |
| |
| } |
| |
| /* |
| 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 { |
| /** |
| * 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) { |
| 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. |
| */ |
| |
| |
| 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; |
| } |
| |
| this._broadcastUpdate.notifyIfUpdated({ |
| cacheName, |
| oldResponse, |
| newResponse, |
| event, |
| url: request.url |
| }); |
| } |
| |
| } |
| |
| /* |
| 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. |
| */ |
| |
| exports.BroadcastCacheUpdate = BroadcastCacheUpdate; |
| exports.Plugin = Plugin; |
| exports.broadcastUpdate = broadcastUpdate; |
| exports.responsesAreSame = responsesAreSame; |
| |
| return exports; |
| |
| }({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private)); |
| //# sourceMappingURL=workbox-broadcast-update.dev.js.map |