@serwist/window 9.0.0-preview.0 → 9.0.0-preview.10

package/dist/Serwist.d.ts

@@ -31,13 +31,11 @@ export declare class Serwist extends SerwistEventTarget {
      * options. The script URL and options are the same as those used when
      * calling [navigator.serviceWorker.register(scriptURL, options)](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register).
      *
-     * @param scriptURL The service worker script
-     *     associated with this instance. Using a
-     *     [`TrustedScriptURL`](https://web.dev/trusted-types/) is supported.
-     * @param registerOptions The service worker options associated
-     *     with this instance.
+     * @param scriptURL The service worker script associated with this instance. Using a
+     * [`TrustedScriptURL`](https://developer.mozilla.org/en-US/docs/Web/API/TrustedScriptURL) is supported.
+     * @param registerOptions The service worker options associated with this instance.
      */
-    constructor(scriptURL: string | TrustedScriptURL, registerOptions?: {});
+    constructor(scriptURL: string | TrustedScriptURL, registerOptions?: RegistrationOptions);
     /**
      * Registers a service worker for this instances script URL and service
      * worker options. By default this method delays registration until after
@@ -108,7 +106,7 @@ export declare class Serwist extends SerwistEventTarget {
      * @param data An object to send to the service worker
      * @returns
      */
-    messageSW(data: object): Promise<any>;
+    messageSW(data: any): Promise<any>;
     /**
      * Sends a `{type: 'SKIP_WAITING'}` message to the service worker that's
      * currently in the `waiting` state associated with the current registration.

package/dist/Serwist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Serwist.d.ts","sourceRoot":"","sources":["../src/Serwist.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAK1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAgBnE;;;;;;;;;;GAUG;AACH,qBAAa,OAAQ,SAAQ,kBAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4B;IACvD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA2B;IAC5D,OAAO,CAAC,iBAAiB,CAAK;IAG9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2C;IACvE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA2C;IAC3E,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA2C;IAEhF,OAAO,CAAC,iBAAiB,CAA0B;IACnD,OAAO,CAAC,SAAS,CAAC,CAAU;IAC5B,OAAO,CAAC,wBAAwB,CAAC,CAAgB;IACjD,OAAO,CAAC,aAAa,CAAC,CAA4B;IAClD,OAAO,CAAC,GAAG,CAAC,CAAgB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,OAAO,CAAC,WAAW,CAAC,CAAgB;IACpC,OAAO,CAAC,eAAe,CAAC,CAAS;IAEjC;;;;;;;;;;OAUG;gBAES,SAAS,EAAE,MAAM,GAAG,gBAAgB,EAAE,eAAe,GAAE,EAAO;IAY1E;;;;;;OAMG;IACG,QAAQ,CAAC,EACb,SAAiB,GAClB,GAAE;QACD;;;WAGG;QACH,SAAS,CAAC,EAAE,OAAO,CAAC;KAChB,GAAG,OAAO,CAAC,yBAAyB,GAAG,SAAS,CAAC;IAkGvD;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAY7B;;;;;;;;OAQG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,aAAa,CAAC,CAEnC;IAED;;;;;;;;;;;OAWG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,aAAa,CAAC,CAExC;IAED;;;;;;;;;;;;;;OAcG;IACH,KAAK,IAAI,OAAO,CAAC,aAAa,CAAC;IAM/B;;;;;;;;;;;;OAYG;IAGG,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAK3C;;;;;;OAMG;IACH,kBAAkB,IAAI,IAAI;IAM1B;;;;;;OAMG;IACH,OAAO,CAAC,6BAA6B;IAQrC;;;;;OAKG;YACW,eAAe;IAsB7B;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAwE7B;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAqF7B;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAuBlC;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CA2BzB;CACH;AAKD;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;GAaG"}
+{"version":3,"file":"Serwist.d.ts","sourceRoot":"","sources":["../src/Serwist.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAK1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAgBnE;;;;;;;;;;GAUG;AACH,qBAAa,OAAQ,SAAQ,kBAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4B;IACvD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA2B;IAC5D,OAAO,CAAC,iBAAiB,CAAK;IAG9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2C;IACvE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA2C;IAC3E,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA2C;IAEhF,OAAO,CAAC,iBAAiB,CAA0B;IACnD,OAAO,CAAC,SAAS,CAAC,CAAU;IAC5B,OAAO,CAAC,wBAAwB,CAAC,CAAgB;IACjD,OAAO,CAAC,aAAa,CAAC,CAA4B;IAClD,OAAO,CAAC,GAAG,CAAC,CAAgB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,OAAO,CAAC,WAAW,CAAC,CAAgB;IACpC,OAAO,CAAC,eAAe,CAAC,CAAS;IAEjC;;;;;;;;OAQG;gBACS,SAAS,EAAE,MAAM,GAAG,gBAAgB,EAAE,eAAe,GAAE,mBAAwB;IAY3F;;;;;;OAMG;IACG,QAAQ,CAAC,EACb,SAAiB,GAClB,GAAE;QACD;;;WAGG;QACH,SAAS,CAAC,EAAE,OAAO,CAAC;KAChB,GAAG,OAAO,CAAC,yBAAyB,GAAG,SAAS,CAAC;IA8FvD;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAY7B;;;;;;;;OAQG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,aAAa,CAAC,CAEnC;IAED;;;;;;;;;;;OAWG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,aAAa,CAAC,CAExC;IAED;;;;;;;;;;;;;;OAcG;IACH,KAAK,IAAI,OAAO,CAAC,aAAa,CAAC;IAM/B;;;;;;;;;;;;OAYG;IAEG,SAAS,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAKxC;;;;;;OAMG;IACH,kBAAkB,IAAI,IAAI;IAM1B;;;;;;OAMG;IACH,OAAO,CAAC,6BAA6B;IAQrC;;;;;OAKG;YACW,eAAe;IAsB7B;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAsE7B;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAqF7B;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAuBlC;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAuBzB;CACH;AAKD;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;GAaG"}

package/dist/index.js

@@ -1,25 +1,6 @@
-import { Deferred, logger, dontWaitFor } from '@serwist/core/internal';
+import { Deferred, logger } from '@serwist/core/internal';
 
-/*
-  Copyright 2019 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.
-*/ /**
- * Sends a data object to a service worker via `postMessage` and resolves with
- * a response (if any).
- *
- * A response can be set in a message handler in the service worker by
- * calling `event.ports[0].postMessage(...)`, which will resolve the promise
- * returned by `messageSW()`. If no response is set, the promise will not
- * resolve.
- *
- * @param sw The service worker to send the message to.
- * @param data An object to send to the service worker.
- * @returns
- */ // biome-ignore lint/complexity/noBannedTypes: Better not change type of data.
-function messageSW(sw, data) {
+const messageSW = (sw, data)=>{
     return new Promise((resolve)=>{
         const messageChannel = new MessageChannel();
         messageChannel.port1.onmessage = (event)=>{
@@ -29,20 +10,9 @@ function messageSW(sw, data) {
             messageChannel.port2
         ]);
     });
-}
-
-/*
-  Copyright 2019 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.
-*/ /**
- * A minimal `Event` subclass shim.
- * This doesn't *actually* subclass `Event` because not all browsers support
- * constructable `EventTarget`, and using a real `Event` will error.
- * @private
- */ class SerwistEvent {
+class SerwistEvent {
     type;
     target;
     sw;
@@ -54,52 +24,23 @@ function messageSW(sw, data) {
     }
 }
 
-/*
-  Copyright 2019 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.
-*/ /**
- * A minimal `EventTarget` shim.
- * This is necessary because not all browsers support constructable
- * `EventTarget`, so using a real `EventTarget` will error.
- * @private
- */ class SerwistEventTarget {
+class SerwistEventTarget {
     _eventListenerRegistry = new Map();
-    /**
-   * @param type
-   * @param listener
-   * @private
-   */ addEventListener(type, listener) {
+    addEventListener(type, listener) {
         const foo = this._getEventListenersByType(type);
         foo.add(listener);
     }
-    /**
-   * @param type
-   * @param listener
-   * @private
-   */ removeEventListener(type, listener) {
+    removeEventListener(type, listener) {
         this._getEventListenersByType(type).delete(listener);
     }
-    /**
-   * @param event
-   * @private
-   */ dispatchEvent(event) {
+    dispatchEvent(event) {
         event.target = this;
         const listeners = this._getEventListenersByType(event.type);
         for (const listener of listeners){
             listener(event);
         }
     }
-    /**
-   * Returns a Set of listeners associated with the passed event type.
-   * If no handlers have been registered, an empty Set is returned.
-   *
-   * @param type The event type.
-   * @returns An array of handler functions.
-   * @private
-   */ _getEventListenersByType(type) {
+    _getEventListenersByType(type) {
         if (!this._eventListenerRegistry.has(type)) {
             this._eventListenerRegistry.set(type, new Set());
         }
@@ -107,52 +48,20 @@ function messageSW(sw, data) {
     }
 }
 
-/*
-  Copyright 2019 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.
-*/ /**
- * Returns true if two URLs have the same `.href` property. The URLS can be
- * relative, and if they are the current location href is used to resolve URLs.
- *
- * @private
- * @param url1
- * @param url2
- * @returns
- */ function urlsMatch(url1, url2) {
+function urlsMatch(url1, url2) {
     const { href } = location;
     return new URL(url1, href).href === new URL(url2, href).href;
 }
 
-// The time a SW must be in the waiting phase before we can conclude
-// `skipWaiting()` wasn't called. This 200 amount wasn't scientifically
-// chosen, but it seems to avoid false positives in my testing.
 const WAITING_TIMEOUT_DURATION = 200;
-// The amount of time after a registration that we can reasonably conclude
-// that the registration didn't trigger an update.
 const REGISTRATION_TIMEOUT_DURATION = 60000;
-// The de facto standard message that a service worker should be listening for
-// to trigger a call to skipWaiting().
 const SKIP_WAITING_MESSAGE = {
     type: "SKIP_WAITING"
 };
-/**
- * A class to aid in handling service worker registration, updates, and
- * reacting to service worker lifecycle events.
- *
- * @fires `@serwist/window.Serwist.message`
- * @fires `@serwist/window.Serwist.installed`
- * @fires `@serwist/window.Serwist.waiting`
- * @fires `@serwist/window.Serwist.controlling`
- * @fires `@serwist/window.Serwist.activated`
- * @fires `@serwist/window.Serwist.redundant`
- */ class Serwist extends SerwistEventTarget {
+class Serwist extends SerwistEventTarget {
     _scriptURL;
     _registerOptions = {};
     _updateFoundCount = 0;
-    // Deferreds we can resolve later.
     _swDeferred = new Deferred();
     _activeDeferred = new Deferred();
     _controllingDeferred = new Deferred();
@@ -164,52 +73,25 @@ const SKIP_WAITING_MESSAGE = {
     _ownSWs = new Set();
     _externalSW;
     _waitingTimeout;
-    /**
-   * Creates a new Serwist instance with a script URL and service worker
-   * options. The script URL and options are the same as those used when
-   * calling [navigator.serviceWorker.register(scriptURL, options)](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register).
-   *
-   * @param scriptURL The service worker script
-   *     associated with this instance. Using a
-   *     [`TrustedScriptURL`](https://web.dev/trusted-types/) is supported.
-   * @param registerOptions The service worker options associated
-   *     with this instance.
-   */ // biome-ignore lint/complexity/noBannedTypes: Unknown reason
     constructor(scriptURL, registerOptions = {}){
         super();
         this._scriptURL = scriptURL;
         this._registerOptions = registerOptions;
-        // Add a message listener immediately since messages received during
-        // page load are buffered only until the DOMContentLoaded event:
-        // https://github.com/GoogleChrome/workbox/issues/2202
         navigator.serviceWorker.addEventListener("message", this._onMessage);
     }
-    /**
-   * Registers a service worker for this instances script URL and service
-   * worker options. By default this method delays registration until after
-   * the window has loaded.
-   *
-   * @param options
-   */ async register({ immediate = false } = {}) {
+    async register({ immediate = false } = {}) {
         if (process.env.NODE_ENV !== "production") {
             if (this._registrationTime) {
-                logger.error("Cannot re-register a Serwist instance after it has " + "been registered. Create a new instance instead.");
+                logger.error("Cannot re-register a Serwist instance after it has been registered. Create a new instance instead.");
                 return;
             }
         }
         if (!immediate && document.readyState !== "complete") {
             await new Promise((res)=>window.addEventListener("load", res));
         }
-        // Set this flag to true if any service worker was controlling the page
-        // at registration time.
         this._isUpdate = Boolean(navigator.serviceWorker.controller);
-        // Before registering, attempt to determine if a SW is already controlling
-        // the page, and if that SW script (and version, if specified) matches this
-        // instance's script.
         this._compatibleControllingSW = this._getControllingSWIfCompatible();
         this._registration = await this._registerScript();
-        // If we have a compatible controller, store the controller as the "own"
-        // SW, resolve active/controlling deferreds and add necessary listeners.
         if (this._compatibleControllingSW) {
             this._sw = this._compatibleControllingSW;
             this._activeDeferred.resolve(this._compatibleControllingSW);
@@ -218,29 +100,19 @@ const SKIP_WAITING_MESSAGE = {
                 once: true
             });
         }
-        // If there's a waiting service worker with a matching URL before the
-        // `updatefound` event fires, it likely means that this site is open
-        // in another tab, or the user refreshed the page (and thus the previous
-        // page wasn't fully unloaded before this page started loading).
-        // https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting
         const waitingSW = this._registration.waiting;
         if (waitingSW && urlsMatch(waitingSW.scriptURL, this._scriptURL.toString())) {
-            // Store the waiting SW as the "own" Sw, even if it means overwriting
-            // a compatible controller.
             this._sw = waitingSW;
-            // Run this in the next microtask, so any code that adds an event
-            // listener after awaiting `register()` will get this event.
-            dontWaitFor(Promise.resolve().then(()=>{
+            void Promise.resolve().then(()=>{
                 this.dispatchEvent(new SerwistEvent("waiting", {
                     sw: waitingSW,
                     wasWaitingBeforeRegister: true
                 }));
                 if (process.env.NODE_ENV !== "production") {
-                    logger.warn("A service worker was already waiting to activate " + "before this script was registered...");
+                    logger.warn("A service worker was already waiting to activate before this script was registered...");
                 }
-            }));
+            });
         }
-        // If an "own" SW is already set, resolve the deferred.
         if (this._sw) {
             this._swDeferred.resolve(this._sw);
             this._ownSWs.add(this._sw);
@@ -249,9 +121,9 @@ const SKIP_WAITING_MESSAGE = {
             logger.log("Successfully registered service worker.", this._scriptURL.toString());
             if (navigator.serviceWorker.controller) {
                 if (this._compatibleControllingSW) {
-                    logger.debug("A service worker with the same script URL " + "is already controlling this page.");
+                    logger.debug("A service worker with the same script URL is already controlling this page.");
                 } else {
-                    logger.debug("A service worker with a different script URL is " + "currently controlling the page. The browser is now fetching " + "the new script now...");
+                    logger.debug("A service worker with a different script URL is currently controlling the page. The browser is now fetching the new script now...");
                 }
             }
             const currentPageIsOutOfScope = ()=>{
@@ -260,172 +132,67 @@ const SKIP_WAITING_MESSAGE = {
                 return !location.pathname.startsWith(scopeURLBasePath);
             };
             if (currentPageIsOutOfScope()) {
-                logger.warn("The current page is not in scope for the registered " + "service worker. Was this a mistake?");
+                logger.warn("The current page is not in scope for the registered service worker. Was this a mistake?");
             }
         }
         this._registration.addEventListener("updatefound", this._onUpdateFound);
         navigator.serviceWorker.addEventListener("controllerchange", this._onControllerChange);
         return this._registration;
     }
-    /**
-   * Checks for updates of the registered service worker.
-   */ async update() {
+    async update() {
         if (!this._registration) {
             if (process.env.NODE_ENV !== "production") {
-                logger.error("Cannot update a Serwist instance without " + "being registered. Register the Serwist instance first.");
+                logger.error("Cannot update a Serwist instance without being registered. Register the Serwist instance first.");
             }
             return;
         }
-        // Try to update registration
         await this._registration.update();
     }
-    /**
-   * Resolves to the service worker registered by this instance as soon as it
-   * is active. If a service worker was already controlling at registration
-   * time then it will resolve to that if the script URLs (and optionally
-   * script versions) match, otherwise it will wait until an update is found
-   * and activates.
-   *
-   * @returns
-   */ get active() {
+    get active() {
         return this._activeDeferred.promise;
     }
-    /**
-   * Resolves to the service worker registered by this instance as soon as it
-   * is controlling the page. If a service worker was already controlling at
-   * registration time then it will resolve to that if the script URLs (and
-   * optionally script versions) match, otherwise it will wait until an update
-   * is found and starts controlling the page.
-   * Note: the first time a service worker is installed it will active but
-   * not start controlling the page unless `clients.claim()` is called in the
-   * service worker.
-   *
-   * @returns
-   */ get controlling() {
+    get controlling() {
         return this._controllingDeferred.promise;
     }
-    /**
-   * Resolves with a reference to a service worker that matches the script URL
-   * of this instance, as soon as it's available.
-   *
-   * If, at registration time, there's already an active or waiting service
-   * worker with a matching script URL, it will be used (with the waiting
-   * service worker taking precedence over the active service worker if both
-   * match, since the waiting service worker would have been registered more
-   * recently).
-   * If there's no matching active or waiting service worker at registration
-   * time then the promise will not resolve until an update is found and starts
-   * installing, at which point the installing service worker is used.
-   *
-   * @returns
-   */ getSW() {
-        // If `this._sw` is set, resolve with that as we want `getSW()` to
-        // return the correct (new) service worker if an update is found.
+    getSW() {
         return this._sw !== undefined ? Promise.resolve(this._sw) : this._swDeferred.promise;
     }
-    /**
-   * Sends the passed data object to the service worker registered by this
-   * instance (via `@serwist/window.Serwist.getSW`) and resolves
-   * with a response (if any).
-   *
-   * A response can be set in a message handler in the service worker by
-   * calling `event.ports[0].postMessage(...)`, which will resolve the promise
-   * returned by `messageSW()`. If no response is set, the promise will never
-   * resolve.
-   *
-   * @param data An object to send to the service worker
-   * @returns
-   */ // We might be able to change the 'data' type to Record<string, unknown> in the future.
-    // eslint-disable-next-line @typescript-eslint/ban-types
     async messageSW(data) {
         const sw = await this.getSW();
         return messageSW(sw, data);
     }
-    /**
-   * Sends a `{type: 'SKIP_WAITING'}` message to the service worker that's
-   * currently in the `waiting` state associated with the current registration.
-   *
-   * If there is no current registration or no service worker is `waiting`,
-   * calling this will have no effect.
-   */ messageSkipWaiting() {
+    messageSkipWaiting() {
         if (this._registration?.waiting) {
             void messageSW(this._registration.waiting, SKIP_WAITING_MESSAGE);
         }
     }
-    /**
-   * Checks for a service worker already controlling the page and returns
-   * it if its script URL matches.
-   *
-   * @private
-   * @returns
-   */ _getControllingSWIfCompatible() {
+    _getControllingSWIfCompatible() {
         const controller = navigator.serviceWorker.controller;
         if (controller && urlsMatch(controller.scriptURL, this._scriptURL.toString())) {
             return controller;
         }
         return undefined;
     }
-    /**
-   * Registers a service worker for this instances script URL and register
-   * options and tracks the time registration was complete.
-   *
-   * @private
-   */ async _registerScript() {
+    async _registerScript() {
         try {
-            // this._scriptURL may be a TrustedScriptURL, but there's no support for
-            // passing that to register() in lib.dom right now.
-            // https://github.com/GoogleChrome/workbox/issues/2855
             const reg = await navigator.serviceWorker.register(this._scriptURL, this._registerOptions);
-            // Keep track of when registration happened, so it can be used in the
-            // `this._onUpdateFound` heuristic. Also use the presence of this
-            // property as a way to see if `.register()` has been called.
             this._registrationTime = performance.now();
             return reg;
         } catch (error) {
             if (process.env.NODE_ENV !== "production") {
                 logger.error(error);
             }
-            // Re-throw the error.
             throw error;
         }
     }
-    /**
-   * @private
-   * @param originalEvent
-   */ _onUpdateFound = (originalEvent)=>{
-        // `this._registration` will never be `undefined` after an update is found.
+    _onUpdateFound = (originalEvent)=>{
         const registration = this._registration;
         const installingSW = registration.installing;
-        // If the script URL passed to `navigator.serviceWorker.register()` is
-        // different from the current controlling SW's script URL, we know any
-        // successful registration calls will trigger an `updatefound` event.
-        // But if the registered script URL is the same as the current controlling
-        // SW's script URL, we'll only get an `updatefound` event if the file
-        // changed since it was last registered. This can be a problem if the user
-        // opens up the same page in a different tab, and that page registers
-        // a SW that triggers an update. It's a problem because this page has no
-        // good way of knowing whether the `updatefound` event came from the SW
-        // script it registered or from a registration attempt made by a newer
-        // version of the page running in another tab.
-        // To minimize the possibility of a false positive, we use the logic here:
-        const updateLikelyTriggeredExternally = // Since we enforce only calling `register()` once, and since we don't
-        // add the `updatefound` event listener until the `register()` call, if
-        // `_updateFoundCount` is > 0 then it means this method has already
-        // been called, thus this SW must be external
-        this._updateFoundCount > 0 || // If the script URL of the installing SW is different from this
-        // instance's script URL, we know it's definitely not from our
-        // registration.
-        !urlsMatch(installingSW.scriptURL, this._scriptURL.toString()) || // If all of the above are false, then we use a time-based heuristic:
-        // Any `updatefound` event that occurs long after our registration is
-        // assumed to be external.
-        performance.now() > this._registrationTime + REGISTRATION_TIMEOUT_DURATION ? // triggered by this instance.
-        true : false;
+        const updateLikelyTriggeredExternally = this._updateFoundCount > 0 || !urlsMatch(installingSW.scriptURL, this._scriptURL.toString()) || performance.now() > this._registrationTime + REGISTRATION_TIMEOUT_DURATION;
         if (updateLikelyTriggeredExternally) {
             this._externalSW = installingSW;
             registration.removeEventListener("updatefound", this._onUpdateFound);
         } else {
-            // If the update was not triggered externally we know the installing
-            // SW is the one we registered, so we set it.
             this._sw = installingSW;
             this._ownSWs.add(installingSW);
             this._swDeferred.resolve(installingSW);
@@ -437,25 +204,16 @@ const SKIP_WAITING_MESSAGE = {
                 }
             }
         }
-        // Dispatch the `installing` event when the SW is installing.
         this.dispatchEvent(new SerwistEvent("installing", {
             sw: installingSW,
             originalEvent,
             isExternal: updateLikelyTriggeredExternally,
             isUpdate: this._isUpdate
         }));
-        // Increment the `updatefound` count, so future invocations of this
-        // method can be sure they were triggered externally.
         ++this._updateFoundCount;
-        // Add a `statechange` listener regardless of whether this update was
-        // triggered externally, since we have callbacks for both.
         installingSW.addEventListener("statechange", this._onStateChange);
     };
-    /**
-   * @private
-   * @param originalEvent
-   */ _onStateChange = (originalEvent)=>{
-        // `this._registration` will never be `undefined` after an update is found.
+    _onStateChange = (originalEvent)=>{
         const registration = this._registration;
         const sw = originalEvent.target;
         const { state } = sw;
@@ -470,16 +228,7 @@ const SKIP_WAITING_MESSAGE = {
         }
         this.dispatchEvent(new SerwistEvent(state, eventProps));
         if (state === "installed") {
-            // This timeout is used to ignore cases where the service worker calls
-            // `skipWaiting()` in the install event, thus moving it directly in the
-            // activating state. (Since all service workers *must* go through the
-            // waiting phase, the only way to detect `skipWaiting()` called in the
-            // install event is to observe that the time spent in the waiting phase
-            // is very short.)
-            // NOTE: we don't need separate timeouts for the own and external SWs
-            // since they can't go through these phases at the same time.
             this._waitingTimeout = self.setTimeout(()=>{
-                // Ensure the SW is still waiting (it may now be redundant).
                 if (state === "installed" && registration.waiting === sw) {
                     this.dispatchEvent(new SerwistEvent("waiting", eventProps));
                     if (process.env.NODE_ENV !== "production") {
@@ -526,16 +275,9 @@ const SKIP_WAITING_MESSAGE = {
             }
         }
     };
-    /**
-   * @private
-   * @param originalEvent
-   */ _onControllerChange = (originalEvent)=>{
+    _onControllerChange = (originalEvent)=>{
         const sw = this._sw;
         const isExternal = sw !== navigator.serviceWorker.controller;
-        // Unconditionally dispatch the controlling event, with isExternal set
-        // to distinguish between controller changes due to the initial registration
-        // vs. an update-check or other tab's registration.
-        // See https://github.com/GoogleChrome/workbox/issues/2786
         this.dispatchEvent(new SerwistEvent("controlling", {
             isExternal,
             originalEvent,
@@ -549,26 +291,11 @@ const SKIP_WAITING_MESSAGE = {
             this._controllingDeferred.resolve(sw);
         }
     };
-    /**
-   * @private
-   * @param originalEvent
-   */ _onMessage = async (originalEvent)=>{
-        // Can't change type 'any' of data.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    _onMessage = async (originalEvent)=>{
         const { data, ports, source } = originalEvent;
-        // Wait until there's an "own" service worker. This is used to buffer
-        // `message` events that may be received prior to calling `register()`.
         await this.getSW();
-        // If the service worker that sent the message is in the list of own
-        // service workers for this instance, dispatch a `message` event.
-        // NOTE: we check for all previously owned service workers rather than
-        // just the current one because some messages (e.g. cache updates) use
-        // a timeout when sent and may be delayed long enough for a service worker
-        // update to be found.
         if (this._ownSWs.has(source)) {
             this.dispatchEvent(new SerwistEvent("message", {
-                // Can't change type 'any' of data.
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 data,
                 originalEvent,
                 ports,
@@ -576,131 +303,6 @@ const SKIP_WAITING_MESSAGE = {
             }));
         }
     };
-} // The jsdoc comments below outline the events this instance may dispatch:
- // -----------------------------------------------------------------------
- /**
- * The `message` event is dispatched any time a `postMessage` is received.
- *
- * @event workbox-window.Workbox#message
- * @type {SerwistEvent}
- * @property {*} data The `data` property from the original `message` event.
- * @property {Event} originalEvent The original [`message`]{@link https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent}
- *     event.
- * @property {string} type `message`.
- * @property {MessagePort[]} ports The `ports` value from `originalEvent`.
- * @property {Workbox} target The `Workbox` instance.
- */  /**
- * The `installed` event is dispatched if the state of a
- * {@link workbox-window.Workbox} instance's
- * {@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw|registered service worker}
- * changes to `installed`.
- *
- * Then can happen either the very first time a service worker is installed,
- * or after an update to the current service worker is found. In the case
- * of an update being found, the event's `isUpdate` property will be `true`.
- *
- * @event workbox-window.Workbox#installed
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The service worker instance.
- * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
- *     event.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this `Workbox` instance called `register()`.
- * @property {boolean|undefined} isExternal True if this event is associated
- *     with an [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}.
- * @property {string} type `installed`.
- * @property {Workbox} target The `Workbox` instance.
- */  /**
- * The `waiting` event is dispatched if the state of a
- * {@link workbox-window.Workbox} instance's
- * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
- * changes to `installed` and then doesn't immediately change to `activating`.
- * It may also be dispatched if a service worker with the same
- * [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}
- * was already waiting when the {@link workbox-window.Workbox#register}
- * method was called.
- *
- * @event workbox-window.Workbox#waiting
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The service worker instance.
- * @property {Event|undefined} originalEvent The original
- *    [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
- *     event, or `undefined` in the case where the service worker was waiting
- *     to before `.register()` was called.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this `Workbox` instance called `register()`.
- * @property {boolean|undefined} isExternal True if this event is associated
- *     with an [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}.
- * @property {boolean|undefined} wasWaitingBeforeRegister True if a service worker with
- *     a matching `scriptURL` was already waiting when this `Workbox`
- *     instance called `register()`.
- * @property {string} type `waiting`.
- * @property {Workbox} target The `Workbox` instance.
- */  /**
- * The `controlling` event is dispatched if a
- * [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}
- * fires on the service worker [container]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer}
- * and the [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}
- * of the new [controller]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/controller}
- * matches the `scriptURL` of the `Workbox` instance's
- * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}.
- *
- * @event workbox-window.Workbox#controlling
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The service worker instance.
- * @property {Event} originalEvent The original [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}
- *     event.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this service worker was registered.
- * @property {boolean|undefined} isExternal True if this event is associated
- *     with an [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}.
- * @property {string} type `controlling`.
- * @property {Workbox} target The `Workbox` instance.
- */  /**
- * The `activated` event is dispatched if the state of a
- * {@link workbox-window.Workbox} instance's
- * {@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw|registered service worker}
- * changes to `activated`.
- *
- * @event workbox-window.Workbox#activated
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The service worker instance.
- * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
- *     event.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this `Workbox` instance called `register()`.
- * @property {boolean|undefined} isExternal True if this event is associated
- *     with an [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}.
- * @property {string} type `activated`.
- * @property {Workbox} target The `Workbox` instance.
- */  /**
- * The `redundant` event is dispatched if the state of a
- * {@link workbox-window.Workbox} instance's
- * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
- * changes to `redundant`.
- *
- * @event workbox-window.Workbox#redundant
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The service worker instance.
- * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
- *     event.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this `Workbox` instance called `register()`.
- * @property {string} type `redundant`.
- * @property {Workbox} target The `Workbox` instance.
- */  /**
- * The `installing` event is dispatched if the service worker
- * finds the new version and starts installing.
- *
- * @event workbox-window.Workbox#installing
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The installing service worker instance.
- * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
- *     event.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this `Workbox` instance called `register()`.
- * @property {string} type `installing`.
- * @property {Workbox} target The `Workbox` instance.
- */
+}
 
 export { Serwist, SerwistEvent, messageSW };

package/dist/messageSW.d.ts

@@ -11,6 +11,5 @@
  * @param data An object to send to the service worker.
  * @returns
  */
-declare function messageSW(sw: ServiceWorker, data: {}): Promise<any>;
-export { messageSW };
+export declare const messageSW: (sw: ServiceWorker, data: any) => Promise<any>;
 //# sourceMappingURL=messageSW.d.ts.map

package/dist/messageSW.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messageSW.d.ts","sourceRoot":"","sources":["../src/messageSW.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AAEH,iBAAS,SAAS,CAAC,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAQ5D;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"messageSW.d.ts","sourceRoot":"","sources":["../src/messageSW.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,OAAQ,aAAa,QAAQ,GAAG,KAAG,QAAQ,GAAG,CAQnE,CAAC"}

package/dist/utils/urlsMatch.d.ts

@@ -1,5 +1,5 @@
 /**
- * Returns true if two URLs have the same `.href` property. The URLS can be
+ * Returns true if two URLs have the same `.href` property. The URLs can be
  * relative, and if they are the current location href is used to resolve URLs.
  *
  * @private

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serwist/window",
-  "version": "9.0.0-preview.0",
+  "version": "9.0.0-preview.10",
   "type": "module",
   "description": "Simplifies communications with Serwist packages running in the service worker",
   "files": [
@@ -32,12 +32,12 @@
   },
   "dependencies": {
     "@types/trusted-types": "2.0.7",
-    "@serwist/core": "9.0.0-preview.0"
+    "@serwist/core": "9.0.0-preview.10"
   },
   "devDependencies": {
     "rollup": "4.9.6",
-    "typescript": "5.4.0-dev.20240203",
-    "@serwist/constants": "9.0.0-preview.0"
+    "typescript": "5.4.0-dev.20240206",
+    "@serwist/constants": "9.0.0-preview.10"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"

package/src/Serwist.ts

@@ -6,7 +6,7 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { Deferred, dontWaitFor, logger } from "@serwist/core/internal";
+import { Deferred, logger } from "@serwist/core/internal";
 import type { TrustedScriptURL } from "trusted-types/lib";
 
 import { messageSW } from "./messageSW.js";
@@ -26,7 +26,7 @@ const REGISTRATION_TIMEOUT_DURATION = 60000;
 
 // The de facto standard message that a service worker should be listening for
 // to trigger a call to skipWaiting().
-const SKIP_WAITING_MESSAGE = { type: "SKIP_WAITING" };
+const SKIP_WAITING_MESSAGE = { type: "SKIP_WAITING" } as const;
 
 /**
  * A class to aid in handling service worker registration, updates, and
@@ -63,14 +63,11 @@ export class Serwist extends SerwistEventTarget {
    * options. The script URL and options are the same as those used when
    * calling [navigator.serviceWorker.register(scriptURL, options)](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register).
    *
-   * @param scriptURL The service worker script
-   *     associated with this instance. Using a
-   *     [`TrustedScriptURL`](https://web.dev/trusted-types/) is supported.
-   * @param registerOptions The service worker options associated
-   *     with this instance.
+   * @param scriptURL The service worker script associated with this instance. Using a
+   * [`TrustedScriptURL`](https://developer.mozilla.org/en-US/docs/Web/API/TrustedScriptURL) is supported.
+   * @param registerOptions The service worker options associated with this instance.
    */
-  // biome-ignore lint/complexity/noBannedTypes: Unknown reason
-  constructor(scriptURL: string | TrustedScriptURL, registerOptions: {} = {}) {
+  constructor(scriptURL: string | TrustedScriptURL, registerOptions: RegistrationOptions = {}) {
     super();
 
     this._scriptURL = scriptURL;
@@ -100,7 +97,7 @@ export class Serwist extends SerwistEventTarget {
   } = {}): Promise<ServiceWorkerRegistration | undefined> {
     if (process.env.NODE_ENV !== "production") {
       if (this._registrationTime) {
-        logger.error("Cannot re-register a Serwist instance after it has " + "been registered. Create a new instance instead.");
+        logger.error("Cannot re-register a Serwist instance after it has been registered. Create a new instance instead.");
         return;
       }
     }
@@ -114,7 +111,7 @@ export class Serwist extends SerwistEventTarget {
     this._isUpdate = Boolean(navigator.serviceWorker.controller);
 
     // Before registering, attempt to determine if a SW is already controlling
-    // the page, and if that SW script (and version, if specified) matches this
+    // the page and if that SW script (and version, if specified) matches this
     // instance's script.
     this._compatibleControllingSW = this._getControllingSWIfCompatible();
 
@@ -137,25 +134,23 @@ export class Serwist extends SerwistEventTarget {
     // https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting
     const waitingSW = this._registration.waiting;
     if (waitingSW && urlsMatch(waitingSW.scriptURL, this._scriptURL.toString())) {
-      // Store the waiting SW as the "own" Sw, even if it means overwriting
+      // Store the waiting SW as the "own" SW, even if it means overwriting
       // a compatible controller.
       this._sw = waitingSW;
 
       // Run this in the next microtask, so any code that adds an event
       // listener after awaiting `register()` will get this event.
-      dontWaitFor(
-        Promise.resolve().then(() => {
-          this.dispatchEvent(
-            new SerwistEvent("waiting", {
-              sw: waitingSW,
-              wasWaitingBeforeRegister: true,
-            }),
-          );
-          if (process.env.NODE_ENV !== "production") {
-            logger.warn("A service worker was already waiting to activate " + "before this script was registered...");
-          }
-        }),
-      );
+      void Promise.resolve().then(() => {
+        this.dispatchEvent(
+          new SerwistEvent("waiting", {
+            sw: waitingSW,
+            wasWaitingBeforeRegister: true,
+          }),
+        );
+        if (process.env.NODE_ENV !== "production") {
+          logger.warn("A service worker was already waiting to activate before this script was registered...");
+        }
+      });
     }
 
     // If an "own" SW is already set, resolve the deferred.
@@ -169,12 +164,10 @@ export class Serwist extends SerwistEventTarget {
 
       if (navigator.serviceWorker.controller) {
         if (this._compatibleControllingSW) {
-          logger.debug("A service worker with the same script URL " + "is already controlling this page.");
+          logger.debug("A service worker with the same script URL is already controlling this page.");
         } else {
           logger.debug(
-            "A service worker with a different script URL is " +
-              "currently controlling the page. The browser is now fetching " +
-              "the new script now...",
+            "A service worker with a different script URL is currently controlling the page. The browser is now fetching the new script now...",
           );
         }
       }
@@ -185,7 +178,7 @@ export class Serwist extends SerwistEventTarget {
         return !location.pathname.startsWith(scopeURLBasePath);
       };
       if (currentPageIsOutOfScope()) {
-        logger.warn("The current page is not in scope for the registered " + "service worker. Was this a mistake?");
+        logger.warn("The current page is not in scope for the registered service worker. Was this a mistake?");
       }
     }
 
@@ -201,7 +194,7 @@ export class Serwist extends SerwistEventTarget {
   async update(): Promise<void> {
     if (!this._registration) {
       if (process.env.NODE_ENV !== "production") {
-        logger.error("Cannot update a Serwist instance without " + "being registered. Register the Serwist instance first.");
+        logger.error("Cannot update a Serwist instance without being registered. Register the Serwist instance first.");
       }
       return;
     }
@@ -274,8 +267,7 @@ export class Serwist extends SerwistEventTarget {
    * @returns
    */
   // We might be able to change the 'data' type to Record<string, unknown> in the future.
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  async messageSW(data: object): Promise<any> {
+  async messageSW(data: any): Promise<any> {
     const sw = await this.getSW();
     return messageSW(sw, data);
   }
@@ -370,11 +362,9 @@ export class Serwist extends SerwistEventTarget {
       // If all of the above are false, then we use a time-based heuristic:
       // Any `updatefound` event that occurs long after our registration is
       // assumed to be external.
-      performance.now() > this._registrationTime + REGISTRATION_TIMEOUT_DURATION
-        ? // If any of the above are not true, we assume the update was
-          // triggered by this instance.
-          true
-        : false;
+      performance.now() > this._registrationTime + REGISTRATION_TIMEOUT_DURATION;
+    // If any of the above are not true, we assume the update was
+    // triggered by this instance.
 
     if (updateLikelyTriggeredExternally) {
       this._externalSW = installingSW;
@@ -539,8 +529,6 @@ export class Serwist extends SerwistEventTarget {
    * @param originalEvent
    */
   private readonly _onMessage = async (originalEvent: MessageEvent) => {
-    // Can't change type 'any' of data.
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const { data, ports, source } = originalEvent;
 
     // Wait until there's an "own" service worker. This is used to buffer
@@ -556,8 +544,6 @@ export class Serwist extends SerwistEventTarget {
     if (this._ownSWs.has(source as ServiceWorker)) {
       this.dispatchEvent(
         new SerwistEvent("message", {
-          // Can't change type 'any' of data.
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           data,
           originalEvent,
           ports,

package/src/messageSW.ts

@@ -19,8 +19,7 @@
  * @param data An object to send to the service worker.
  * @returns
  */
-// biome-ignore lint/complexity/noBannedTypes: Better not change type of data.
-function messageSW(sw: ServiceWorker, data: {}): Promise<any> {
+export const messageSW = (sw: ServiceWorker, data: any): Promise<any> => {
   return new Promise((resolve) => {
     const messageChannel = new MessageChannel();
     messageChannel.port1.onmessage = (event: MessageEvent) => {
@@ -28,6 +27,4 @@ function messageSW(sw: ServiceWorker, data: {}): Promise<any> {
     };
     sw.postMessage(data, [messageChannel.port2]);
   });
-}
-
-export { messageSW };
+};

package/src/utils/urlsMatch.ts

@@ -7,7 +7,7 @@
 */
 
 /**
- * Returns true if two URLs have the same `.href` property. The URLS can be
+ * Returns true if two URLs have the same `.href` property. The URLs can be
  * relative, and if they are the current location href is used to resolve URLs.
  *
  * @private