@ohos-ports/serwist-window 9.5.12-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-2023 Google LLC, 2019-2023 ShadowWalker w@weiw.io https://weiw.io, 2020-2023 Anthony Fu <https://github.com/antfu>, 2023-PRESENT 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://serwist.pages.dev/docs/window.

package/dist/chunks/isCurrentPageOutOfScope-BF6DLxHk.js

@@ -0,0 +1,15 @@
+//#region src/utils/isCurrentPageOutOfScope.ts
+const isCurrentPageOutOfScope = (scope) => {
+	// Guard: scope checks are non-blocking and only meaningful in a browser
+	// document context; treat the page as in-scope when DOM globals are absent.
+	if (typeof document === "undefined" || typeof location === "undefined") {
+		return false;
+	}
+	const scopeURL = new URL(scope, document.baseURI);
+	const scopeURLBasePath = new URL("./", scopeURL.href).pathname;
+	return !location.pathname.startsWith(scopeURLBasePath);
+};
+//#endregion
+export { isCurrentPageOutOfScope as t };
+
+//# sourceMappingURL=isCurrentPageOutOfScope-BF6DLxHk.js.map

package/dist/chunks/isCurrentPageOutOfScope-BF6DLxHk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCurrentPageOutOfScope-BF6DLxHk.js","names":[],"sources":["../../src/utils/isCurrentPageOutOfScope.ts"],"sourcesContent":["export const isCurrentPageOutOfScope = (scope: string) => {\n  const scopeURL = new URL(scope, document.baseURI);\n  const scopeURLBasePath = new URL(\"./\", scopeURL.href).pathname;\n  return !location.pathname.startsWith(scopeURLBasePath);\n};\n"],"mappings":";AAAA,MAAa,2BAA2B,UAAkB;CACxD,MAAM,WAAW,IAAI,IAAI,OAAO,SAAS,OAAO;CAChD,MAAM,mBAAmB,IAAI,IAAI,MAAM,SAAS,IAAI,CAAC,CAAC;CACtD,OAAO,CAAC,SAAS,SAAS,WAAW,gBAAgB;AACvD"}

package/dist/index.d.mts

