@react-native-harness/runtime 1.0.0-alpha.19 → 1.0.0-alpha.20

package/assets/harness-module-system.js

@@ -0,0 +1,73 @@
+// @ts-nocheck
+/* eslint-disable */
+
+// This file is a polyfill that monkey-patches the Metro module system
+// to allow capturing nested require calls.
+
+(function (globalObject) {
+  const myRequire = function (id) {
+    return globalObject.__r(id);
+  };
+
+  const myImportDefault = function (id) {
+    return globalObject.__r.importDefault(id);
+  };
+
+  const myImportAll = function (id) {
+    return globalObject.__r.importAll(id);
+  };
+
+  // Monkey-patch define
+  const originalDefine = globalObject.__d;
+  globalObject.__d = function (factory, moduleId, dependencyMap) {
+    const wrappedFactory = function (...args) {
+      // Standard Metro with import support (7 arguments)
+      // args: global, require, importDefault, importAll, module, exports, dependencyMap
+      const global = args[0];
+      const moduleObject = args[4];
+      const exports = args[5];
+      const depMap = args[6];
+
+      return factory(
+        global,
+        myRequire,
+        myImportDefault,
+        myImportAll,
+        moduleObject,
+        exports,
+        depMap
+      );
+    };
+
+    // Call the original define with the wrapped factory
+    return originalDefine.call(this, wrappedFactory, moduleId, dependencyMap);
+  };
+
+  globalObject.__resetModule = function (moduleId) {
+    const module = globalObject.__r.getModules().get(moduleId);
+
+    if (!module) {
+      return;
+    }
+
+    module.hasError = false;
+    module.error = undefined;
+    module.isInitialized = false;
+  };
+
+  globalObject.__resetModules = function () {
+    const modules = globalObject.__r.getModules();
+
+    modules.forEach(function (mod, moduleId) {
+      globalObject.__resetModule(moduleId);
+    });
+  };
+})(
+  typeof globalThis !== 'undefined'
+    ? globalThis
+    : typeof global !== 'undefined'
+    ? global
+    : typeof window !== 'undefined'
+    ? window
+    : this
+);

package/dist/bundler/evaluate.js

@@ -12,7 +12,7 @@ export const evaluateModule = (moduleJs, modulePath) => {
     }
     const moduleId = Number(__rParam);
     // This is important as if module was already initialized, it would not be re-initialized
-    global.__clearModule(moduleId);
+    global.__resetModule(moduleId);
     // eslint-disable-next-line no-eval
     eval(moduleJs);
 };

