@react-native-harness/bridge 1.5.0 → 1.6.0

package/dist/link/standard-websocket.js

@@ -0,0 +1,214 @@
+import { globalClock } from "./ports.js";
+export { globalClock } from "./ports.js";
+const OPEN = 1;
+const DEFAULT_POLL_MS = 4;
+export class StandardWebSocketConnection {
+    #socket;
+    #clock;
+    #pollMs;
+    #dataListeners = new Set();
+    #binaryListeners = new Set();
+    #closeListeners = new Set();
+    #errorListeners = new Set();
+    #sentListeners = new Set();
+    #pending = [];
+    #waiters = [];
+    #queued = 0;
+    #flushed = 0;
+    #checkScheduled = false;
+    #timer;
+    #closed = false;
+    constructor(socket, options = {}) {
+        this.#socket = socket;
+        this.#clock = options.clock ?? globalClock;
+        this.#pollMs = options.pollMs ?? DEFAULT_POLL_MS;
+        // why: the default, "blob", cannot be read without awaiting, which would reorder messages.
+        socket.binaryType = "arraybuffer";
+        const onMessage = (event) => {
+            this.#onMessage(event.data);
+        };
+        const onClose = () => this.#markClosed();
+        const onError = (event) => {
+            const error = event.error instanceof Error ? event.error : new Error("WebSocket error");
+            for (const listener of this.#errorListeners)
+                listener(error);
+            this.#markClosed();
+        };
+        socket.addEventListener("message", onMessage);
+        socket.addEventListener("close", onClose);
+        socket.addEventListener("error", onError);
+    }
+    get closed() {
+        return this.#closed;
+    }
+    get #buffered() {
+        return this.#socket.bufferedAmount ?? 0;
+    }
+    get unsentBytes() {
+        return this.#buffered;
+    }
+    onData(listener) {
+        this.#dataListeners.add(listener);
+        if (this.#pending.length > 0) {
+            for (const chunk of this.#pending.splice(0))
+                listener(chunk);
+        }
+        return () => {
+            this.#dataListeners.delete(listener);
+        };
+    }
+    onBinary(listener) {
+        this.#binaryListeners.add(listener);
+        return () => {
+            this.#binaryListeners.delete(listener);
+        };
+    }
+    onClose(listener) {
+        if (this.#closed) {
+            listener();
+            return () => undefined;
+        }
+        this.#closeListeners.add(listener);
+        return () => {
+            this.#closeListeners.delete(listener);
+        };
+    }
+    onError(listener) {
+        this.#errorListeners.add(listener);
+        return () => {
+            this.#errorListeners.delete(listener);
+        };
+    }
+    onSent(listener) {
+        this.#sentListeners.add(listener);
+        return () => {
+            this.#sentListeners.delete(listener);
+        };
+    }
+    write(contents) {
+        return this.#send(contents);
+    }
+    writeBinary(bytes) {
+        return this.#send(bytes);
+    }
+    async close() {
+        if (this.#closed)
+            return;
+        this.#socket.close();
+        this.#markClosed();
+    }
+    #send(data) {
+        if (this.#closed || this.#socket.readyState !== OPEN)
+            return Promise.resolve();
+        // why: the standard send() has no completion callback, so what has left the buffer is worked out from bufferedAmount.
+        const before = this.#buffered;
+        this.#socket.send(data);
+        this.#queued += Math.max(0, this.#buffered - before);
+        return new Promise((resolve) => {
+            this.#waiters.push({ resolve, target: this.#queued });
+            this.#scheduleCheck();
+        });
+    }
+    #onMessage(data) {
+        if (typeof data === "string") {
+            if (this.#dataListeners.size === 0) {
+                this.#pending.push(data);
+            }
+            else {
+                for (const listener of this.#dataListeners)
+                    listener(data);
+            }
+        }
+        else if (data instanceof ArrayBuffer) {
+            const bytes = new Uint8Array(data);
+            for (const listener of this.#binaryListeners)
+                listener(bytes);
+        }
+        else if (ArrayBuffer.isView(data)) {
+            const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+            for (const listener of this.#binaryListeners)
+                listener(bytes);
+        }
+        // why: a peer's message, a credit most of all, says bytes are moving, and is a cheaper look than a timer.
+        if (this.#waiters.length > 0 || this.#flushed < this.#queued)
+            this.#check();
+    }
+    #scheduleCheck() {
+        if (this.#checkScheduled)
+            return;
+        // why: a write must not settle, or report sent, before the call that made it has returned.
+        this.#checkScheduled = true;
+        void Promise.resolve().then(() => {
+            this.#checkScheduled = false;
+            this.#check();
+        });
+    }
+    #check() {
+        if (this.#closed)
+            return;
+        const buffered = this.#buffered;
+        const flushed = Math.max(this.#flushed, this.#queued - buffered);
+        const moved = flushed > this.#flushed;
+        this.#flushed = flushed;
+        if (this.#waiters.some((waiter) => waiter.target <= flushed)) {
+            const due = this.#waiters.filter((waiter) => waiter.target <= flushed);
+            this.#waiters = this.#waiters.filter((waiter) => waiter.target > flushed);
+            for (const waiter of due)
+                waiter.resolve();
+        }
+        if (moved)
+            for (const listener of this.#sentListeners)
+                listener();
+        if (buffered === 0 && this.#timer !== undefined) {
+            this.#clock.cancel(this.#timer);
+            this.#timer = undefined;
+        }
+        // why: a background tab throttles timers to about one a second, so a large transfer there slows until the tab is shown again.
+        if (buffered > 0 && this.#timer === undefined) {
+            this.#timer = this.#clock.setTimer(this.#pollMs, () => {
+                this.#timer = undefined;
+                this.#check();
+            });
+        }
+    }
+    #markClosed() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        if (this.#timer !== undefined) {
+            this.#clock.cancel(this.#timer);
+            this.#timer = undefined;
+        }
+        for (const waiter of this.#waiters.splice(0))
+            waiter.resolve();
+        for (const listener of this.#closeListeners)
+            listener();
+    }
+}
+export async function connectStandardWebSocket(options) {
+    const create = options.createSocket ??
+        ((url, protocols) => new WebSocket(url, protocols));
+    const socket = create(options.url, options.protocols);
+    const connection = new StandardWebSocketConnection(socket, options);
+    await new Promise((resolve, reject) => {
+        if (socket.readyState === OPEN)
+            return resolve();
+        const onOpen = () => {
+            cleanup();
+            resolve();
+        };
+        const onFail = () => {
+            cleanup();
+            reject(new Error(`could not open a WebSocket to ${options.url}`));
+        };
+        const cleanup = () => {
+            socket.removeEventListener("open", onOpen);
+            socket.removeEventListener("error", onFail);
+            socket.removeEventListener("close", onFail);
+        };
+        socket.addEventListener("open", onOpen);
+        socket.addEventListener("error", onFail);
+        socket.addEventListener("close", onFail);
+    });
+    return connection;
+}

package/dist/link/streams.d.ts

@@ -0,0 +1,4 @@
+export declare const LinkReadableStream: typeof globalThis.ReadableStream;
+export declare const LinkWritableStream: typeof globalThis.WritableStream;
+export declare const LinkByteLengthQueuingStrategy: typeof globalThis.ByteLengthQueuingStrategy;
+//# sourceMappingURL=streams.d.ts.map

package/dist/link/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../src/link/streams.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,kBAAkB,EAAE,OAAO,UAAU,CAAC,cAEwB,CAAC;AAE5E,eAAO,MAAM,kBAAkB,EAAE,OAAO,UAAU,CAAC,cAEwB,CAAC;AAE5E,eAAO,MAAM,6BAA6B,EAAE,OAAO,UAAU,CAAC,yBAEmC,CAAC"}

package/dist/link/streams.js

@@ -0,0 +1,15 @@
+import { ByteLengthQueuingStrategy as PonyfillByteLengthQueuingStrategy, ReadableStream as PonyfillReadableStream, WritableStream as PonyfillWritableStream, } from "web-streams-polyfill";
+const host = globalThis;
+// why: one source for all three, so a native stream never meets a ponyfilled strategy.
+const native = typeof host.ReadableStream === "function" &&
+    typeof host.WritableStream === "function" &&
+    typeof host.ByteLengthQueuingStrategy === "function";
+export const LinkReadableStream = native
+    ? host.ReadableStream
+    : PonyfillReadableStream;
+export const LinkWritableStream = native
+    ? host.WritableStream
+    : PonyfillWritableStream;
+export const LinkByteLengthQueuingStrategy = native
+    ? host.ByteLengthQueuingStrategy
+    : PonyfillByteLengthQueuingStrategy;

package/dist/platform-bridge.d.ts

@@ -0,0 +1,4 @@
+import type { HarnessPlatformRunner } from '@react-native-harness/platforms';
+import type { BridgeServerFunctions } from './shared.js';
+export declare const createPlatformBridgeFunctions: (platformRunner: HarnessPlatformRunner) => Partial<BridgeServerFunctions>;
+//# sourceMappingURL=platform-bridge.d.ts.map

package/dist/platform-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-bridge.d.ts","sourceRoot":"","sources":["../src/platform-bridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD,eAAO,MAAM,6BAA6B,GACxC,gBAAgB,qBAAqB,KACpC,OAAO,CAAC,qBAAqB,CAwB/B,CAAC"}

package/dist/platform-bridge.js

@@ -0,0 +1,25 @@
+export const createPlatformBridgeFunctions = (platformRunner) => {
+    return {
+        'platform.actions.tap': async (x, y) => {
+            await platformRunner.actions.tap(x, y);
+        },
+        'platform.actions.inputText': async (text) => {
+            await platformRunner.actions.inputText(text);
+        },
+        'platform.actions.tapElement': async (element) => {
+            await platformRunner.actions.tapElement(element);
+        },
+        'platform.actions.screenshot': async () => {
+            return await platformRunner.actions.screenshot();
+        },
+        'platform.queries.getUiHierarchy': async () => {
+            return await platformRunner.queries.getUiHierarchy();
+        },
+        'platform.queries.findByTestId': async (testId) => {
+            return await platformRunner.queries.findByTestId(testId);
+        },
+        'platform.queries.findAllByTestId': async (testId) => {
+            return await platformRunner.queries.findAllByTestId(testId);
+        },
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-harness/bridge",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -32,8 +32,8 @@
     "ssim.js": "^3.5.0",
     "tslib": "^2.3.0",
     "ws": "^8.18.2",
-    "@react-native-harness/platforms": "1.5.0",
-    "@react-native-harness/tools": "1.5.0"
+    "@react-native-harness/platforms": "1.6.0",
+    "@react-native-harness/tools": "1.6.0"
   },
   "devDependencies": {
     "@types/pixelmatch": "^5.2.6",