@serwist/broadcast-update 8.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Google LLC, 2019 ShadowWalker w@weiw.io https://weiw.io, 2023 Serwist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-broadcast-update

package/dist/BroadcastCacheUpdate.d.ts

@@ -0,0 +1,71 @@
+import type { CacheDidUpdateCallbackParam } from "@serwist/core";
+export interface BroadcastCacheUpdateOptions {
+    /**
+     * A list of headers that will be used to determine whether the responses
+     * differ.
+     *
+     * @default ['content-length', 'etag', 'last-modified']
+     */
+    headersToCheck?: string[];
+    /**
+     * A function whose return value
+     * will be used as the `payload` field in any cache update messages sent
+     * to the window clients.
+     * @param options
+     * @returns
+     */
+    generatePayload?: (options: CacheDidUpdateCallbackParam) => Record<string, any>;
+    /**
+     * If true (the default) then all open clients will receive a message. If false,
+     * then only the client that make the original request will be notified of the update.
+     *
+     * @default true
+     */
+    notifyAllClients?: boolean;
+}
+/**
+ * Uses the `postMessage()` API to inform any open windows/tabs when a cached
+ * response has been updated.
+ *
+ * For efficiency's sake, the underlying response bodies are not compared;
+ * only specific response headers are checked.
+ */
+declare class BroadcastCacheUpdate {
+    private readonly _headersToCheck;
+    private readonly _generatePayload;
+    private readonly _notifyAllClients;
+    /**
+     * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
+     * broadcast messages on
+     *
+     * @param options
+     */
+    constructor({ generatePayload, headersToCheck, notifyAllClients }?: BroadcastCacheUpdateOptions);
+    /**
+     * Compares two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+     * and sends a message (via `postMessage()`) to all window clients if the
+     * responses differ. Neither of the Responses can be
+     * [opaque](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
+     *
+     * The message that's posted has the following format (where `payload` can
+     * be customized via the `generatePayload` option the instance is created
+     * with):
+     *
+     * ```
+     * {
+     *   type: 'CACHE_UPDATED',
+     *   meta: 'workbox-broadcast-update',
+     *   payload: {
+     *     cacheName: 'the-cache-name',
+     *     updatedURL: 'https://example.com/'
+     *   }
+     * }
+     * ```
+     *
+     * @param options
+     * @returns Resolves once the update is sent.
+     */
+    notifyIfUpdated(options: CacheDidUpdateCallbackParam): Promise<void>;
+}
+export { BroadcastCacheUpdate };
+//# sourceMappingURL=BroadcastCacheUpdate.d.ts.map

package/dist/BroadcastCacheUpdate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BroadcastCacheUpdate.d.ts","sourceRoot":"","sources":["../src/BroadcastCacheUpdate.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAcjE,MAAM,WAAW,2BAA2B;IAC1C;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,2BAA2B,KAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAChF;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAgBD;;;;;;GAMG;AACH,cAAM,oBAAoB;IACxB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAW;IAC3C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAgE;IACjG,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAU;IAE5C;;;;;OAKG;gBACS,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,GAAE,2BAAgC;IAMnG;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,eAAe,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;CA4E3E;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/BroadcastUpdatePlugin.d.ts

@@ -0,0 +1,28 @@
+import type { SerwistPlugin } from "@serwist/core";
+import type { BroadcastCacheUpdateOptions } from "./BroadcastCacheUpdate.js";
+/**
+ * This plugin will automatically broadcast a message whenever a cached response
+ * is updated.
+ */
+declare class BroadcastUpdatePlugin implements SerwistPlugin {
+    private readonly _broadcastUpdate;
+    /**
+     * Construct a `@serwist/broadcast-update.BroadcastCacheUpdate` instance with
+     * the passed options and calls its `notifyIfUpdated` method whenever the
+     * plugin's `cacheDidUpdate` callback is invoked.
+     *
+     * @param options
+     */
+    constructor(options?: BroadcastCacheUpdateOptions);
+    /**
+     * A "lifecycle" callback that will be triggered automatically by
+     * `@serwist/build.RuntimeCaching` handlers when an entry is
+     * added to a cache.
+     *
+     * @private
+     * @param options The input object to this function.
+     */
+    cacheDidUpdate: SerwistPlugin["cacheDidUpdate"];
+}
+export { BroadcastUpdatePlugin };
+//# sourceMappingURL=BroadcastUpdatePlugin.d.ts.map

