wawesome 0.18.1 → 0.20.0

package/dist/{guest-parity-Df4rlLDW.mjs → guest-parity-W61MH7Fb.mjs}

@@ -1,4 +1,4 @@
-import { a as unsupportedGlobals, i as shimmedGlobals, n as methodRemedy, r as polyfilledGlobals, t as declaredMethods } from "./guest-surface-CXON0L5V.mjs";
+import { a as unsupportedGlobals, i as shimmedGlobals, n as methodRemedy, r as polyfilledGlobals, t as declaredMethods } from "./guest-surface-D5X-IMAN.mjs";
 //#region ../../server/guest-surface/message-channel.js
 const ENTANGLED = Symbol("entangled");
 const QUEUE = Symbol("queue");
@@ -6,6 +6,39 @@ const STARTED = Symbol("started");
 const CLOSED = Symbol("closed");
 const LISTENERS = Symbol("listeners");
 const ONMESSAGE = Symbol("onmessage");
+var MessageEvent = class extends Event {
+	#data;
+	#origin;
+	#lastEventId;
+	#source;
+	#ports;
+	constructor(type, init = {}) {
+		super(type, init);
+		this.#data = init.data ?? null;
+		this.#origin = init.origin ?? "";
+		this.#lastEventId = init.lastEventId ?? "";
+		this.#source = init.source ?? null;
+		this.#ports = init.ports ?? [];
+	}
+	get data() {
+		return this.#data;
+	}
+	get origin() {
+		return this.#origin;
+	}
+	get lastEventId() {
+		return this.#lastEventId;
+	}
+	get source() {
+		return this.#source;
+	}
+	get ports() {
+		return this.#ports;
+	}
+	get [Symbol.toStringTag]() {
+		return "MessageEvent";
+	}
+};
 var MessagePort = class {
 	constructor() {
 		this[ENTANGLED] = null;
@@ -59,15 +92,18 @@ function drain(port) {
 	const data = port[QUEUE].shift();
 	setTimeout(() => {
 		if (port[CLOSED]) return;
-		deliver(port, {
-			type: "message",
-			data,
-			target: port,
-			ports: []
-		});
+		deliver(port, messageEvent(port, data));
 		drain(port);
 	}, 0);
 }
+function messageEvent(port, data) {
+	const event = new MessageEvent("message", { data });
+	Object.defineProperty(event, "target", {
+		value: port,
+		enumerable: true
+	});
+	return event;
+}
 function deliver(port, event) {
 	if (typeof port.onmessage === "function") port.onmessage(event);
 	for (const listener of port[LISTENERS].slice()) if (typeof listener === "function") listener.call(port, event);
@@ -82,6 +118,84 @@ var MessageChannel = class {
 	}
 };
 //#endregion
+//#region ../../server/guest-surface/text-streams.js
+const READABLE = Symbol("readable");
+const WRITABLE = Symbol("writable");
+const DECODER = Symbol("decoder");
+var TextEncoderStream = class {
+	constructor() {
+		const encoder = new TextEncoder();
+		let held = "";
+		const pipe = new TransformStream({
+			transform(chunk, controller) {
+				const text = held + String(chunk);
+				held = endsInHighSurrogate(text) ? text.slice(-1) : "";
+				const bytes = encoder.encode(held === "" ? text : text.slice(0, -1));
+				if (bytes.length > 0) controller.enqueue(bytes);
+			},
+			flush(controller) {
+				if (held === "") return;
+				controller.enqueue(encoder.encode(held));
+				held = "";
+			}
+		});
+		this[READABLE] = pipe.readable;
+		this[WRITABLE] = pipe.writable;
+	}
+	get encoding() {
+		return "utf-8";
+	}
+	get readable() {
+		return this[READABLE];
+	}
+	get writable() {
+		return this[WRITABLE];
+	}
+	get [Symbol.toStringTag]() {
+		return "TextEncoderStream";
+	}
+};
+function endsInHighSurrogate(text) {
+	const last = text.charCodeAt(text.length - 1);
+	return last >= 55296 && last <= 56319;
+}
+var TextDecoderStream = class {
+	constructor(label = "utf-8", options = {}) {
+		const decoder = new TextDecoder(label, options);
+		const pipe = new TransformStream({
+			transform(chunk, controller) {
+				const text = decoder.decode(chunk, { stream: true });
+				if (text !== "") controller.enqueue(text);
+			},
+			flush(controller) {
+				const text = decoder.decode();
+				if (text !== "") controller.enqueue(text);
+			}
+		});
+		this[DECODER] = decoder;
+		this[READABLE] = pipe.readable;
+		this[WRITABLE] = pipe.writable;
+	}
+	get encoding() {
+		return this[DECODER].encoding;
+	}
+	get fatal() {
+		return this[DECODER].fatal;
+	}
+	get ignoreBOM() {
+		return this[DECODER].ignoreBOM;
+	}
+	get readable() {
+		return this[READABLE];
+	}
+	get writable() {
+		return this[WRITABLE];
+	}
+	get [Symbol.toStringTag]() {
+		return "TextDecoderStream";
+	}
+};
+//#endregion
 //#region ../../server/guest-surface/locale-methods.js
 function installUnsupportedLocaleMethods(scope, methods, remedy) {
 	const replaced = [];
@@ -118,7 +232,10 @@ function resolve(scope, target) {
 //#region src/guest-parity.ts
 const SHIMS = {
 	MessageChannel,
-	MessagePort
+	MessageEvent,
+	MessagePort,
+	TextDecoderStream,
+	TextEncoderStream
 };
 function applyGuestParity(options = {}) {
 	const scope = globalThis;
@@ -126,11 +243,16 @@ function applyGuestParity(options = {}) {
 	const undo = [];
 	const removed = [];
 	const exempted = [];
+	const neededByHost = [];
 	for (const entry of unsupportedGlobals()) {
 		if (polyfilled.has(entry.name)) {
 			exempted.push(entry.name);
 			continue;
 		}
+		if (entry.neededByHost) {
+			neededByHost.push(entry.name);
+			continue;
+		}
 		const descriptor = Object.getOwnPropertyDescriptor(scope, entry.name);
 		if (!descriptor) continue;
 		undo.push(() => Object.defineProperty(scope, entry.name, descriptor));
@@ -158,6 +280,7 @@ function applyGuestParity(options = {}) {
 		shimmed,
 		replacedMethods: replaced.map(({ target, name }) => `${target}.${name}`),
 		exempted,
+		neededByHost,
 		restore() {
 			for (const step of undo.reverse()) step();
 			undo.length = 0;

package/dist/guest-parity.d.mts

@@ -9,6 +9,8 @@ interface GuestParity {
   replacedMethods: string[];
   /** Left in place because the project bundles a polyfill for them. */
   exempted: string[];
+  /** Left in place because this process needs them. The guest still has none. */
+  neededByHost: string[];
   restore(): void;
 }
 declare function applyGuestParity(options?: GuestParityOptions): GuestParity;

package/dist/guest-parity.mjs

@@ -1,2 +1,2 @@
-import { t as applyGuestParity } from "./guest-parity-Df4rlLDW.mjs";
+import { t as applyGuestParity } from "./guest-parity-W61MH7Fb.mjs";
 export { applyGuestParity };

package/dist/guest-surface-D5X-IMAN.mjs

@@ -0,0 +1,208 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region ../../server/guest-surface/surface.json
+var globals = [
+	{
+		"name": "MessageChannel",
+		"status": "shim",
+		"shim": "message-channel",
+		"why": "The engine has none. react-dom/server.browser constructs one at module scope, so a bundle that reaches for it does not evaluate at all."
+	},
+	{
+		"name": "MessagePort",
+		"status": "shim",
+		"shim": "message-channel",
+		"why": "The other half of the pair: a port handed to code that checks what it received has to be a real constructor."
+	},
+	{
+		"name": "MessageEvent",
+		"status": "shim",
+		"shim": "message-channel",
+		"why": "What the pair above carries. Without it, code that checks `event instanceof MessageEvent` fails against our own shim."
+	},
+	{
+		"name": "TextEncoderStream",
+		"status": "shim",
+		"shim": "text-streams",
+		"why": "The engine has TransformStream and TextEncoder and not this wrapper over them. Every other stream class is there, so the gap is easy to walk into while piping a body."
+	},
+	{
+		"name": "TextDecoderStream",
+		"status": "shim",
+		"shim": "text-streams",
+		"why": "The other direction, and the one a streamed request body is read through."
+	},
+	{
+		"name": "Intl",
+		"status": "unsupported",
+		"remedy": "bundle an Intl polyfill, for example @formatjs/intl-numberformat",
+		"providedBy": [
+			"intl",
+			"full-icu",
+			"@formatjs/intl",
+			"@formatjs/intl-*",
+			"intl-pluralrules",
+			"intl-locales-supported",
+			"intl-segmenter-polyfill"
+		]
+	},
+	{
+		"name": "URLPattern",
+		"status": "unsupported",
+		"remedy": "bundle a URLPattern polyfill, for example urlpattern-polyfill",
+		"providedBy": ["urlpattern-polyfill"]
+	},
+	{
+		"name": "WebSocket",
+		"status": "unsupported",
+		"remedy": "the sandbox has no sockets, so nothing can supply this one; open the connection from the browser instead, or reach a realtime service over HTTPS"
+	},
+	{
+		"name": "EventSource",
+		"status": "unsupported",
+		"remedy": "a run is bounded by the invocation clock, so nothing here can hold a subscription open for a client; subscribe from the browser instead, or poll with fetch"
+	},
+	{
+		"name": "BroadcastChannel",
+		"status": "unsupported",
+		"remedy": "each invocation runs on its own and shares no memory with any other, so there is nobody here to broadcast to; pass the message over fetch to a service that holds it"
+	},
+	{
+		"name": "caches",
+		"status": "unsupported",
+		"remedy": "the platform has no Cache API; keep the value in a service you reach over fetch"
+	},
+	{
+		"name": "FileReader",
+		"status": "unsupported",
+		"remedy": "read the Blob directly: await blob.text(), await blob.arrayBuffer(), or blob.stream()"
+	},
+	{
+		"name": "WebAssembly",
+		"status": "unsupported",
+		"neededByHost": true,
+		"why": "Node compiles its own HTTP parser from WebAssembly the first time anything calls fetch, so a suite that had this taken away would fail inside undici rather than in the code under test.",
+		"remedy": "the guest is itself WebAssembly and cannot load more of it; do the work in JavaScript, or call a service that does it"
+	},
+	{
+		"name": "XMLHttpRequest",
+		"status": "unsupported",
+		"remedy": "use fetch, which the guest has"
+	},
+	{
+		"name": "navigator",
+		"status": "unsupported",
+		"remedy": "nothing here is a browser, so nothing can supply it; ask with typeof navigator and take the other path"
+	},
+	{
+		"name": "localStorage",
+		"status": "unsupported",
+		"remedy": "nothing written in one invocation survives into the next; keep the value in a store you reach over fetch, or hand it back to the caller"
+	},
+	{
+		"name": "sessionStorage",
+		"status": "unsupported",
+		"remedy": "nothing written in one invocation survives into the next; keep the value in a store you reach over fetch, or hand it back to the caller"
+	},
+	{
+		"name": "indexedDB",
+		"status": "unsupported",
+		"remedy": "the sandbox has no database; reach one over fetch"
+	},
+	{
+		"name": "setImmediate",
+		"status": "unsupported",
+		"remedy": "call setTimeout(fn, 0), or queueMicrotask(fn) where the callback must run before the host is yielded to"
+	},
+	{
+		"name": "reportError",
+		"status": "unsupported",
+		"remedy": "throw, or write the error yourself with console.error"
+	},
+	{
+		"name": "Atomics",
+		"status": "unsupported",
+		"remedy": "the guest runs one thread and shares memory with nothing, so there is nothing here to synchronise against; take the single-threaded path"
+	},
+	{
+		"name": "SharedArrayBuffer",
+		"status": "unsupported",
+		"remedy": "the guest runs one thread and shares memory with nothing; use an ArrayBuffer"
+	}
+];
+var methods = [
+	{
+		"target": "Number.prototype",
+		"name": "toLocaleString"
+	},
+	{
+		"target": "Date.prototype",
+		"name": "toLocaleString"
+	},
+	{
+		"target": "Date.prototype",
+		"name": "toLocaleDateString"
+	},
+	{
+		"target": "Date.prototype",
+		"name": "toLocaleTimeString"
+	},
+	{
+		"target": "String.prototype",
+		"name": "toLocaleLowerCase"
+	},
+	{
+		"target": "String.prototype",
+		"name": "toLocaleUpperCase"
+	}
+];
+var methodRemedy$1 = "the engine carries no ICU, so it ignores the locale and returns an unlocalised string; format the value yourself, or bundle a formatting library and call it directly";
+//#endregion
+//#region src/guest-surface.ts
+function declaredGlobals() {
+	return globals;
+}
+function declaredMethods() {
+	return methods;
+}
+function methodRemedy() {
+	return methodRemedy$1;
+}
+function unsupportedGlobals() {
+	return declaredGlobals().filter((entry) => entry.status === "unsupported");
+}
+function shimmedGlobals() {
+	return declaredGlobals().filter((entry) => entry.status === "shim");
+}
+/**
+* Globals a project already carries a polyfill for, read from the manifest the
+* polyfill is declared in so nothing here can drift from what is bundled.
+*/
+function polyfilledGlobals(projectDir) {
+	const declared = declaredPackages(projectDir);
+	return new Set(declaredGlobals().filter((entry) => (entry.providedBy ?? []).some((pattern) => declared.some((name) => matches(pattern, name)))).map((entry) => entry.name));
+}
+function matches(pattern, name) {
+	if (!pattern.endsWith("*")) return pattern === name;
+	return name.startsWith(pattern.slice(0, -1));
+}
+function declaredPackages(projectDir) {
+	const manifest = path.join(projectDir, "package.json");
+	if (!fs.existsSync(manifest)) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(fs.readFileSync(manifest, "utf-8"));
+	} catch {
+		return [];
+	}
+	return [
+		"dependencies",
+		"devDependencies",
+		"optionalDependencies"
+	].flatMap((field) => {
+		const deps = parsed[field];
+		return typeof deps === "object" && deps !== null ? Object.keys(deps) : [];
+	});
+}
+//#endregion
+export { unsupportedGlobals as a, shimmedGlobals as i, methodRemedy as n, polyfilledGlobals as r, declaredMethods as t };