package/dist/client/getWSServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getWSServer.d.ts","sourceRoot":"","sources":["../../src/client/getWSServer.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,QAAO,MAK9B,CAAC"}
+{"version":3,"file":"getWSServer.d.ts","sourceRoot":"","sources":["../../src/client/getWSServer.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,QAAO,MAM9B,CAAC"}

package/dist/client/getWSServer.js

@@ -3,5 +3,6 @@ import { WS_SERVER_PORT } from '../constants.js';
 export const getWSServer = () => {
     const devServerUrl = getDevServerUrl();
     const hostname = devServerUrl.split('://')[1].split(':')[0];
-    return `ws://${hostname}:${WS_SERVER_PORT}`;
+    const port = global.RN_HARNESS?.webSocketPort || WS_SERVER_PORT;
+    return `ws://${hostname}:${port}`;
 };

package/dist/client/store.d.ts

@@ -0,0 +1,4 @@
+import type { BridgeClient } from '@react-native-harness/bridge/client';
+export declare const setClient: (client: BridgeClient) => void;
+export declare const getClientInstance: () => BridgeClient;
+//# sourceMappingURL=store.d.ts.map

package/dist/client/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/client/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAIxE,eAAO,MAAM,SAAS,GAAI,QAAQ,YAAY,KAAG,IAEhD,CAAC;AAEF,eAAO,MAAM,iBAAiB,QAAO,YAOpC,CAAC"}

package/dist/client/store.js

@@ -0,0 +1,10 @@
+let clientInstance = null;
+export const setClient = (client) => {
+    clientInstance = client;
+};
+export const getClientInstance = () => {
+    if (!clientInstance) {
+        throw new Error('Bridge client not initialized. This should not happen in normal operation.');
+    }
+    return clientInstance;
+};

package/dist/disableHMRWhenReady.d.ts

@@ -0,0 +1,2 @@
+export declare function disableHMRWhenReady(disable: () => void, retriesLeft: number, retryDelay?: number): Promise<void>;
+//# sourceMappingURL=disableHMRWhenReady.d.ts.map

package/dist/disableHMRWhenReady.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disableHMRWhenReady.d.ts","sourceRoot":"","sources":["../src/disableHMRWhenReady.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,IAAI,EACnB,WAAW,EAAE,MAAM,EACnB,UAAU,SAAK,iBAuBhB"}

package/dist/disableHMRWhenReady.js

@@ -0,0 +1,20 @@
+export function disableHMRWhenReady(disable, retriesLeft, retryDelay = 10) {
+    return new Promise((resolve, reject) => {
+        function attempt(remaining) {
+            try {
+                disable();
+                resolve();
+            }
+            catch (error) {
+                if (remaining > 0 &&
+                    error instanceof Error &&
+                    error.message.includes('Expected HMRClient.setup() call at startup.')) {
+                    setTimeout(() => attempt(remaining - 1), retryDelay);
+                    return;
+                }
+                reject(error);
+            }
+        }
+        attempt(retriesLeft);
+    });
+}

package/dist/expect/expect.d.ts

@@ -0,0 +1,9 @@
+import type { ExpectStatic } from '@vitest/expect';
+import * as chai from 'chai';
+import './setup.js';
+export declare function createExpect(): ExpectStatic;
+declare const globalExpect: ExpectStatic;
+export { assert, should } from 'chai';
+export { chai, globalExpect as expect };
+export type { Assertion, AsymmetricMatchersContaining, DeeplyAllowMatchers, ExpectStatic, JestAssertion, Matchers, } from '@vitest/expect';
+//# sourceMappingURL=expect.d.ts.map

package/dist/expect/expect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../src/expect/expect.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAa,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAS5E,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAG7B,OAAO,YAAY,CAAC;AAGpB,wBAAgB,YAAY,IAAI,YAAY,CAwF3C;AAED,QAAA,MAAM,YAAY,EAAE,YAA6B,CAAC;AAQlD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,YAAY,IAAI,MAAM,EAAE,CAAC;AAExC,YAAY,EACV,SAAS,EACT,4BAA4B,EAC5B,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,QAAQ,GACT,MAAM,gBAAgB,CAAC"}

package/dist/expect/expect.js

@@ -0,0 +1,77 @@
+// This is adapted version of https://github.com/vitest-dev/vitest/blob/main/packages/vitest/src/integrations/chai/index.ts
+// Credits to Vitest team for the original implementation.
+import { addCustomEqualityTesters, ASYMMETRIC_MATCHERS_OBJECT, customMatchers, getState, GLOBAL_EXPECT, setState, } from '@vitest/expect';
+import * as chai from 'chai';
+// Setup additional matchers
+import './setup.js';
+import { toMatchImageSnapshot } from './matchers/toMatchImageSnapshot.js';
+export function createExpect() {
+    const expect = ((value, message) => {
+        const { assertionCalls } = getState(expect);
+        setState({ assertionCalls: assertionCalls + 1 }, expect);
+        return chai.expect(value, message);
+    });
+    Object.assign(expect, chai.expect);
+    Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
+    expect.getState = () => getState(expect);
+    expect.setState = (state) => setState(state, expect);
+    // @ts-expect-error global is not typed
+    const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
+    setState({
+        // this should also add "snapshotState" that is added conditionally
+        ...globalState,
+        assertionCalls: 0,
+        isExpectingAssertions: false,
+        isExpectingAssertionsError: null,
+        expectedAssertionsNumber: null,
+        expectedAssertionsNumberErrorGen: null,
+    }, expect);
+    // @ts-expect-error untyped
+    expect.extend = (matchers) => chai.expect.extend(expect, matchers);
+    // @ts-expect-error untyped
+    expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
+    // @ts-expect-error untyped
+    expect.soft = (...args) => {
+        // @ts-expect-error private soft access
+        return expect(...args).withContext({ soft: true });
+    };
+    // @ts-expect-error untyped
+    expect.unreachable = (message) => {
+        chai.assert.fail(`expected${message ? ` "${message}" ` : ' '}not to be reached`);
+    };
+    function assertions(expected) {
+        const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(errorGen(), assertions);
+        }
+        expect.setState({
+            expectedAssertionsNumber: expected,
+            expectedAssertionsNumberErrorGen: errorGen,
+        });
+    }
+    function hasAssertions() {
+        const error = new Error('expected any number of assertion, but got none');
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(error, hasAssertions);
+        }
+        expect.setState({
+            isExpectingAssertions: true,
+            isExpectingAssertionsError: error,
+        });
+    }
+    chai.util.addMethod(expect, 'assertions', assertions);
+    chai.util.addMethod(expect, 'hasAssertions', hasAssertions);
+    expect.extend(customMatchers);
+    expect.extend({
+        toMatchImageSnapshot,
+    });
+    return expect;
+}
+const globalExpect = createExpect();
+Object.defineProperty(globalThis, GLOBAL_EXPECT, {
+    value: globalExpect,
+    writable: true,
+    configurable: true,
+});
+export { assert, should } from 'chai';
+export { chai, globalExpect as expect };

