@react-native-harness/runtime 1.2.0-rc.1 → 1.2.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@react-native-harness/runtime",
   "description": "The core test runtime that executes on React Native devices, providing Jest-compatible APIs (describe, it, expect) and managing test collection, execution, and result reporting in native environments.",
-  "version": "1.2.0-rc.1",
+  "version": "1.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -47,7 +47,7 @@
     "react-native-url-polyfill": "^3.0.0",
     "use-sync-external-store": "^1.6.0",
     "zustand": "^5.0.5",
-    "@react-native-harness/bridge": "1.2.0-rc.1"
+    "@react-native-harness/bridge": "1.2.0"
   },
   "devDependencies": {
     "@types/chai": "^5.2.2"

package/src/client/factory.ts

@@ -4,7 +4,7 @@ import type {
   BundlerEvents,
   TestExecutionOptions,
 } from '@react-native-harness/bridge';
-import { getBridgeClient } from '@react-native-harness/bridge/client';
+import { connectToHarness, type HarnessHandle } from '@react-native-harness/bridge/client';
 import { store } from '../ui/state.js';
 import { getTestRunner, TestRunner } from '../runner/index.js';
 import { getTestCollector, TestCollector } from '../collector/index.js';
@@ -14,92 +14,81 @@ import { getBundler, evaluateModule, Bundler } from '../bundler/index.js';
 import { markTestsAsSkippedByName } from '../filtering/index.js';
 import { setup } from '../render/setup.js';
 import { runSetupFiles } from './setup-files.js';
-import { setClient } from './store.js';
+import { setHandle } from './store.js';
 
-export const getClient = async () => {
-  const client = await getBridgeClient(getWSServer(), {
-    runTests: async () => {
-      throw new Error('Not implemented');
-    },
-  });
-
-  setClient(client);
-
-  client.rpc.$functions.runTests = async (
-    path: string,
-    options: TestExecutionOptions
-  ) => {
-    if (store.getState().status === 'running') {
-      throw new Error('Already running tests');
-    }
-
-    store.getState().setStatus('running');
+export const getClient = async (): Promise<HarnessHandle> => {
+  const handle = await connectToHarness(getWSServer(), {
+    runTests: async (path: string, options: TestExecutionOptions) => {
+      if (store.getState().status === 'running') {
+        throw new Error('Already running tests');
+      }
 
-    let collector: TestCollector | null = null;
-    let runner: TestRunner | null = null;
-    let events: EventEmitter<
-      TestRunnerEvents | TestCollectorEvents | BundlerEvents
-    > | null = null;
-    let bundler: Bundler | null = null;
+      store.getState().setStatus('running');
 
-    try {
-      collector = getTestCollector();
-      runner = getTestRunner();
-      bundler = getBundler();
-      events = combineEventEmitters(
-        collector.events,
-        runner.events,
-        bundler.events
-      );
+      let collector: TestCollector | null = null;
+      let runner: TestRunner | null = null;
+      let events: EventEmitter<
+        TestRunnerEvents | TestCollectorEvents | BundlerEvents
+      > | null = null;
+      let bundler: Bundler | null = null;
 
-      events.addListener((event) => {
-        client.rpc.emitEvent(event.type, event);
-      });
+      try {
+        collector = getTestCollector();
+        runner = getTestRunner();
+        bundler = getBundler();
+        events = combineEventEmitters(
+          collector.events,
+          runner.events,
+          bundler.events,
+        );
 
-      await runSetupFiles({
-        setupFiles: options.setupFiles ?? [],
-        setupFilesAfterEnv: [],
-        events: events as EventEmitter<BundlerEvents>,
-        bundler: bundler as Bundler,
-        evaluateModule,
-      });
+        events.addListener((event) => {
+          handle.emitEvent(event);
+        });
 
-      const moduleJs = await bundler.getModule(path);
-      const collectionResult = await collector.collect(async () => {
         await runSetupFiles({
-          setupFiles: [],
-          setupFilesAfterEnv: options.setupFilesAfterEnv ?? [],
+          setupFiles: options.setupFiles ?? [],
+          setupFilesAfterEnv: [],
           events: events as EventEmitter<BundlerEvents>,
           bundler: bundler as Bundler,
           evaluateModule,
         });
 
-        // Setup automatic cleanup for rendered components
-        setup();
-        evaluateModule(moduleJs, path);
-      }, path);
+        const moduleJs = await bundler.getModule(path);
+        const collectionResult = await collector.collect(async () => {
+          await runSetupFiles({
+            setupFiles: [],
+            setupFilesAfterEnv: options.setupFilesAfterEnv ?? [],
+            events: events as EventEmitter<BundlerEvents>,
+            bundler: bundler as Bundler,
+            evaluateModule,
+          });
+
+          setup();
+          evaluateModule(moduleJs, path);
+        }, path);
 
-      // Apply test name pattern by marking non-matching tests as skipped
-      const processedTestSuite = options.testNamePattern
-        ? markTestsAsSkippedByName(
-            collectionResult.testSuite,
-            options.testNamePattern
-          )
-        : collectionResult.testSuite;
+        const processedTestSuite = options.testNamePattern
+          ? markTestsAsSkippedByName(
+              collectionResult.testSuite,
+              options.testNamePattern,
+            )
+          : collectionResult.testSuite;
 
-      const result = await runner.run({
-        testSuite: processedTestSuite,
-        testFilePath: path,
-        runner: options.runner,
-      });
-      return result;
-    } finally {
-      collector?.dispose();
-      runner?.dispose();
-      events?.clearAllListeners();
-      store.getState().setStatus('idle');
-    }
-  };
+        return await runner.run({
+          testSuite: processedTestSuite,
+          testFilePath: path,
+          runner: options.runner,
+        });
+      } finally {
+        collector?.dispose();
+        runner?.dispose();
+        events?.clearAllListeners();
+        store.getState().setStatus('idle');
+      }
+    },
+  });
 
-  return client;
+  setHandle(handle);
+  return handle;
 };

package/src/client/store.ts

@@ -1,16 +1,16 @@
-import type { BridgeClient } from '@react-native-harness/bridge/client';
+import type { HarnessHandle } from '@react-native-harness/bridge/client';
 
-let clientInstance: BridgeClient | null = null;
+let handle: HarnessHandle | null = null;
 
-export const setClient = (client: BridgeClient): void => {
-  clientInstance = client;
+export const setHandle = (h: HarnessHandle): void => {
+  handle = h;
 };
 
-export const getClientInstance = (): BridgeClient => {
-  if (!clientInstance) {
+export const getHandle = (): HarnessHandle => {
+  if (!handle) {
     throw new Error(
-      'Bridge client not initialized. This should not happen in normal operation.'
+      'Harness not connected. This should not happen in normal operation.'
     );
   }
-  return clientInstance;
+  return handle;
 };

package/src/expect/matchers/toMatchImageSnapshot.ts

@@ -1,9 +1,6 @@
-import { getClientInstance } from '../../client/store.js';
+import { getHandle } from '../../client/store.js';
 import type { MatcherState } from '@vitest/expect';
-import {
-  type ImageSnapshotOptions,
-  generateTransferId,
-} from '@react-native-harness/bridge';
+import type { ImageSnapshotOptions } from '@react-native-harness/bridge';
 import { getHarnessContext } from '../../runner/index.js';
 
 type ScreenshotResult = {
@@ -17,30 +14,19 @@ export async function toMatchImageSnapshot(
   received: ScreenshotResult,
   options: ImageSnapshotOptions
 ): Promise<{ pass: boolean; message: () => string }> {
-  const client = getClientInstance();
+  const handle = getHandle();
   const context = getHarnessContext();
 
-  const transferId = generateTransferId();
-  client.sendBinary(transferId, received.data);
+  const screenshotFile = await handle.transferScreenshot(received.data, {
+    width: received.width,
+    height: received.height,
+  });
 
-  const screenshotFile = await client.rpc['device.screenshot.receive'](
-    {
-      type: 'binary',
-      transferId,
-      size: received.data.length,
-      mimeType: 'image/png',
-    },
-    {
-      width: received.width,
-      height: received.height,
-    }
-  );
-
-  const result = await client.rpc['test.matchImageSnapshot'](
+  const result = await handle.matchImageSnapshot(
     screenshotFile,
     context.testFilePath,
     options,
-    context.runner
+    context.runner,
   );
 
   return {

package/src/initialize.ts

@@ -3,10 +3,19 @@ import { getClient } from './client/index.js';
 import { disableHMRWhenReady } from './disableHMRWhenReady.js';
 import { setupJestMock } from './jest-mock.js';
 
-// Polyfill for EventTarget
+// Polyfill for EventTarget on runtimes that don't ship one (RN's JSC).
+// Do NOT overwrite when a native ctor already exists (RN Web / browsers):
+// Safari's EventTarget.dispatchEvent() does an internal brand check and
+// rejects polyfill instances with a TypeError, which breaks any
+// DOM-event-driven flow in the page — most visibly DRM (FairPlay) via
+// libraries that re-dispatch synthetic `encrypted` events.
 const Shim = require('event-target-shim');
-globalThis.Event = Shim.Event;
-globalThis.EventTarget = Shim.EventTarget;
+if (typeof globalThis.Event !== 'function') {
+  globalThis.Event = Shim.Event;
+}
+if (typeof globalThis.EventTarget !== 'function') {
+  globalThis.EventTarget = Shim.EventTarget;
+}
 
 // Setup jest mock to warn users about using Jest APIs
 setupJestMock();
@@ -25,10 +34,10 @@ setTimeout(() => {
   void (async () => {
     try {
       await disableHMRWhenReady(() => HMRClient.disable(), 50);
-      const client = await getClient();
+      const handle = await getClient();
 
       const deviceDescriptor = getDeviceDescriptor();
-      await client.rpc.reportReady(deviceDescriptor);
+      handle.reportReady(deviceDescriptor);
     } catch (error) {
       console.error('Failed to initialize React Native Harness', error);
     }

package/src/jsx/jsx-dev-runtime.ts

@@ -1,26 +1,45 @@
 import * as ReactJSXRuntimeDev from 'react/jsx-dev-runtime';
 
+type NamedElementType = {
+  displayName?: string;
+  name?: string;
+};
+
+const isNamedElementType = (value: unknown): value is NamedElementType =>
+  (typeof value === 'function' ||
+    (typeof value === 'object' && value !== null)) &&
+  ('displayName' in value || 'name' in value);
+
+const isPropsObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
 export const Fragment = ReactJSXRuntimeDev.Fragment;
 
-export function jsxDEV(
-  type: any,
-  props: any,
-  key: any,
-  isStaticChildren: any,
-  source: any,
-  self: any
-) {
-  if (
-    type &&
-    (type.displayName === 'View' || type.name === 'View') &&
-    props &&
+export function jsxDEV(...args: Parameters<typeof ReactJSXRuntimeDev.jsxDEV>) {
+  const [type, props, key, isStaticChildren, source, self] = args;
+  const isViewType =
+    isNamedElementType(type) &&
+    (type.displayName === 'View' || type.name === 'View');
+  const nextProps =
+    isViewType &&
+    isPropsObject(props) &&
     props.collapsable === undefined
-  ) {
-    props = { ...props, collapsable: true };
+      ? { ...props, collapsable: true }
+      : props;
+
+  if (isViewType && isPropsObject(props) && props.collapsable === undefined) {
+    return ReactJSXRuntimeDev.jsxDEV(
+      type,
+      nextProps,
+      key,
+      isStaticChildren,
+      source,
+      self
+    );
   }
   return ReactJSXRuntimeDev.jsxDEV(
     type,
-    props,
+    nextProps,
     key,
     isStaticChildren,
     source,

package/src/waitFor.ts

@@ -114,6 +114,12 @@ export interface WaitUntilOptions
 
 type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
 
+const isPromiseLike = <T>(value: T | PromiseLike<T>): value is PromiseLike<T> =>
+  value !== null &&
+  typeof value === 'object' &&
+  'then' in value &&
+  typeof value.then === 'function';
+
 export function waitUntil<T>(
   callback: WaitUntilCallback<T>,
   options: number | WaitUntilOptions = {}
@@ -164,12 +170,8 @@ export function waitUntil<T>(
       }
       try {
         const result = callback();
-        if (
-          result !== null &&
-          typeof result === 'object' &&
-          typeof (result as any).then === 'function'
-        ) {
-          const thenable = result as PromiseLike<T>;
+        if (isPromiseLike(result)) {
+          const thenable = result;
           promiseStatus = 'pending';
           thenable.then(
             (resolvedValue) => {