@@ -0,0 +1,374 @@
+//#region src/messageSW.d.ts
+/**
+ * Sends a data object to a service worker via `postMessage` and resolves with
+ * a response (if any).
+ *
+ * A response can be sent by calling `event.ports[0].postMessage(...)`, which will
+ * resolve the promise returned by `messageSW()`. If no response is sent, the promise
+ * will never resolve.
+ *
+ * @param sw The service worker to send the message to.
+ * @param data An object to send to the service worker.
+ * @returns
+ */
+declare const messageSW: (sw: ServiceWorker, data: any) => Promise<any>;
+//#endregion
+//#region src/utils/SerwistEvent.d.ts
+/**
+ * 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
+ */
+declare class SerwistEvent<K extends keyof SerwistEventMap> {
+  type: K;
+  target?: SerwistEventTarget;
+  sw?: ServiceWorker;
+  originalEvent?: Event;
+  isExternal?: boolean;
+  constructor(type: K, props: Omit<SerwistEventMap[K], "target" | "type">);
+}
+interface SerwistMessageEvent extends SerwistEvent<"message"> {
+  data: any;
+  originalEvent: Event;
+  ports: readonly MessagePort[];
+}
+interface SerwistLifecycleEvent extends SerwistEvent<keyof SerwistLifecycleEventMap> {
+  isUpdate?: boolean;
+}
+interface SerwistLifecycleWaitingEvent extends SerwistLifecycleEvent {
+  wasWaitingBeforeRegister?: boolean;
+}
+interface SerwistLifecycleEventMap {
+  installing: SerwistLifecycleEvent;
+  installed: SerwistLifecycleEvent;
+  waiting: SerwistLifecycleWaitingEvent;
+  activating: SerwistLifecycleEvent;
+  activated: SerwistLifecycleEvent;
+  controlling: SerwistLifecycleEvent;
+  redundant: SerwistLifecycleEvent;
+}
+interface SerwistEventMap extends SerwistLifecycleEventMap {
+  message: SerwistMessageEvent;
+}
+//#endregion
+//#region src/utils/SerwistEventTarget.d.ts
+/**
+ * A minimal `EventTarget` shim.
+ * This is necessary because not all browsers support constructable
+ * `EventTarget`, so using a real `EventTarget` will error.
+ * @private
+ */
+declare class SerwistEventTarget {
+  private readonly _eventListenerRegistry;
+  /**
+   * @param type
+   * @param listener
+   * @private
+   */
+  addEventListener<K extends keyof SerwistEventMap>(type: K, listener: (event: SerwistEventMap[K]) => any): void;
+  /**
+   * @param type
+   * @param listener
+   * @private
+   */
+  removeEventListener<K extends keyof SerwistEventMap>(type: K, listener: (event: SerwistEventMap[K]) => any): void;
+  /**
+   * @param event
+   * @private
+   */
+  dispatchEvent(event: SerwistEvent<any>): void;
+  /**
+   * 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
+   */
+  private _getEventListenersByType;
+}
+//#endregion
+//#region src/Serwist.d.ts
+/**
+ * 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`
+ */
+declare class Serwist extends SerwistEventTarget {
+  private readonly _scriptURL;
+  private readonly _registerOptions;
+  private _updateFoundCount;
+  private readonly _swDeferred;
+  private readonly _activeDeferred;
+  private readonly _controllingDeferred;
+  private _registrationTime;
+  private _isUpdate?;
+  private _compatibleControllingSW?;
+  private _registration?;
+  private _sw?;
+  private readonly _ownSWs;
+  private _externalSW?;
+  private _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://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?: RegistrationOptions);
+  /**
+   * 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
+   */
+  register({ immediate }?: {
+    /**
+     * Setting this to true will register the service worker immediately,
+     * even if the window has not loaded (not recommended).
+     */
+    immediate?: boolean;
+  }): Promise<ServiceWorkerRegistration | undefined>;
+  /**
+   * Checks for updates of the registered service worker.
+   */
+  update(): Promise<void>;
+  /**
+   * 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(): Promise<ServiceWorker>;
+  /**
+   * 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(): Promise<ServiceWorker>;
+  /**
+   * 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(): Promise<ServiceWorker>;
+  /**
+   * Sends the passed data object to the service worker registered by this
+   * instance (via `getSW`) and resolves with a response (if any).
+   *
+   * A response can be sent by calling `event.ports[0].postMessage(...)`, which will
+   * resolve the promise returned by `messageSW()`. If no response is sent, the promise
+   * will never resolve.
+   *
+   * @param data An object to send to the service worker
+   * @returns
+   */
+  messageSW(data: any): Promise<any>;
+  /**
+   * Sends a `{ type: "SKIP_WAITING" }` message to the service worker that is
+   * currently waiting and associated with the current registration.
+   *
+   * If there is no current registration, or no service worker is waiting,
+   * calling this will have no effect.
+   */
+  messageSkipWaiting(): void;
+  /**
+   * Checks for a service worker already controlling the page and returns
+   * it if its script URL matches.
+   *
+   * @private
+   * @returns
+   */
+  private _getControllingSWIfCompatible;
+  /**
+   * Registers a service worker for this instances script URL and register
+   * options and tracks the time registration was complete.
+   *
+   * @private
+   */
+  private _registerScript;
+  /**
+   * @private
+   * @param originalEvent
+   */
+  private readonly _onUpdateFound;
+  /**
+   * @private
+   * @param originalEvent
+   */
+  private readonly _onStateChange;
+  /**
+   * @private
+   * @param originalEvent
+   */
+  private readonly _onControllerChange;
+  /**
+   * @private
+   * @param originalEvent
+   */
+  private readonly _onMessage;
+}
+/**
+ * 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.
+ */
+//#endregion
+export { Serwist, SerwistEvent, SerwistEventMap, SerwistLifecycleEvent, SerwistLifecycleEventMap, SerwistLifecycleWaitingEvent, SerwistMessageEvent, messageSW };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/messageSW.ts","../src/utils/SerwistEvent.ts","../src/utils/SerwistEventTarget.ts","../src/Serwist.ts"],"mappings":";;;;;;;;;;;;;cAoBa,YAAS,IAAQ,eAAa,cAAc;;;;;;;;;cCJ5C,aAAa,gBAAgB;EAO/B,MAAM;EANf,SAAS;EACT,KAAK;EACL,gBAAgB;EAChB;EAEA,YACS,MAAM,GACb,OAAO,KAAK,gBAAgB;;UAMf,4BAA4B;EAC3C;EACA,eAAe;EACf,gBAAgB;;UAGD,8BAA8B,mBAAmB;EAChE;;UAGe,qCAAqC;EACpD;;UAGe;EACf,YAAY;EACZ,WAAW;EACX,SAAS;EACT,YAAY;EACZ,WAAW;EACX,aAAa;EACb,WAAW;;UAGI,wBAAwB;EACvC,SAAS;;;;;;;;;;cCrCE;mBACM;;;;;;EAOjB,iBAAiB,gBAAgB,iBAAiB,MAAM,GAAG,WAAW,OAAO,gBAAgB;;;;;;EAU7F,oBAAoB,gBAAgB,iBAAiB,MAAM,GAAG,WAAW,OAAO,gBAAgB;;;;;EAQhG,cAAc,OAAO;;;;;;;;;UAiBb;;;;;;;;;;;;;;;cCpBG,gBAAgB;mBACV;mBACA;UACT;mBAGS;mBACA;mBACA;UAET;UACA;UACA;UACA;UACA;mBACS;UACT;UACA;;;;;;;;;;EAWR,YAAY,oBAAoB,kBAAkB,kBAAiB;;;;;;;;EAmB7D,WACJ;;;;;IAMA;MACO,QAAQ;;;;EA4FX,UAAU;;;;;;;;;;MAqBZ,UAAU,QAAQ;;;;;;;;;;;;;MAgBlB,eAAe,QAAQ;;;;;;;;;;;;;;;;EAmB3B,SAAS,QAAQ;;;;;;;;;;;;EAkBX,UAAU,YAAY;;;;;;;;EAY5B;;;;;;;;UAaQ;;;;;;;UAcM;;;;;mBA0BG;;;;;mBA4EA;;;;;mBA2FA;;;;;mBA6BA"}

package/dist/index.internal.d.mts

@@ -0,0 +1,5 @@
+//#region src/utils/isCurrentPageOutOfScope.d.ts
+declare const isCurrentPageOutOfScope: (scope: string) => boolean;
+//#endregion
+export { isCurrentPageOutOfScope };
+//# sourceMappingURL=index.internal.d.mts.map

package/dist/index.internal.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.internal.d.mts","names":[],"sources":["../src/utils/isCurrentPageOutOfScope.ts"],"mappings":";cAAa,0BAAuB"}

package/dist/index.internal.mjs

@@ -0,0 +1,6 @@
+// HarmonyOS Node.js platform adaptation: install browser API shims
+// (navigator.serviceWorker, document, window, location) before the library
+// body evaluates. No-op in real browsers.
+import "./ohos-node-shim.mjs";
+import { t as isCurrentPageOutOfScope } from "./chunks/isCurrentPageOutOfScope-BF6DLxHk.js";
+export { isCurrentPageOutOfScope };