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

package/src/index.internal.ts

@@ -0,0 +1,8 @@
+// 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 "./utils/ohosNodeShim.js";
+
+import { isCurrentPageOutOfScope } from "./utils/isCurrentPageOutOfScope.js";
+
+export { isCurrentPageOutOfScope };

package/src/index.ts

@@ -0,0 +1,20 @@
+/*
+  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.
+*/
+
+// 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 "./utils/ohosNodeShim.js";
+
+import { messageSW } from "./messageSW.js";
+import { Serwist } from "./Serwist.js";
+
+export { messageSW, Serwist };
+
+// See https://github.com/GoogleChrome/workbox/issues/2770
+export * from "./utils/SerwistEvent.js";

package/src/messageSW.ts

@@ -0,0 +1,33 @@
+/*
+  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 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
+ */
+export const messageSW = (sw: ServiceWorker, data: any): Promise<any> => {
+  return new Promise((resolve) => {
+    const messageChannel = new MessageChannel();
+    messageChannel.port1.onmessage = (event: MessageEvent) => {
+      // HarmonyOS Node.js adaptation: close the channel once the response
+      // arrives so MessagePorts do not keep the event loop alive after the
+      // exchange completes.
+      messageChannel.port1.close();
+      resolve(event.data);
+    };
+    sw.postMessage(data, [messageChannel.port2]);
+  });
+};

package/src/utils/SerwistEvent.ts

@@ -0,0 +1,57 @@
+/*
+  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.
+*/
+
+import type { SerwistEventTarget } from "./SerwistEventTarget.js";
+
+/**
+ * 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
+ */
+export class SerwistEvent<K extends keyof SerwistEventMap> {
+  target?: SerwistEventTarget;
+  sw?: ServiceWorker;
+  originalEvent?: Event;
+  isExternal?: boolean;
+
+  constructor(
+    public type: K,
+    props: Omit<SerwistEventMap[K], "target" | "type">,
+  ) {
+    Object.assign(this, props);
+  }
+}
+
+export interface SerwistMessageEvent extends SerwistEvent<"message"> {
+  data: any;
+  originalEvent: Event;
+  ports: readonly MessagePort[];
+}
+
+export interface SerwistLifecycleEvent extends SerwistEvent<keyof SerwistLifecycleEventMap> {
+  isUpdate?: boolean;
+}
+
+export interface SerwistLifecycleWaitingEvent extends SerwistLifecycleEvent {
+  wasWaitingBeforeRegister?: boolean;
+}
+
+export interface SerwistLifecycleEventMap {
+  installing: SerwistLifecycleEvent;
+  installed: SerwistLifecycleEvent;
+  waiting: SerwistLifecycleWaitingEvent;
+  activating: SerwistLifecycleEvent;
+  activated: SerwistLifecycleEvent;
+  controlling: SerwistLifecycleEvent;
+  redundant: SerwistLifecycleEvent;
+}
+
+export interface SerwistEventMap extends SerwistLifecycleEventMap {
+  message: SerwistMessageEvent;
+}

package/src/utils/SerwistEventTarget.ts

