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

package/dist/render/cleanup.js

@@ -0,0 +1,6 @@
+import { store } from '../ui/state.js';
+export const cleanup = () => {
+    store.getState().setRenderedElement(null);
+    store.getState().setOnLayoutCallback(null);
+    store.getState().setOnRenderCallback(null);
+};

package/dist/render/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { RenderResult, RenderOptions } from './types.js';
+export declare const render: (element: React.ReactElement, options?: RenderOptions) => Promise<RenderResult>;
+export { cleanup } from './cleanup.js';
+export type { RenderResult, RenderOptions } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/render/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAY9D,eAAO,MAAM,MAAM,GACjB,SAAS,KAAK,CAAC,YAAY,EAC3B,UAAS,aAAkB,KAC1B,OAAO,CAAC,YAAY,CA2EtB,CAAC;AAEF,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/render/index.js

@@ -0,0 +1,66 @@
+import React from 'react';
+import { store } from '../ui/state.js';
+const wrapElement = (element, wrapper) => {
+    if (!wrapper) {
+        return element;
+    }
+    return React.createElement(wrapper, { children: element });
+};
+export const render = async (element, options = {}) => {
+    const { timeout = 1000, wrapper } = options;
+    // If an element is already rendered, unmount it first
+    if (store.getState().renderedElement !== null) {
+        store.getState().setRenderedElement(null);
+        store.getState().setOnLayoutCallback(null);
+        store.getState().setOnRenderCallback(null);
+    }
+    // Create a promise that resolves when the element is laid out
+    const layoutPromise = new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            store.getState().setOnLayoutCallback(null);
+            reject(new Error(`Render timeout: Element did not mount within ${timeout}ms`));
+        }, timeout);
+        store.getState().setOnLayoutCallback(() => {
+            clearTimeout(timeoutId);
+            resolve();
+        });
+    });
+    // Wrap and set the element in state (key is generated automatically)
+    const wrappedElement = wrapElement(element, wrapper);
+    store.getState().setRenderedElement(wrappedElement);
+    // Wait for layout
+    await layoutPromise;
+    const rerender = async (newElement) => {
+        if (store.getState().renderedElement === null) {
+            throw new Error('No element is currently rendered. Call render() first.');
+        }
+        // Create a promise that resolves when the element is re-rendered
+        const renderPromise = new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                store.getState().setOnRenderCallback(null);
+                reject(new Error(`Rerender timeout: Element did not update within ${timeout}ms`));
+            }, timeout);
+            store.getState().setOnRenderCallback(() => {
+                clearTimeout(timeoutId);
+                resolve();
+            });
+        });
+        const wrappedNewElement = wrapElement(newElement, wrapper);
+        store.getState().updateRenderedElement(wrappedNewElement);
+        // Wait for render
+        await renderPromise;
+    };
+    const unmount = () => {
+        if (store.getState().renderedElement === null) {
+            return;
+        }
+        store.getState().setRenderedElement(null);
+        store.getState().setOnLayoutCallback(null);
+        store.getState().setOnRenderCallback(null);
+    };
+    return {
+        rerender,
+        unmount,
+    };
+};
+export { cleanup } from './cleanup.js';

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/render/setup.d.ts

@@ -0,0 +1,2 @@
+export declare const setup: () => void;
+//# sourceMappingURL=setup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/render/setup.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK,YAIjB,CAAC"}

package/dist/render/setup.js

@@ -0,0 +1,7 @@
+import { afterEach } from '../collector/functions.js';
+import { cleanup } from './cleanup.js';
+export const setup = () => {
+    afterEach(() => {
+        cleanup();
+    });
+};

package/dist/render/types.d.ts