package/dist/expect/matchers/toMatchImageSnapshot.d.ts

@@ -0,0 +1,12 @@
+import type { MatcherState } from '@vitest/expect';
+import type { FileReference, ImageSnapshotOptions } from '@react-native-harness/bridge';
+declare module '@vitest/expect' {
+    interface Matchers {
+        toMatchImageSnapshot(options: ImageSnapshotOptions): Promise<void>;
+    }
+}
+export declare function toMatchImageSnapshot(this: MatcherState, received: FileReference, options: ImageSnapshotOptions): Promise<{
+    pass: boolean;
+    message: () => string;
+}>;
+//# sourceMappingURL=toMatchImageSnapshot.d.ts.map

package/dist/expect/matchers/toMatchImageSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toMatchImageSnapshot.d.ts","sourceRoot":"","sources":["../../../src/expect/matchers/toMatchImageSnapshot.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EACV,aAAa,EACb,oBAAoB,EACrB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,QAAQ,gBAAgB,CAAC;IAC9B,UAAU,QAAQ;QAChB,oBAAoB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KACpE;CACF;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,MAAM,CAAA;CAAE,CAAC,CAcnD"}

package/dist/expect/matchers/toMatchImageSnapshot.js

@@ -0,0 +1,11 @@
+import { getClientInstance } from '../../client/store.js';
+import { getHarnessContext } from '../../runner/index.js';
+export async function toMatchImageSnapshot(received, options) {
+    const client = getClientInstance();
+    const context = getHarnessContext();
+    const result = await client.rpc['test.matchImageSnapshot'](received, context.testFilePath, options, context.runner);
+    return {
+        pass: result.pass,
+        message: () => result.message,
+    };
+}

package/dist/globals.d.ts