package/dist/BroadcastUpdatePlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BroadcastUpdatePlugin.d.ts","sourceRoot":"","sources":["../src/BroadcastUpdatePlugin.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAG7E;;;GAGG;AACH,cAAM,qBAAsB,YAAW,aAAa;IAClD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAuB;IAExD;;;;;;OAMG;gBACS,OAAO,CAAC,EAAE,2BAA2B;IAIjD;;;;;;;OAOG;IACH,cAAc,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAE7C;CACH;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { BroadcastCacheUpdateOptions } from "./BroadcastCacheUpdate.js";
+import { BroadcastCacheUpdate } from "./BroadcastCacheUpdate.js";
+import { BroadcastUpdatePlugin } from "./BroadcastUpdatePlugin.js";
+import { responsesAreSame } from "./responsesAreSame.js";
+/**
+ * @module workbox-broadcast-update
+ */
+export { BroadcastCacheUpdate, BroadcastUpdatePlugin, responsesAreSame };
+export type { BroadcastCacheUpdateOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;GAEG;AAEH,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,CAAC;AAEzE,YAAY,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,209 @@
+import { SerwistError, logger, assert, resultingClientExists, timeout, dontWaitFor } from '@serwist/core/internal';
+
+/**
+ * Given two `Response's`, compares several header values to see if they are
+ * the same or not.
+ *
+ * @param firstResponse
+ * @param secondResponse
+ * @param headersToCheck
+ * @returns
+ */ const responsesAreSame = (firstResponse, secondResponse, headersToCheck)=>{
+    if (process.env.NODE_ENV !== "production") {
+        if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
+            throw new SerwistError("invalid-responses-are-same-args");
+        }
+    }
+    const atLeastOneHeaderAvailable = headersToCheck.some((header)=>{
+        return firstResponse.headers.has(header) && secondResponse.headers.has(header);
+    });
+    if (!atLeastOneHeaderAvailable) {
+        if (process.env.NODE_ENV !== "production") {
+            logger.warn(`Unable to determine where the response has been updated ` + `because none of the headers that would be checked are present.`);
+            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 = "serwist-broadcast-update";
+const NOTIFY_ALL_CLIENTS = true;
+const DEFAULT_HEADERS_TO_CHECK = [
+    "content-length",
+    "etag",
+    "last-modified"
+];
+
+// UA-sniff Safari: https://stackoverflow.com/questions/7944460/detect-safari-browser
+// TODO(philipwalton): remove once this Safari bug fix has been released.
+// https://bugs.webkit.org/show_bug.cgi?id=201169
+const isSafari = typeof navigator !== "undefined" && /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+/**
+ * Generates the default payload used in update messages. By default the
+ * payload includes the `cacheName` and `updatedURL` fields.
+ *
+ * @returns
+ * @private
+ */ function defaultPayloadGenerator(data) {
+    return {
+        cacheName: data.cacheName,
+        updatedURL: data.request.url
+    };
+}
+/**
+ * Uses the `postMessage()` API to inform any open windows/tabs when a cached
+ * response has been updated.
+ *
+ * For efficiency's sake, the underlying response bodies are not compared;
+ * only specific response headers are checked.
+ */ class BroadcastCacheUpdate {
+    _headersToCheck;
+    _generatePayload;
+    _notifyAllClients;
+    /**
+   * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
+   * broadcast messages on
+   *
+   * @param options
+   */ constructor({ generatePayload, headersToCheck, notifyAllClients } = {}){
+        this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;
+        this._generatePayload = generatePayload || defaultPayloadGenerator;
+        this._notifyAllClients = notifyAllClients ?? NOTIFY_ALL_CLIENTS;
+    }
+    /**
+   * Compares two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+   * and sends a message (via `postMessage()`) to all window clients if the
+   * responses differ. Neither of the Responses can be
+   * [opaque](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
+   *
+   * The message that's posted has the following format (where `payload` can
+   * be customized via the `generatePayload` option the instance is created
+   * with):
+   *
+   * ```
+   * {
+   *   type: 'CACHE_UPDATED',
+   *   meta: 'workbox-broadcast-update',
+   *   payload: {
+   *     cacheName: 'the-cache-name',
+   *     updatedURL: 'https://example.com/'
+   *   }
+   * }
+   * ```
+   *
+   * @param options
+   * @returns Resolves once the update is sent.
+   */ async notifyIfUpdated(options) {
+        if (process.env.NODE_ENV !== "production") {
+            assert.isType(options.cacheName, "string", {
+                moduleName: "@serwist/broadcast-update",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "cacheName"
+            });
+            assert.isInstance(options.newResponse, Response, {
+                moduleName: "@serwist/broadcast-update",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "newResponse"
+            });
+            assert.isInstance(options.request, Request, {
+                moduleName: "@serwist/broadcast-update",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "request"
+            });
+        }
+        // Without two responses there is nothing to compare.
+        if (!options.oldResponse) {
+            return;
+        }
+        if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {
+            if (process.env.NODE_ENV !== "production") {
+                logger.log(`Newer response found (and cached) for:`, options.request.url);
+            }
+            const messageData = {
+                type: CACHE_UPDATED_MESSAGE_TYPE,
+                meta: CACHE_UPDATED_MESSAGE_META,
+                payload: this._generatePayload(options)
+            };
+            // For navigation requests, wait until the new window client exists
+            // before sending the message
+            if (options.request.mode === "navigate") {
+                let resultingClientId;
+                if (options.event instanceof FetchEvent) {
+                    resultingClientId = options.event.resultingClientId;
+                }
+                const resultingWin = await resultingClientExists(resultingClientId);
+                // Safari does not currently implement postMessage buffering and
+                // there's no good way to feature detect that, so to increase the
+                // chances of the message being delivered in Safari, we add a timeout.
+                // We also do this if `resultingClientExists()` didn't return a client,
+                // which means it timed out, so it's worth waiting a bit longer.
+                if (!resultingWin || isSafari) {
+                    // 3500 is chosen because (according to CrUX data) 80% of mobile
+                    // websites hit the DOMContentLoaded event in less than 3.5 seconds.
+                    // And presumably sites implementing service worker are on the
+                    // higher end of the performance spectrum.
+                    await timeout(3500);
+                }
+            }
+            if (this._notifyAllClients) {
+                const windows = await self.clients.matchAll({
+                    type: "window"
+                });
+                for (const win of windows){
+                    win.postMessage(messageData);
+                }
+            } else {
+                // See https://github.com/GoogleChrome/workbox/issues/2895
+                if (options.event instanceof FetchEvent) {
+                    const client = await self.clients.get(options.event.clientId);
+                    client?.postMessage(messageData);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * This plugin will automatically broadcast a message whenever a cached response
+ * is updated.
+ */ class BroadcastUpdatePlugin {
+    _broadcastUpdate;
+    /**
+   * Construct a `@serwist/broadcast-update.BroadcastCacheUpdate` instance with
+   * the passed options and calls its `notifyIfUpdated` method whenever the
+   * plugin's `cacheDidUpdate` callback is invoked.
+   *
+   * @param options
+   */ constructor(options){
+        this._broadcastUpdate = new BroadcastCacheUpdate(options);
+    }
+    /**
+   * A "lifecycle" callback that will be triggered automatically by
+   * `@serwist/build.RuntimeCaching` handlers when an entry is
+   * added to a cache.
+   *
+   * @private
+   * @param options The input object to this function.
+   */ cacheDidUpdate = async (options)=>{
+        dontWaitFor(this._broadcastUpdate.notifyIfUpdated(options));
+    };
+}
+
+export { BroadcastCacheUpdate, BroadcastUpdatePlugin, responsesAreSame };

package/dist/index.old.cjs

@@ -0,0 +1,213 @@
+'use strict';
+
+var internal = require('@serwist/core/internal');
+
+/**
+ * Given two `Response's`, compares several header values to see if they are
+ * the same or not.
+ *
+ * @param firstResponse
+ * @param secondResponse
+ * @param headersToCheck
+ * @returns
+ */ const responsesAreSame = (firstResponse, secondResponse, headersToCheck)=>{
+    if (process.env.NODE_ENV !== "production") {
+        if (!(firstResponse instanceof Response && secondResponse instanceof Response)) {
+            throw new internal.SerwistError("invalid-responses-are-same-args");
+        }
+    }
+    const atLeastOneHeaderAvailable = headersToCheck.some((header)=>{
+        return firstResponse.headers.has(header) && secondResponse.headers.has(header);
+    });
+    if (!atLeastOneHeaderAvailable) {
+        if (process.env.NODE_ENV !== "production") {
+            internal.logger.warn(`Unable to determine where the response has been updated ` + `because none of the headers that would be checked are present.`);
+            internal.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 = "serwist-broadcast-update";
+const NOTIFY_ALL_CLIENTS = true;
+const DEFAULT_HEADERS_TO_CHECK = [
+    "content-length",
+    "etag",
+    "last-modified"
+];
+
+// UA-sniff Safari: https://stackoverflow.com/questions/7944460/detect-safari-browser
+// TODO(philipwalton): remove once this Safari bug fix has been released.
+// https://bugs.webkit.org/show_bug.cgi?id=201169
+const isSafari = typeof navigator !== "undefined" && /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+/**
+ * Generates the default payload used in update messages. By default the
+ * payload includes the `cacheName` and `updatedURL` fields.
+ *
+ * @returns
+ * @private
+ */ function defaultPayloadGenerator(data) {
+    return {
+        cacheName: data.cacheName,
+        updatedURL: data.request.url
+    };
+}
+/**
+ * Uses the `postMessage()` API to inform any open windows/tabs when a cached
+ * response has been updated.
+ *
+ * For efficiency's sake, the underlying response bodies are not compared;
+ * only specific response headers are checked.
+ */ class BroadcastCacheUpdate {
+    _headersToCheck;
+    _generatePayload;
+    _notifyAllClients;
+    /**
+   * Construct a BroadcastCacheUpdate instance with a specific `channelName` to
+   * broadcast messages on
+   *
+   * @param options
+   */ constructor({ generatePayload, headersToCheck, notifyAllClients } = {}){
+        this._headersToCheck = headersToCheck || DEFAULT_HEADERS_TO_CHECK;
+        this._generatePayload = generatePayload || defaultPayloadGenerator;
+        this._notifyAllClients = notifyAllClients ?? NOTIFY_ALL_CLIENTS;
+    }
+    /**
+   * Compares two [Responses](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+   * and sends a message (via `postMessage()`) to all window clients if the
+   * responses differ. Neither of the Responses can be
+   * [opaque](https://developer.chrome.com/docs/workbox/caching-resources-during-runtime/#opaque-responses).
+   *
+   * The message that's posted has the following format (where `payload` can
+   * be customized via the `generatePayload` option the instance is created
+   * with):
+   *
+   * ```
+   * {
+   *   type: 'CACHE_UPDATED',
+   *   meta: 'workbox-broadcast-update',
+   *   payload: {
+   *     cacheName: 'the-cache-name',
+   *     updatedURL: 'https://example.com/'
+   *   }
+   * }
+   * ```
+   *
+   * @param options
+   * @returns Resolves once the update is sent.
+   */ async notifyIfUpdated(options) {
+        if (process.env.NODE_ENV !== "production") {
+            internal.assert.isType(options.cacheName, "string", {
+                moduleName: "@serwist/broadcast-update",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "cacheName"
+            });
+            internal.assert.isInstance(options.newResponse, Response, {
+                moduleName: "@serwist/broadcast-update",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "newResponse"
+            });
+            internal.assert.isInstance(options.request, Request, {
+                moduleName: "@serwist/broadcast-update",
+                className: "BroadcastCacheUpdate",
+                funcName: "notifyIfUpdated",
+                paramName: "request"
+            });
+        }
+        // Without two responses there is nothing to compare.
+        if (!options.oldResponse) {
+            return;
+        }
+        if (!responsesAreSame(options.oldResponse, options.newResponse, this._headersToCheck)) {
+            if (process.env.NODE_ENV !== "production") {
+                internal.logger.log(`Newer response found (and cached) for:`, options.request.url);
+            }
+            const messageData = {
+                type: CACHE_UPDATED_MESSAGE_TYPE,
+                meta: CACHE_UPDATED_MESSAGE_META,
+                payload: this._generatePayload(options)
+            };
+            // For navigation requests, wait until the new window client exists
+            // before sending the message
+            if (options.request.mode === "navigate") {
+                let resultingClientId;
+                if (options.event instanceof FetchEvent) {
+                    resultingClientId = options.event.resultingClientId;
+                }
+                const resultingWin = await internal.resultingClientExists(resultingClientId);
+                // Safari does not currently implement postMessage buffering and
+                // there's no good way to feature detect that, so to increase the
+                // chances of the message being delivered in Safari, we add a timeout.
+                // We also do this if `resultingClientExists()` didn't return a client,
+                // which means it timed out, so it's worth waiting a bit longer.
+                if (!resultingWin || isSafari) {
+                    // 3500 is chosen because (according to CrUX data) 80% of mobile
+                    // websites hit the DOMContentLoaded event in less than 3.5 seconds.
+                    // And presumably sites implementing service worker are on the
+                    // higher end of the performance spectrum.
+                    await internal.timeout(3500);
+                }
+            }
+            if (this._notifyAllClients) {
+                const windows = await self.clients.matchAll({
+                    type: "window"
+                });
+                for (const win of windows){
+                    win.postMessage(messageData);
+                }
+            } else {
+                // See https://github.com/GoogleChrome/workbox/issues/2895
+                if (options.event instanceof FetchEvent) {
+                    const client = await self.clients.get(options.event.clientId);
+                    client?.postMessage(messageData);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * This plugin will automatically broadcast a message whenever a cached response
+ * is updated.
+ */ class BroadcastUpdatePlugin {
+    _broadcastUpdate;
+    /**
+   * Construct a `@serwist/broadcast-update.BroadcastCacheUpdate` instance with
+   * the passed options and calls its `notifyIfUpdated` method whenever the
+   * plugin's `cacheDidUpdate` callback is invoked.
+   *
+   * @param options
+   */ constructor(options){
+        this._broadcastUpdate = new BroadcastCacheUpdate(options);
+    }
+    /**
+   * A "lifecycle" callback that will be triggered automatically by
+   * `@serwist/build.RuntimeCaching` handlers when an entry is
+   * added to a cache.
+   *
+   * @private
+   * @param options The input object to this function.
+   */ cacheDidUpdate = async (options)=>{
+        internal.dontWaitFor(this._broadcastUpdate.notifyIfUpdated(options));
+    };
+}
+
+exports.BroadcastCacheUpdate = BroadcastCacheUpdate;
+exports.BroadcastUpdatePlugin = BroadcastUpdatePlugin;
+exports.responsesAreSame = responsesAreSame;

package/dist/responsesAreSame.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Given two `Response's`, compares several header values to see if they are
+ * the same or not.
+ *
+ * @param firstResponse
+ * @param secondResponse
+ * @param headersToCheck
+ * @returns
+ */
+declare const responsesAreSame: (firstResponse: Response, secondResponse: Response, headersToCheck: string[]) => boolean;
+export { responsesAreSame };
+//# sourceMappingURL=responsesAreSame.d.ts.map

package/dist/responsesAreSame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responsesAreSame.d.ts","sourceRoot":"","sources":["../src/responsesAreSame.ts"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,QAAA,MAAM,gBAAgB,kBAAmB,QAAQ,kBAAkB,QAAQ,kBAAkB,MAAM,EAAE,KAAG,OA4BvG,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/utils/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const CACHE_UPDATED_MESSAGE_TYPE = "CACHE_UPDATED";
+export declare const CACHE_UPDATED_MESSAGE_META = "serwist-broadcast-update";
+export declare const NOTIFY_ALL_CLIENTS = true;
+export declare const DEFAULT_HEADERS_TO_CHECK: string[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,0BAA0B,kBAAkB,CAAC;AAC1D,eAAO,MAAM,0BAA0B,6BAA6B,CAAC;AACrE,eAAO,MAAM,kBAAkB,OAAO,CAAC;AACvC,eAAO,MAAM,wBAAwB,EAAE,MAAM,EAAgD,CAAC"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@serwist/broadcast-update",
+  "version": "8.0.0",
+  "type": "module",
+  "description": "A service worker helper library that uses the Broadcast Channel API to announce when a cached response has updated",
+  "files": [
+    "dist",
+    "!dist/**/dts"
+  ],
+  "keywords": [
+    "serwist",
+    "serwistjs",
+    "service worker",
+    "sw",
+    "serwist-plugin"
+  ],
+  "author": "Google's Web DevRel Team, Serwist's Team",
+  "license": "MIT",
+  "repository": "serwist/serwist",
+  "bugs": "https://github.com/serwist/serwist/issues",
+  "homepage": "https://ducanh-next-pwa.vercel.app",
+  "module": "./dist/index.js",
+  "main": "./dist/index.old.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.old.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@serwist/core": "8.0.0"
+  },
+  "devDependencies": {
+    "rollup": "3.28.1",
+    "@serwist/constants": "8.0.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",
+    "lint": "eslint src --ext ts,tsx,js,jsx,cjs,mjs",
+    "typecheck": "tsc"
+  }
+}