@@ -0,0 +1,12 @@
+import type React from 'react';
+export type RenderResult = {
+    rerender: (element: React.ReactElement) => Promise<void>;
+    unmount: () => void;
+};
+export type RenderOptions = {
+    timeout?: number;
+    wrapper?: React.ComponentType<{
+        children: React.ReactNode;
+    }>;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/render/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAC;CAC9D,CAAC"}

package/dist/render/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,9 +1,11 @@
-import type { SerializedError } from '@react-native-harness/bridge';
+import type { SerializedError, CodeFrame } from '@react-native-harness/bridge';
 export declare class TestExecutionError extends Error {
     file: string;
     suite: string;
     test: string;
-    constructor(error: unknown, file: string, suite: string, test: string);
+    codeFrame?: CodeFrame;
+    constructor(error: unknown, file: string, suite: string, test: string, codeFrame?: CodeFrame);
     toSerializedJSON(): SerializedError;
 }
+export declare const getTestExecutionError: (error: unknown, file: string, suite: string, test: string) => Promise<TestExecutionError>;
 //# sourceMappingURL=errors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runner/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;gBAED,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IASrE,gBAAgB,IAAI,eAAe;CAcpC"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runner/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG/E,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,SAAS,CAAC;gBAGpB,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,SAAS;IAWvB,gBAAgB,IAAI,eAAe;CAapC;AAED,eAAO,MAAM,qBAAqB,GAChC,OAAO,OAAO,EACd,MAAM,MAAM,EACZ,OAAO,MAAM,EACb,MAAM,MAAM,KACX,OAAO,CAAC,kBAAkB,CAe5B,CAAC"}

package/dist/runner/errors.js

@@ -1,23 +1,41 @@
+import { getCodeFrame } from '../symbolicate.js';
 export class TestExecutionError extends Error {
     file;
     suite;
     test;
-    constructor(error, file, suite, test) {
+    codeFrame;
+    constructor(error, file, suite, test, codeFrame) {
         super('Test execution error');
         this.name = 'TestExecutionError';
         this.file = file;
         this.suite = suite;
         this.test = test;
         this.cause = error;
+        this.codeFrame = codeFrame;
     }
     toSerializedJSON() {
         const causeName = this.cause instanceof Error ? this.cause.name : 'Unknown name';
         const causeMessage = this.cause instanceof Error ? this.cause.message : 'Unknown message';
-        const causeStack = this.cause instanceof Error ? this.cause.stack : undefined;
+        const causeCodeFrame = this.codeFrame;
         return {
             name: causeName,
             message: causeMessage,
-            stack: causeStack,
+            codeFrame: causeCodeFrame,
         };
     }
 }
+export const getTestExecutionError = async (error, file, suite, test) => {
+    try {
+        if (error instanceof Error) {
+            const codeFrame = await getCodeFrame(error);
+            if (codeFrame) {
+                return new TestExecutionError(error, file, suite, test, codeFrame);
+            }
+        }
+        return new TestExecutionError(error, file, suite, test);
+    }
+    catch (error) {
+        // If the stack cannot be symbolicated, return the original error
+        return new TestExecutionError(error, file, suite, test);
+    }
+};

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/runner/factory.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,eAAO,MAAM,aAAa,QAAO,UAehC,CAAC"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/runner/factory.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,eAAO,MAAM,aAAa,QAAO,UAsBhC,CAAC"}

package/dist/runner/factory.js

@@ -5,10 +5,15 @@ export const getTestRunner = () => {
     return {
         events,
         run: async (testSuite, testFilePath) => {
-            return runSuite(testSuite, {
+            const result = await runSuite(testSuite, {
                 events,
                 testFilePath,
             });
+            // If coverage is enabled, there will be a global variable called __coverage__
+            if ('__coverage__' in global && !!global.__coverage__) {
+                result.coverage = global.__coverage__;
+            }
+            return result;
         },
         dispose: () => {
             events.clearAllListeners();

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

@@ -1 +1 @@
-{"version":3,"file":"runSuite.d.ts","sourceRoot":"","sources":["../../src/runner/runSuite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,SAAS,EACT,eAAe,EAChB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAsH/C,eAAO,MAAM,QAAQ,GACnB,OAAO,SAAS,EAChB,SAAS,iBAAiB,KACzB,OAAO,CAAC,eAAe,CAuEzB,CAAC"}
+{"version":3,"file":"runSuite.d.ts","sourceRoot":"","sources":["../../src/runner/runSuite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,SAAS,EACT,eAAe,EAChB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAsH/C,eAAO,MAAM,QAAQ,GACnB,OAAO,SAAS,EAChB,SAAS,iBAAiB,KACzB,OAAO,CAAC,eAAe,CAoIzB,CAAC"}

package/dist/runner/runSuite.js

@@ -1,5 +1,5 @@
 import { runHooks } from './hooks.js';
-import { TestExecutionError } from './errors.js';
+import { getTestExecutionError } from './errors.js';
 const runTest = async (test, suite, context) => {
     const startTime = Date.now();
     // Emit test-started event
@@ -69,7 +69,7 @@ const runTest = async (test, suite, context) => {
         return result;
     }
     catch (error) {
-        const testError = new TestExecutionError(error, context.testFilePath, suite.name, test.name);
+        const testError = await getTestExecutionError(error, context.testFilePath, suite.name, test.name);
         const duration = Date.now() - startTime;
         const result = {
             name: test.name,
@@ -98,6 +98,43 @@ export const runSuite = async (suite, context) => {
         name: suite.name,
         file: context.testFilePath,
     });
+    // Check if suite should be skipped or is todo
+    if (suite.status === 'skipped') {
+        const result = {
+            name: suite.name,
+            tests: [],
+            suites: [],
+            status: 'skipped',
+            duration: 0,
+        };
+        // Emit suite-finished event
+        context.events.emit({
+            type: 'suite-finished',
+            file: context.testFilePath,
+            name: suite.name,
+            duration: 0,
+            status: 'skipped',
+        });
+        return result;
+    }
+    if (suite.status === 'todo') {
+        const result = {
+            name: suite.name,
+            tests: [],
+            suites: [],
+            status: 'todo',
+            duration: 0,
+        };
+        // Emit suite-finished event
+        context.events.emit({
+            type: 'suite-finished',
+            file: context.testFilePath,
+            name: suite.name,
+            duration: 0,
+            status: 'todo',
+        });
+        return result;
+    }
     const testResults = [];
     const suiteResults = [];
     // Run beforeAll hooks
@@ -123,11 +160,26 @@ export const runSuite = async (suite, context) => {
     if (hasFailedTests || hasFailedSuites) {
         status = 'failed';
     }
-    else if ((testResults.every((result) => result.status === 'skipped') &&
-        suiteResults.every((result) => result.status === 'skipped') &&
-        testResults.length > 0) ||
-        suiteResults.length > 0) {
-        status = 'skipped';
+    else {
+        // Check if all tests and suites are skipped (and there are some tests/suites to check)
+        const allTestsSkipped = testResults.length > 0 &&
+            testResults.every((result) => result.status === 'skipped');
+        const allSuitesSkipped = suiteResults.length > 0 &&
+            suiteResults.every((result) => result.status === 'skipped');
+        const hasAnyContent = testResults.length > 0 || suiteResults.length > 0;
+        if (hasAnyContent &&
+            ((testResults.length > 0 &&
+                allTestsSkipped &&
+                suiteResults.length === 0) ||
+                (suiteResults.length > 0 &&
+                    allSuitesSkipped &&
+                    testResults.length === 0) ||
+                (testResults.length > 0 &&
+                    suiteResults.length > 0 &&
+                    allTestsSkipped &&
+                    allSuitesSkipped))) {
+            status = 'skipped';
+        }
     }
     // Emit suite-finished event
     context.events.emit({

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();

package/dist/symbolicate.d.ts

@@ -0,0 +1,3 @@
+import type { CodeFrame } from '@react-native-harness/bridge';
+export declare const getCodeFrame: (error: Error) => Promise<CodeFrame | null>;
+//# sourceMappingURL=symbolicate.d.ts.map

package/dist/symbolicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbolicate.d.ts","sourceRoot":"","sources":["../src/symbolicate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAI9D,eAAO,MAAM,YAAY,GAAU,OAAO,KAAK,KAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAmBzE,CAAC"}

package/dist/symbolicate.js

@@ -0,0 +1,19 @@
+import parseErrorStack from 'react-native/Libraries/Core/Devtools/parseErrorStack';
+import symbolicateStackTrace from 'react-native/Libraries/Core/Devtools/symbolicateStackTrace';
+export const getCodeFrame = async (error) => {
+    const parsedStack = parseErrorStack(error.stack);
+    const symbolicatedStack = await symbolicateStackTrace(parsedStack);
+    if (!('codeFrame' in symbolicatedStack) || !symbolicatedStack.codeFrame) {
+        return null;
+    }
+    const codeFrame = symbolicatedStack.codeFrame;
+    // Normalize optionality (null -> undefined)
+    return {
+        ...codeFrame,
+        location: codeFrame.location
+            ? {
+                ...codeFrame.location,
+            }
+            : undefined,
+    };
+};