@@ -1,5 +1,6 @@
 export type HarnessGlobal = {
     appRegistryComponentName: string;
+    webSocketPort?: number;
 };
 declare global {
     var RN_HARNESS: HarnessGlobal | undefined;

package/dist/globals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../src/globals.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAC1B,wBAAwB,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,UAAU,EAAE,aAAa,GAAG,SAAS,CAAC;CAC3C;AAED,eAAO,MAAM,gBAAgB,QAAO,aAQnC,CAAC"}
+{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../src/globals.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG;IAC1B,wBAAwB,EAAE,MAAM,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,UAAU,EAAE,aAAa,GAAG,SAAS,CAAC;CAC3C;AAED,eAAO,MAAM,gBAAgB,QAAO,aAQnC,CAAC"}

package/dist/initialize.js

@@ -1,5 +1,6 @@
 import { getDeviceDescriptor } from './client/getDeviceDescriptor.js';
 import { getClient } from './client/index.js';
+import { disableHMRWhenReady } from './disableHMRWhenReady.js';
 import { setupJestMock } from './jest-mock.js';
 // Polyfill for EventTarget
 const Shim = require('event-target-shim');
@@ -15,9 +16,7 @@ const HMRClientModule = require('react-native/Libraries/Utilities/HMRClient');
 const HMRClient = 'default' in HMRClientModule ? HMRClientModule.default : HMRClientModule;
 // Wait for HMRClient to be initialized
 setTimeout(() => {
-    HMRClient.disable();
-    // Initialize the React Native Harness
-    void getClient().then((client) => client.rpc.reportReady(getDeviceDescriptor()));
+    void disableHMRWhenReady(() => HMRClient.disable(), 50).then(() => getClient().then((client) => client.rpc.reportReady(getDeviceDescriptor())));
 });
 // Re-throw fatal errors
 ErrorUtils.setGlobalHandler((error) => {

package/dist/mocker/index.d.ts

@@ -1,2 +1,2 @@
-export { mock, requireActual, clearMocks, unmock, resetModules, } from './registry.js';
+export { mock, requireActual, unmock, resetModules, } from './registry.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/mocker/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mocker/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,aAAa,EACb,UAAU,EACV,MAAM,EACN,YAAY,GACb,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mocker/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,aAAa,EACb,MAAM,EACN,YAAY,GACb,MAAM,eAAe,CAAC"}

package/dist/mocker/index.js

@@ -1 +1 @@
-export { mock, requireActual, clearMocks, unmock, resetModules, } from './registry.js';
+export { mock, requireActual, unmock, resetModules, } from './registry.js';

package/dist/mocker/registry.d.ts

@@ -1,6 +1,5 @@
 import { ModuleFactory } from './types.js';
 export declare const mock: (moduleId: string, factory: ModuleFactory) => void;
-export declare const clearMocks: () => void;
 export declare const requireActual: <T = any>(moduleId: string) => T;
 export declare const unmock: (moduleId: string) => void;
 export declare const resetModules: () => void;

package/dist/mocker/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/mocker/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAqB,MAAM,YAAY,CAAC;AAO9D,eAAO,MAAM,IAAI,GAAI,UAAU,MAAM,EAAE,SAAS,aAAa,KAAG,IAG/D,CAAC;AAEF,eAAO,MAAM,UAAU,QAAO,IAG7B,CAAC;AAkBF,eAAO,MAAM,aAAa,GAAI,CAAC,GAAG,GAAG,EAAE,UAAU,MAAM,KAAG,CAEH,CAAC;AAExD,eAAO,MAAM,MAAM,GAAI,UAAU,MAAM,SAGtC,CAAC;AAEF,eAAO,MAAM,YAAY,QAAO,IAK/B,CAAC"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/mocker/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAqB,MAAM,YAAY,CAAC;AAO9D,eAAO,MAAM,IAAI,GAAI,UAAU,MAAM,EAAE,SAAS,aAAa,KAAG,IAG/D,CAAC;AAmBF,eAAO,MAAM,aAAa,GAAI,CAAC,GAAG,GAAG,EAAE,UAAU,MAAM,KAAG,CAEH,CAAC;AAExD,eAAO,MAAM,MAAM,GAAI,UAAU,MAAM,SAGtC,CAAC;AAEF,eAAO,MAAM,YAAY,QAAO,IAG/B,CAAC"}

package/dist/mocker/registry.js

@@ -1,24 +1,20 @@
+const modulesCache = new Map();
 const mockRegistry = new Map();
-const mockCache = new Map();
 const originalRequire = global.__r;
 export const mock = (moduleId, factory) => {
-    mockCache.delete(moduleId);
+    modulesCache.delete(moduleId);
     mockRegistry.set(moduleId, factory);
 };
-export const clearMocks = () => {
-    mockRegistry.clear();
-    mockCache.clear();
+const isModuleMocked = (moduleId) => {
+    return mockRegistry.has(moduleId);
 };
 const getMockImplementation = (moduleId) => {
-    if (mockCache.has(moduleId)) {
-        return mockCache.get(moduleId);
-    }
     const factory = mockRegistry.get(moduleId);
     if (!factory) {
         return null;
     }
     const implementation = factory();
-    mockCache.set(moduleId, implementation);
+    modulesCache.set(moduleId, implementation);
     return implementation;
 };
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -27,20 +23,27 @@ export const requireActual = (moduleId) =>
 originalRequire(moduleId);
 export const unmock = (moduleId) => {
     mockRegistry.delete(moduleId);
-    mockCache.delete(moduleId);
+    modulesCache.delete(moduleId);
 };
 export const resetModules = () => {
-    mockCache.clear();
-    // Reset Metro's module cache
-    global.__resetAllModules();
+    modulesCache.clear();
+    mockRegistry.clear();
 };
 const mockRequire = (moduleId) => {
     // babel plugin will transform 'moduleId' to a number
-    const mockedModule = getMockImplementation(moduleId);
-    if (mockedModule) {
+    const moduleIdNumber = moduleId;
+    const cachedModule = modulesCache.get(moduleIdNumber);
+    if (cachedModule) {
+        return cachedModule;
+    }
+    if (isModuleMocked(moduleIdNumber)) {
+        const mockedModule = getMockImplementation(moduleIdNumber);
+        modulesCache.set(moduleIdNumber, mockedModule);
         return mockedModule;
     }
-    return originalRequire(moduleId);
+    const originalModule = originalRequire(moduleIdNumber);
+    modulesCache.set(moduleIdNumber, originalModule);
+    return originalModule;
 };
 Object.setPrototypeOf(mockRequire, Object.getPrototypeOf(originalRequire));
 Object.defineProperties(mockRequire, Object.getOwnPropertyDescriptors(originalRequire));

package/dist/render/queries.d.ts

@@ -0,0 +1,7 @@
+import { HostInstance } from 'react-native';
+export declare const setRoot: (rootInstance: HostInstance) => void;
+declare const queryByTestId: (params: string) => import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default | null, queryAllByTestId: (params: string) => import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default[], getByTestId: (params: string) => import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default | null, getAllByTestId: (params: string) => import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default[], findByTestId: (params: string) => Promise<import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default>, findAllByTestId: (params: string) => Promise<import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default[]>;
+declare const queryById: (params: string) => import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default | null, queryAllById: (params: string) => import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default[], getId: (params: string) => import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default | null, getAllById: (params: string) => import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default[], findById: (params: string) => Promise<import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default>, findAllById: (params: string) => Promise<import("react-native/types_generated/src/private/webapis/dom/nodes/ReactNativeElement").default[]>;
+export { queryByTestId, queryAllByTestId, getByTestId, getAllByTestId, findByTestId, findAllByTestId, };
+export { queryById, queryAllById, getId, getAllById, findById, findAllById };
+//# sourceMappingURL=queries.d.ts.map

package/dist/render/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../src/render/queries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAM5C,eAAO,MAAM,OAAO,GAAI,cAAc,YAAY,SAEjD,CAAC;AA6IF,QAAA,MACW,aAAa,8HACV,gBAAgB,yHACrB,WAAW,8HACR,cAAc,yHAChB,YAAY,gIACT,eAAe,gIAG3B,CAAC;AACF,QAAA,MACW,SAAS,8HACN,YAAY,yHACjB,KAAK,8HACF,UAAU,yHACZ,QAAQ,gIACL,WAAW,gIAC+B,CAAC;AAExD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,YAAY,EACZ,eAAe,GAChB,CAAC;AAEF,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC"}

package/dist/render/queries.js

@@ -0,0 +1,99 @@
+// import { store } from '../ui/state.js';
+import { waitUntil } from '../waitFor.js';
+let root = null;
+export const setRoot = (rootInstance) => {
+    root = rootInstance;
+};
+const getRoot = () => {
+    const container = root;
+    if (!container) {
+        throw new Error('You need to render a component first!');
+    }
+    const ownerDocument = container.ownerDocument;
+    if (!ownerDocument) {
+        throw new Error('This feature is supported in React Native 0.82 and later!');
+    }
+    return ownerDocument.getRootNode();
+};
+const findNodeByPredicate = (predicate) => {
+    const queue = [getRoot()];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (predicate(node)) {
+            return node;
+        }
+        for (const child of node.children) {
+            queue.push(child);
+        }
+    }
+    return null;
+};
+const findNodesByPredicate = (predicate) => {
+    const nodes = [];
+    const queue = [getRoot()];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (predicate(node)) {
+            nodes.push(node);
+        }
+        for (const child of node.children) {
+            queue.push(child);
+        }
+    }
+    return nodes;
+};
+const getFiberOfHostInstance = (hostInstance) => {
+    // This should be considered as 'reaching into the implementation details' of React Native.
+    // Not perfect, but it's the only way to get the props of the host instance.
+    return (hostInstance
+        .__internalInstanceHandle || null);
+};
+const getPropsOfHostInstance = (hostInstance) => {
+    return getFiberOfHostInstance(hostInstance)?.memoizedProps || {};
+};
+const findBy = (predicate, options) => {
+    return waitUntil(() => findNodeByPredicate(predicate), options);
+};
+const findAllBy = (predicate, options) => {
+    return waitUntil(() => {
+        const nodes = findNodesByPredicate(predicate);
+        if (nodes.length === 0) {
+            return null;
+        }
+        return nodes;
+    }, options);
+};
+const queryBy = (predicate) => {
+    return findNodeByPredicate(predicate);
+};
+const queryAllBy = (predicate) => {
+    return findNodesByPredicate(predicate);
+};
+const getBy = (predicate) => {
+    const node = queryBy(predicate);
+    if (!node) {
+        throw new Error(`No node found with predicate ${predicate}`);
+    }
+    return node;
+};
+const getAllBy = (predicate) => {
+    const nodes = queryAllBy(predicate);
+    if (nodes.length === 0) {
+        throw new Error(`No nodes found with predicate ${predicate}`);
+    }
+    return nodes;
+};
+const createQueries = (predicate) => {
+    return {
+        findBy: (params) => findBy((node) => predicate(node, params)),
+        findAllBy: (params) => findAllBy((node) => predicate(node, params)),
+        queryBy: (params) => queryBy((node) => predicate(node, params)),
+        queryAllBy: (params) => queryAllBy((node) => predicate(node, params)),
+        getBy: (params) => getBy((node) => predicate(node, params)),
+        getAllBy: (params) => getAllBy((node) => predicate(node, params)),
+    };
+};
+const { queryBy: queryByTestId, queryAllBy: queryAllByTestId, getBy: getByTestId, getAllBy: getAllByTestId, findBy: findByTestId, findAllBy: findAllByTestId, } = createQueries((node, testId) => getPropsOfHostInstance(node).testID === testId);
+const { queryBy: queryById, queryAllBy: queryAllById, getBy: getId, getAllBy: getAllById, findBy: findById, findAllBy: findAllById, } = createQueries((node, id) => node.id === id);
+export { queryByTestId, queryAllByTestId, getByTestId, getAllByTestId, findByTestId, findAllByTestId, };
+export { queryById, queryAllById, getId, getAllById, findById, findAllById };

package/dist/runner/context.d.ts

@@ -0,0 +1,10 @@
+export type HarnessContext = {
+    testFilePath: string;
+    runner: string;
+};
+declare global {
+    var HARNESS_CONTEXT: HarnessContext;
+}
+export declare const getHarnessContext: () => HarnessContext;
+export declare const setHarnessContext: (context: HarnessContext) => void;
+//# sourceMappingURL=context.d.ts.map

package/dist/runner/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/runner/context.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,eAAe,EAAE,cAAc,CAAC;CACrC;AAED,eAAO,MAAM,iBAAiB,QAAO,cAEpC,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,SAAS,cAAc,KAAG,IAE3D,CAAC"}

package/dist/runner/context.js

@@ -0,0 +1,6 @@
+export const getHarnessContext = () => {
+    return globalThis['HARNESS_CONTEXT'];
+};
+export const setHarnessContext = (context) => {
+    globalThis['HARNESS_CONTEXT'] = context;
+};

package/dist/screen/index.d.ts

@@ -0,0 +1,8 @@
+import type { ElementReference, FileReference } from '@react-native-harness/bridge';
+export type Screen = {
+    findByTestId: (testId: string) => Promise<ElementReference>;
+    findAllByTestId: (testId: string) => Promise<ElementReference[]>;
+    screenshot: (name?: string) => Promise<FileReference>;
+};
+export declare const screen: Screen;
+//# sourceMappingURL=index.d.ts.map

package/dist/screen/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/screen/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,8BAA8B,CAAC;AAGtC,MAAM,MAAM,MAAM,GAAG;IACnB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC5D,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IACjE,UAAU,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;CACvD,CAAC;AAmBF,eAAO,MAAM,MAAM,QAAiB,CAAC"}

package/dist/screen/index.js

@@ -0,0 +1,18 @@
+import { getClientInstance } from '../client/store.js';
+const createScreen = () => {
+    return {
+        findByTestId: async (testId) => {
+            const client = getClientInstance();
+            return await client.rpc['platform.queries.findByTestId'](testId);
+        },
+        findAllByTestId: async (testId) => {
+            const client = getClientInstance();
+            return await client.rpc['platform.queries.findAllByTestId'](testId);
+        },
+        screenshot: async () => {
+            const client = getClientInstance();
+            return await client.rpc['platform.actions.screenshot']();
+        },
+    };
+};
+export const screen = createScreen();