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

package/dist/ohos-node-shim.mjs

@@ -0,0 +1,297 @@
+/*
+  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 {
+		constructor() {
+			this._listeners = new Map();
+		}
+
+		addEventListener(type, listener) {
+			if (!this._listeners.has(type)) {
+				this._listeners.set(type, new Set());
+			}
+			this._listeners.get(type).add(listener);
+		}
+
+		removeEventListener(type, listener) {
+			this._listeners.get(type)?.delete(listener);
+		}
+
+		_dispatch(type, event) {
+			event.type = type;
+			if (event.target === undefined) {
+				event.target = this;
+			}
+			this._listeners.get(type)?.forEach((listener) => {
+				listener.call(this, event);
+			});
+			const onHandler = this[`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 {
+		_channel;
+
+		constructor(scriptURL, channel) {
+			super();
+			this.scriptURL = scriptURL;
+			this.state = "installing";
+			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, transfer) {
+			// Sent from the page, delivered on the worker side.
+			this._channel.port1.postMessage(data, transfer ?? []);
+		}
+
+		_setState(state) {
+			this.state = state;
+			this._dispatch("statechange", {
+				state,
+				target: this,
+			});
+		}
+	}
+	//#endregion
+
+	//#region ServiceWorkerRegistration
+	class ShimServiceWorkerRegistration extends ShimEventTarget {
+		constructor(scope) {
+			super();
+			this.scope = scope;
+			this.installing = null;
+			this.waiting = null;
+			this.active = null;
+			this.onupdatefound = null;
+		}
+
+		async update() {
+			return this;
+		}
+
+		async unregister() {
+			return true;
+		}
+	}
+	//#endregion
+
+	//#region ServiceWorkerContainer
+	class ShimServiceWorkerContainer extends ShimEventTarget {
+		#controller = null;
+
+		constructor() {
+			super();
+			this.onmessage = null;
+			this.oncontrollerchange = null;
+			this.ready = Promise.resolve(this);
+		}
+
+		get controller() {
+			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, options = {}) {
+			const resolvedURL = new URL(scriptURL, 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() {
+			return undefined;
+		}
+
+		async getRegistrations() {
+			return [];
+		}
+
+		startMessages() {}
+	}
+	//#endregion
+
+	//#region Location / document / window / self shims
+	const locationShim = pathToFileURL(join(cwd(), "/"));
+	Object.freeze?.(locationShim);
+
+	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, key, value) => {
+		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
+}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@ohos-ports/serwist-window",
+  "version": "9.5.12-beta.1",
+  "type": "module",
+  "description": "Simplifies communications with Serwist packages running in the service worker",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "keywords": [
+    "serwist",
+    "serwistjs",
+    "service worker",
+    "sw",
+    "window",
+    "message",
+    "postMessage"
+  ],
+  "author": "Google's Web DevRel Team",
+  "contributors": [
+    "Serwist <ducanh2912.rusty@gmail.com> (https://serwist.pages.dev/)"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/serwist-window/9.5.12"
+  },
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "homepage": "https://serwist.pages.dev",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "typesVersions": {
+    "*": {
+      "internal": [
+        "./dist/index.internal.d.mts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./internal": {
+      "types": "./dist/index.internal.d.mts",
+      "default": "./dist/index.internal.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@types/trusted-types": "2.0.7",
+    "serwist": "9.5.12"
+  },
+  "devDependencies": {
+    "@ohos-ports/tsdown": "^0.23.0-beta.0",
+    "typescript": "7.0.2"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "rimraf dist && NODE_ENV=production tsdown",
+    "dev": "tsdown --watch",
+    "lint": "biome lint ./src",
+    "typecheck": "tsc"
+  }
+}