@react-native-harness/runtime 1.1.0 → 1.2.0

package/src/expect/expect.ts

@@ -13,6 +13,7 @@ import {
 import * as chai from 'chai';
 
 // Setup additional matchers
+import { getCurrentExpectTestState } from './context.js';
 import './setup.js';
 import { toMatchImageSnapshot } from './matchers/toMatchImageSnapshot.js';
 
@@ -20,12 +21,22 @@ export function createExpect(): ExpectStatic {
   const expect = ((value: unknown, message?: string): Assertion => {
     const { assertionCalls } = getState(expect);
     setState({ assertionCalls: assertionCalls + 1 }, expect);
-    return chai.expect(value, message) as unknown as Assertion;
+
+    const assertion = chai.expect(value, message) as unknown as Assertion & {
+      withTest?: (test: unknown) => Assertion;
+    };
+    const currentTest = getCurrentExpectTestState();
+
+    return currentTest && assertion.withTest
+      ? assertion.withTest(currentTest)
+      : assertion;
   }) as ExpectStatic;
   Object.assign(expect, chai.expect);
   Object.assign(
     expect,
-    globalThis[ASYMMETRIC_MATCHERS_OBJECT as unknown as keyof typeof globalThis]
+    globalThis[
+      ASYMMETRIC_MATCHERS_OBJECT as unknown as keyof typeof globalThis
+    ],
   );
 
   expect.getState = () => getState<MatcherState>(expect);
@@ -44,7 +55,7 @@ export function createExpect(): ExpectStatic {
       expectedAssertionsNumber: null,
       expectedAssertionsNumberErrorGen: null,
     },
-    expect
+    expect,
   );
 
   // @ts-expect-error untyped
@@ -62,7 +73,7 @@ export function createExpect(): ExpectStatic {
   // @ts-expect-error untyped
   expect.unreachable = (message?: string) => {
     chai.assert.fail(
-      `expected${message ? ` "${message}" ` : ' '}not to be reached`
+      `expected${message ? ` "${message}" ` : ' '}not to be reached`,
     );
   };
 
@@ -71,7 +82,7 @@ export function createExpect(): ExpectStatic {
       new Error(
         `expected number of assertions to be ${expected}, but got ${
           expect.getState().assertionCalls
-        }`
+        }`,
       );
     if (Error.captureStackTrace) {
       Error.captureStackTrace(errorGen(), assertions);

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/runner/runSuite.ts

@@ -4,6 +4,11 @@ import type {
   TestSuite,
   TestSuiteResult,
 } from '@react-native-harness/bridge';
+import {
+  setCurrentExpectTestState,
+  type HarnessExpectTestState,
+} from '../expect/context.js';
+import { flushExpectTestState } from '../expect/errors.js';
 import { runHooks } from './hooks.js';
 import { getTestExecutionError } from './errors.js';
 import { TestRunnerContext } from './types.js';
@@ -15,7 +20,7 @@ declare global {
 const runTest = async (
   test: TestCase,
   suite: TestSuite,
-  context: TestRunnerContext
+  context: TestRunnerContext,
 ): Promise<TestResult> => {
   const startTime = Date.now();
 
@@ -69,14 +74,23 @@ const runTest = async (
       return result;
     }
 
-    // Run all beforeEach hooks from the current suite and its parents
-    await runHooks(suite, 'beforeEach');
+    const expectTestState: HarnessExpectTestState = {};
+    setCurrentExpectTestState(expectTestState);
 
-    // Run the actual test
-    await test.fn();
+    try {
+      // Run all beforeEach hooks from the current suite and its parents
+      await runHooks(suite, 'beforeEach');
 
-    // Run all afterEach hooks from the current suite and its parents
-    await runHooks(suite, 'afterEach');
+      // Run the actual test
+      await test.fn();
+
+      // Run all afterEach hooks from the current suite and its parents
+      await runHooks(suite, 'afterEach');
+
+      await flushExpectTestState(expectTestState);
+    } finally {
+      setCurrentExpectTestState(undefined);
+    }
 
     const duration = Date.now() - startTime;
 
@@ -102,7 +116,7 @@ const runTest = async (
       error,
       context.testFilePath,
       suite.name,
-      test.name
+      test.name,
     );
     const duration = Date.now() - startTime;
 
@@ -130,7 +144,7 @@ const runTest = async (
 
 export const runSuite = async (
   suite: TestSuite,
-  context: TestRunnerContext
+  context: TestRunnerContext,
 ): Promise<TestSuiteResult> => {
   const startTime = Date.now();
 
@@ -212,10 +226,10 @@ export const runSuite = async (
 
   // Check if any tests or child suites failed
   const hasFailedTests = testResults.some(
-    (result) => result.status === 'failed'
+    (result) => result.status === 'failed',
   );
   const hasFailedSuites = suiteResults.some(
-    (result) => result.status === 'failed'
+    (result) => result.status === 'failed',
   );
 
   if (hasFailedTests || hasFailedSuites) {

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) => {