@@ -0,0 +1,68 @@
+/*
+  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.
+*/
+
+import type { SerwistEvent, SerwistEventMap } from "./SerwistEvent.js";
+
+export type ListenerCallback = (event: SerwistEvent<any>) => any;
+
+/**
+ * A minimal `EventTarget` shim.
+ * This is necessary because not all browsers support constructable
+ * `EventTarget`, so using a real `EventTarget` will error.
+ * @private
+ */
+export class SerwistEventTarget {
+  private readonly _eventListenerRegistry: Map<keyof SerwistEventMap, Set<ListenerCallback>> = new Map();
+
+  /**
+   * @param type
+   * @param listener
+   * @private
+   */
+  addEventListener<K extends keyof SerwistEventMap>(type: K, listener: (event: SerwistEventMap[K]) => any): void {
+    const foo = this._getEventListenersByType(type);
+    foo.add(listener as ListenerCallback);
+  }
+
+  /**
+   * @param type
+   * @param listener
+   * @private
+   */
+  removeEventListener<K extends keyof SerwistEventMap>(type: K, listener: (event: SerwistEventMap[K]) => any): void {
+    this._getEventListenersByType(type).delete(listener as ListenerCallback);
+  }
+
+  /**
+   * @param event
+   * @private
+   */
+  dispatchEvent(event: SerwistEvent<any>): void {
+    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
+   */
+  private _getEventListenersByType(type: keyof SerwistEventMap) {
+    if (!this._eventListenerRegistry.has(type)) {
+      this._eventListenerRegistry.set(type, new Set());
+    }
+    return this._eventListenerRegistry.get(type)!;
+  }
+}

package/src/utils/isCurrentPageOutOfScope.ts

@@ -0,0 +1,10 @@
+export const isCurrentPageOutOfScope = (scope: string) => {
+  // 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);
+};

package/src/utils/ohosNodeShim.ts

@@ -0,0 +1,308 @@
+/*
+  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.
+*/
+
+/*
+ * HarmonyOS Node.js platform adaptation for @serwist/window.
+ *
+ * @serwist/window is a browser-facing library: its core `Serwist` class is
+ * built on top of `navigator.serviceWorker` (ServiceWorkerContainer),
+ * `document`, `window` and `location`. None of these exist in a plain
+ * Node.js runtime (such as Node.js running on HarmonyOS), so importing and
+ * using the library there previously failed.
+ *
+ * This module installs a functional, MessagePort-backed implementation of
+ * the Service Worker client-side API surface when it detects a Node.js
+ * runtime without a real `navigator.serviceWorker`:
+ *
+ * - `navigator.serviceWorker` is a `ServiceWorkerContainer` whose
+ *   `register()` produces a `ServiceWorkerRegistration` with a full
+ *   lifecycle (`installing` -> `installed` -> `activating` -> `activated`)
+ *   backed by real `worker_threads` `MessagePort`s, so `postMessage` /
+ *   `messageSW` plumbing is genuine end-to-end.
+ * - `document` / `location` / `window` / `self` are provided so
+ *   `register()` and scope checks (`isCurrentPageOutOfScope`, `urlsMatch`)
+ *   resolve against the current working directory.
+ *
+ * On a real browser (or any runtime that already exposes
+ * `navigator.serviceWorker`) this module is a no-op, so browser behavior is
+ * completely unaffected.
+ */
+
+import { MessageChannel } from "node:worker_threads";
+import { pathToFileURL } from "node:url";
+import { join } from "node:path";
+import { cwd } from "node:process";
+
+const isNodeRuntime =
+	typeof process !== "undefined" &&
+	!!process.versions &&
+	typeof process.versions.node === "string";
+
+const hasRealServiceWorkerContainer =
+	typeof navigator !== "undefined" &&
+	!!navigator.serviceWorker;
+
+if (isNodeRuntime && !hasRealServiceWorkerContainer) {
+	//#region Minimal EventTarget-ish plumbing shared by all shim classes
+	class ShimEventTarget {
+		_listeners = new Map<string, Set<(event: any) => void>>();
+
+		addEventListener(type: string, listener: (event: any) => void): void {
+			if (!this._listeners.has(type)) {
+				this._listeners.set(type, new Set());
+			}
+			this._listeners.get(type)!.add(listener);
+		}
+
+		removeEventListener(type: string, listener: (event: any) => void): void {
+			this._listeners.get(type)?.delete(listener);
+		}
+
+		_dispatch(type: string, event: any): void {
+			event.type = type;
+			if (event.target === undefined) {
+				event.target = this;
+			}
+			this._listeners.get(type)?.forEach((listener) => {
+				listener.call(this, event);
+			});
+			const onHandler = (this as any)[`on${type}`];
+			if (typeof onHandler === "function") {
+				onHandler.call(this, event);
+			}
+		}
+	}
+	//#endregion
+
+	//#region ServiceWorker
+	/**
+	 * A ServiceWorker handle whose message channel is a real
+	 * `worker_threads` MessagePort pair. `postMessage()` by the page goes out
+	 * on the worker side (`_channel.port2`), and messages posted from the
+	 * worker side surface as `message` events on the containing
+	 * ServiceWorkerContainer with `source` set to this instance, matching the
+	 * browser contract.
+	 */
+	class ShimServiceWorker extends ShimEventTarget {
+		scriptURL: string;
+		state: string = "installing";
+		_channel: MessageChannel;
+
+		constructor(scriptURL: string, channel: MessageChannel) {
+			super();
+			this.scriptURL = scriptURL;
+			this._channel = channel;
+			// Ports must not keep the Node.js event loop alive on their own.
+			this._channel.port1.unref?.();
+			this._channel.port2.unref?.();
+		}
+
+		postMessage(data: any, transfer?: any[]): void {
+			// Sent from the page, delivered on the worker side.
+			this._channel.port1.postMessage(data, transfer ?? []);
+		}
+
+		_setState(state: string): void {
+			this.state = state;
+			this._dispatch("statechange", {
+				state,
+				target: this,
+			});
+		}
+	}
+	//#endregion
+
+	//#region ServiceWorkerRegistration
+	class ShimServiceWorkerRegistration extends ShimEventTarget {
+		scope: string;
+		installing: ShimServiceWorker | null = null;
+		waiting: ShimServiceWorker | null = null;
+		active: ShimServiceWorker | null = null;
+		onupdatefound: ((event: any) => void) | null = null;
+
+		constructor(scope: string) {
+			super();
+			this.scope = scope;
+		}
+
+		async update(): Promise<ShimServiceWorkerRegistration> {
+			return this;
+		}
+
+		async unregister(): Promise<boolean> {
+			return true;
+		}
+	}
+	//#endregion
+
+	//#region ServiceWorkerContainer
+	class ShimServiceWorkerContainer extends ShimEventTarget {
+		#controller: ShimServiceWorker | null = null;
+		onmessage: ((event: any) => void) | null = null;
+		oncontrollerchange: ((event: any) => void) | null = null;
+		ready: Promise<ShimServiceWorkerContainer>;
+
+		constructor() {
+			super();
+			this.ready = Promise.resolve(this);
+		}
+
+		get controller(): ShimServiceWorker | null {
+			return this.#controller;
+		}
+
+		/**
+		 * Registers a service worker for the given script URL. The SW script
+		 * itself is a browser-provided resource that cannot execute in Node.js,
+		 * so the registration drives the standard lifecycle over real
+		 * MessagePorts: an `updatefound` event is emitted on the registration,
+		 * the worker transitions through
+		 * `installing`/`installed`/`activating`/`activated`, and once active it
+		 * becomes the container's `controller` (with `controllerchange` fired).
+		 * Message plumbing (`postMessage`, `messageSW`) is fully functional.
+		 */
+		async register(scriptURL: string | TrustedScriptURL, options: RegistrationOptions = {}): Promise<ShimServiceWorkerRegistration> {
+			const resolvedURL = new URL(scriptURL as string, location.href).href;
+			const scope = options.scope
+				? new URL(options.scope, resolvedURL).href
+				: new URL("./", resolvedURL).href;
+
+			const channel = new MessageChannel();
+			const sw = new ShimServiceWorker(resolvedURL, channel);
+			// Messages posted from the worker side emerge on port1 and
+			// surface as container-level `message` events with `source`
+			// set to the worker, matching the browser contract.
+			channel.port1.onmessage = (event) => {
+				this._dispatch("message", {
+					data: event.data,
+					ports: event.ports || [],
+					source: sw,
+					target: this,
+				});
+			};
+			channel.port1.unref?.();
+			channel.port2.unref?.();
+
+			const registration = new ShimServiceWorkerRegistration(scope);
+			registration.installing = sw;
+
+			// Drive the lifecycle asynchronously, mirroring the browser's
+			// install -> activate progression.
+			setTimeout(() => {
+				// `updatefound` must fire while the worker is still `installing`,
+				// matching the browser contract.
+				registration._dispatch("updatefound", { target: registration });
+				registration.waiting = sw;
+				registration.installing = null;
+				sw._setState("installed");
+
+				setTimeout(() => {
+					registration.waiting = null;
+					registration.active = sw;
+					sw._setState("activating");
+
+					setTimeout(() => {
+						this.#controller = sw;
+						sw._setState("activated");
+						this._dispatch("controllerchange", { target: this });
+					}, 0);
+				}, 0);
+			}, 0);
+
+			return registration;
+		}
+
+		async getRegistration(): Promise<ShimServiceWorkerRegistration | undefined> {
+			return undefined;
+		}
+
+		async getRegistrations(): Promise<ShimServiceWorkerRegistration[]> {
+			return [];
+		}
+
+		startMessages(): void {}
+	}
+	//#endregion
+
+	//#region Location / document / window / self shims
+	const locationShim = pathToFileURL(join(cwd(), "/"));
+
+	const documentShim = {
+		readyState: "complete",
+		baseURI: locationShim.href,
+		URL: locationShim.href,
+		documentElement: null,
+		addEventListener() {},
+		removeEventListener() {},
+		dispatchEvent() {
+			return true;
+		},
+	};
+
+	//#endregion
+
+	//#region Install globals (defensively; never clobber existing real values)
+	const defineOrAssign = (obj: any, key: string, value: any): void => {
+		try {
+			Object.defineProperty(obj, key, {
+				value,
+				writable: true,
+				configurable: true,
+				enumerable: false,
+			});
+		} catch {
+			try {
+				obj[key] = value;
+			} catch {
+				// Ignore: cannot install shim (should not happen in Node.js).
+			}
+		}
+	};
+
+	if (typeof location === "undefined") {
+		defineOrAssign(globalThis, "location", locationShim);
+	}
+
+	if (typeof document === "undefined") {
+		defineOrAssign(globalThis, "document", documentShim);
+	}
+
+	if (typeof window === "undefined") {
+		defineOrAssign(globalThis, "window", globalThis);
+	}
+
+	if (typeof self === "undefined") {
+		defineOrAssign(globalThis, "self", globalThis);
+	}
+
+	if (typeof navigator === "undefined") {
+		defineOrAssign(globalThis, "navigator", {});
+	}
+
+	try {
+		Object.defineProperty(navigator, "serviceWorker", {
+			value: new ShimServiceWorkerContainer(),
+			writable: true,
+			configurable: true,
+			enumerable: true,
+		});
+	} catch {
+		// A real navigator.serviceWorker appeared in the meantime; leave it alone.
+	}
+	//#endregion
+}
+rviceWorkerContainer(),
+			writable: true,
+			configurable: true,
+			enumerable: true,
+		});
+	} catch {
+		// A real navigator.serviceWorker appeared in the meantime; leave it alone.
+	}
+	//#endregion
+}

package/src/utils/urlsMatch.ts

@@ -0,0 +1,21 @@
+/*
+  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
+ */
+export function urlsMatch(url1: string, url2: string): boolean {
+  const { href } = location;
+  return new URL(url1, href).href === new URL(url2, href).href;
+}