@react-native-harness/runtime 1.0.0-alpha.1

package/dist/runner/hooks.js

@@ -0,0 +1,39 @@
+const collectInheritedHooks = (suite, hookType) => {
+    const hooks = [];
+    const suiteChain = [];
+    // Collect all suites from current to root
+    let currentSuite = suite;
+    while (currentSuite) {
+        suiteChain.push(currentSuite);
+        currentSuite = currentSuite.parent;
+    }
+    if (hookType === 'beforeEach' || hookType === 'beforeAll') {
+        // For beforeEach/beforeAll: run parent hooks first (reverse the chain)
+        for (let i = suiteChain.length - 1; i >= 0; i--) {
+            if (hookType === 'beforeEach') {
+                hooks.push(...suiteChain[i].beforeEach);
+            }
+            else {
+                hooks.push(...suiteChain[i].beforeAll);
+            }
+        }
+    }
+    else {
+        // For afterEach/afterAll: run child hooks first (use chain as-is)
+        for (const suiteInChain of suiteChain) {
+            if (hookType === 'afterEach') {
+                hooks.push(...suiteInChain.afterEach);
+            }
+            else {
+                hooks.push(...suiteInChain.afterAll);
+            }
+        }
+    }
+    return hooks;
+};
+export const runHooks = async (suite, hookType) => {
+    const hooks = collectInheritedHooks(suite, hookType);
+    for (const hook of hooks) {
+        await hook();
+    }
+};

package/dist/runner/index.d.ts

@@ -0,0 +1,4 @@
+export type { TestRunnerEventsEmitter, TestRunner, TestRunnerContext, } from './types.js';
+export { TestExecutionError } from './errors.js';
+export { getTestRunner } from './factory.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runner/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,uBAAuB,EACvB,UAAU,EACV,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/runner/index.js

@@ -0,0 +1,2 @@
+export { TestExecutionError } from './errors.js';
+export { getTestRunner } from './factory.js';

package/dist/runner/runSuite.d.ts

@@ -0,0 +1,4 @@
+import type { TestSuite, TestSuiteResult } from '@react-native-harness/bridge';
+import { TestRunnerContext } from './types.js';
+export declare const runSuite: (suite: TestSuite, context: TestRunnerContext) => Promise<TestSuiteResult>;
+//# sourceMappingURL=runSuite.d.ts.map

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

@@ -0,0 +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"}

package/dist/runner/runSuite.js

@@ -0,0 +1,147 @@
+import { runHooks } from './hooks.js';
+import { TestExecutionError } from './errors.js';
+const runTest = async (test, suite, context) => {
+    const startTime = Date.now();
+    // Emit test-started event
+    context.events.emit({
+        type: 'test-started',
+        name: test.name,
+        suite: suite.name,
+        file: context.testFilePath,
+    });
+    try {
+        if (test.status === 'skipped') {
+            const result = {
+                name: test.name,
+                status: 'skipped',
+                duration: 0,
+            };
+            // Emit test-finished event
+            context.events.emit({
+                type: 'test-finished',
+                name: test.name,
+                suite: suite.name,
+                file: context.testFilePath,
+                duration: 0,
+                status: 'skipped',
+            });
+            return result;
+        }
+        if (test.status === 'todo') {
+            console.log(`- ${test.name} (todo)`);
+            const result = {
+                name: test.name,
+                status: 'todo',
+                duration: 0,
+            };
+            // Emit test-finished event
+            context.events.emit({
+                type: 'test-finished',
+                name: test.name,
+                suite: suite.name,
+                file: context.testFilePath,
+                duration: 0,
+                status: 'todo',
+            });
+            return result;
+        }
+        // Run all beforeEach hooks from the current suite and its parents
+        await runHooks(suite, 'beforeEach');
+        // Run the actual test
+        await test.fn();
+        // Run all afterEach hooks from the current suite and its parents
+        await runHooks(suite, 'afterEach');
+        const duration = Date.now() - startTime;
+        const result = {
+            name: test.name,
+            status: 'passed',
+            duration,
+        };
+        // Emit test-finished event
+        context.events.emit({
+            type: 'test-finished',
+            file: context.testFilePath,
+            suite: suite.name,
+            name: test.name,
+            duration,
+            status: 'passed',
+        });
+        return result;
+    }
+    catch (error) {
+        const testError = new TestExecutionError(error, context.testFilePath, suite.name, test.name);
+        const duration = Date.now() - startTime;
+        const result = {
+            name: test.name,
+            status: 'failed',
+            error: testError.toSerializedJSON(),
+            duration,
+        };
+        // Emit test-finished event
+        context.events.emit({
+            type: 'test-finished',
+            file: context.testFilePath,
+            suite: suite.name,
+            name: test.name,
+            duration,
+            error: testError.toSerializedJSON(),
+            status: 'failed',
+        });
+        return result;
+    }
+};
+export const runSuite = async (suite, context) => {
+    const startTime = Date.now();
+    // Emit suite-started event
+    context.events.emit({
+        type: 'suite-started',
+        name: suite.name,
+        file: context.testFilePath,
+    });
+    const testResults = [];
+    const suiteResults = [];
+    // Run beforeAll hooks
+    await runHooks(suite, 'beforeAll');
+    // Run all tests in the current suite
+    for (const test of suite.tests) {
+        const result = await runTest(test, suite, context);
+        testResults.push(result);
+    }
+    // Run all child suites
+    for (const childSuite of suite.suites) {
+        const result = await runSuite(childSuite, context);
+        suiteResults.push(result);
+    }
+    // Run afterAll hooks
+    await runHooks(suite, 'afterAll');
+    const duration = Date.now() - startTime;
+    // Determine overall suite status
+    let status = 'passed';
+    // Check if any tests or child suites failed
+    const hasFailedTests = testResults.some((result) => result.status === 'failed');
+    const hasFailedSuites = suiteResults.some((result) => result.status === 'failed');
+    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';
+    }
+    // Emit suite-finished event
+    context.events.emit({
+        type: 'suite-finished',
+        file: context.testFilePath,
+        name: suite.name,
+        duration,
+        status,
+    });
+    return {
+        name: suite.name,
+        tests: testResults,
+        suites: suiteResults,
+        status,
+        duration,
+    };
+};

package/dist/runner/types.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from '../utils/emitter.js';
+import type { TestRunnerEvents, TestSuite, TestSuiteResult } from '@react-native-harness/bridge';
+export type TestRunnerEventsEmitter = EventEmitter<TestRunnerEvents>;
+export type TestRunnerContext = {
+    events: TestRunnerEventsEmitter;
+    testFilePath: string;
+};
+export type TestRunner = {
+    events: TestRunnerEventsEmitter;
+    run: (testSuite: TestSuite, testFilePath: string) => Promise<TestSuiteResult>;
+    dispose: () => void;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/runner/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EACV,gBAAgB,EAChB,SAAS,EACT,eAAe,EAChB,MAAM,8BAA8B,CAAC;AAEtC,MAAM,MAAM,uBAAuB,GAAG,YAAY,CAAC,gBAAgB,CAAC,CAAC;AAErE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,uBAAuB,CAAC;IAChC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,uBAAuB,CAAC;IAChC,GAAG,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IAC9E,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC"}

package/dist/runner/types.js

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

package/dist/runner.d.ts

@@ -0,0 +1,7 @@
+import type { TestSuite } from './collector/index.js';
+import type { SuiteResult, BridgeEvents } from '@react-native-harness/bridge';
+export type TestRunnerContext = {
+    testFilePath: string;
+};
+export declare function runSuite(suite: TestSuite, eventHandler: (event: BridgeEvents[keyof BridgeEvents]) => void, context: TestRunnerContext): Promise<SuiteResult>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAEV,WAAW,EACX,YAAY,EACb,MAAM,8BAA8B,CAAC;AAEtC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAsKF,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,SAAS,EAChB,YAAY,EAAE,CAAC,KAAK,EAAE,YAAY,CAAC,MAAM,YAAY,CAAC,KAAK,IAAI,EAC/D,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,WAAW,CAAC,CAmFtB"}

package/dist/runner.js

@@ -0,0 +1,201 @@
+async function runHooks(hooks) {
+    for (const hook of hooks) {
+        await hook();
+    }
+}
+function collectInheritedHooks(suite, hookType) {
+    const hooks = [];
+    const suiteChain = [];
+    // Collect all suites from current to root
+    let currentSuite = suite;
+    while (currentSuite) {
+        suiteChain.push(currentSuite);
+        currentSuite = currentSuite.parent;
+    }
+    if (hookType === 'beforeEach') {
+        // For beforeEach: run parent hooks first (reverse the chain)
+        for (let i = suiteChain.length - 1; i >= 0; i--) {
+            hooks.push(...suiteChain[i].beforeEach);
+        }
+    }
+    else {
+        // For afterEach: run child hooks first (use chain as-is)
+        for (const suiteInChain of suiteChain) {
+            hooks.push(...suiteInChain.afterEach);
+        }
+    }
+    return hooks;
+}
+async function runTest(test, suite, eventHandler, context) {
+    const startTime = Date.now();
+    // Emit test-started event
+    eventHandler({
+        type: 'test-started',
+        path: context.testFilePath,
+        suite: suite.name,
+        name: test.name,
+    });
+    try {
+        if (test.status === 'skipped') {
+            console.log(`- ${test.name} (skipped)`);
+            const result = {
+                name: test.name,
+                status: 'skipped',
+                duration: 0,
+            };
+            // Emit test-finished event
+            eventHandler({
+                type: 'test-finished',
+                path: context.testFilePath,
+                suite: suite.name,
+                name: test.name,
+                duration: 0,
+                reason: 'skipped',
+            });
+            return result;
+        }
+        if (test.status === 'todo') {
+            console.log(`- ${test.name} (todo)`);
+            const result = {
+                name: test.name,
+                status: 'todo',
+                duration: 0,
+            };
+            // Emit test-finished event
+            eventHandler({
+                type: 'test-finished',
+                path: context.testFilePath,
+                suite: suite.name,
+                name: test.name,
+                duration: 0,
+                reason: 'todo',
+            });
+            return result;
+        }
+        // Run all beforeEach hooks from the current suite and its parents
+        const beforeEachHooks = collectInheritedHooks(suite, 'beforeEach');
+        await runHooks(beforeEachHooks);
+        // Run the actual test
+        await test.fn();
+        // Run all afterEach hooks from the current suite and its parents
+        const afterEachHooks = collectInheritedHooks(suite, 'afterEach');
+        await runHooks(afterEachHooks);
+        const duration = Date.now() - startTime;
+        console.log(`✓ ${test.name}`);
+        const result = {
+            name: test.name,
+            status: 'passed',
+            duration,
+        };
+        // Emit test-finished event
+        eventHandler({
+            type: 'test-finished',
+            path: context.testFilePath,
+            suite: suite.name,
+            name: test.name,
+            duration,
+            reason: 'passed',
+        });
+        return result;
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        console.error(`✗ ${test.name}`);
+        console.error(error);
+        const result = {
+            name: test.name,
+            status: 'failed',
+            error: {
+                name: typeof error === 'object' && error !== null && 'name' in error
+                    ? error.name
+                    : 'Unknown error',
+                message: typeof error === 'object' && error !== null && 'message' in error
+                    ? error.message
+                    : JSON.stringify(error),
+                stack: typeof error === 'object' && error !== null && 'stack' in error
+                    ? error.stack
+                    : undefined,
+            },
+            duration,
+        };
+        // Emit test-finished event
+        eventHandler({
+            type: 'test-finished',
+            path: context.testFilePath,
+            suite: suite.name,
+            name: test.name,
+            duration,
+            reason: 'failed',
+        });
+        return result;
+    }
+}
+export async function runSuite(suite, eventHandler, context) {
+    console.log(`\n${suite.name}`);
+    const startTime = Date.now();
+    // Emit suite-started event
+    eventHandler({
+        type: 'suite-started',
+        path: context.testFilePath,
+        name: suite.name,
+    });
+    const testResults = [];
+    const suiteResults = [];
+    let suiteError;
+    try {
+        // Run beforeAll hooks
+        await runHooks(suite.beforeAll);
+        // Run all tests in the current suite
+        for (const test of suite.tests) {
+            const result = await runTest(test, suite, eventHandler, context);
+            testResults.push(result);
+        }
+        // Run all child suites
+        for (const childSuite of suite.suites) {
+            const result = await runSuite(childSuite, eventHandler, context);
+            suiteResults.push(result);
+        }
+        // Run afterAll hooks
+        await runHooks(suite.afterAll);
+    }
+    catch (error) {
+        console.error(`Suite "${suite.name}" failed`);
+        suiteError = error;
+    }
+    const duration = Date.now() - startTime;
+    // Determine overall suite status
+    let status = 'passed';
+    if (suiteError) {
+        status = 'failed';
+    }
+    else {
+        // Check if any tests or child suites failed
+        const hasFailedTests = testResults.some((result) => result.status === 'failed');
+        const hasFailedSuites = suiteResults.some((result) => result.status === 'failed');
+        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';
+        }
+    }
+    // Emit suite-finished event
+    eventHandler({
+        type: 'suite-finished',
+        path: context.testFilePath,
+        name: suite.name,
+        duration,
+        reason: status,
+    });
+    return {
+        name: suite.name,
+        tests: testResults,
+        suites: suiteResults,
+        status,
+        error: suiteError,
+        duration,
+    };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,2 @@
+export declare const getClient: () => Promise<import("@react-native-harness/bridge/client").BridgeClient>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,SAAS,2EA6CrB,CAAC"}

package/dist/runtime.js

@@ -0,0 +1,44 @@
+import { getBridgeClient } from '@react-native-harness/bridge/client';
+import { fetchModule, evaluateModule } from './bundler/index.js';
+import { state } from './state.js';
+import { getTestRunner } from './runner/index.js';
+import { getTestCollector } from './collector/index.js';
+import { combineEventEmitters } from './utils/emitter.js';
+import { getWSServer } from './client/getWSServer.js';
+import { Alert } from 'react-native';
+import { getDeviceDescriptor } from './client/getDeviceDescriptor.js';
+export const getClient = async () => {
+    const client = await getBridgeClient(getWSServer(), {
+        runTests: async () => {
+            throw new Error('Not implemented');
+        },
+    });
+    Alert.alert('Device', JSON.stringify(getDeviceDescriptor()));
+    client.rpc.$functions.runTests = async (path) => {
+        if (state.getState().status === 'running') {
+            throw new Error('Already running tests');
+        }
+        state.getState().setStatus('running');
+        let collector = null;
+        let runner = null;
+        let events = null;
+        try {
+            collector = getTestCollector();
+            runner = getTestRunner();
+            events = combineEventEmitters(collector.events, runner.events);
+            events.addListener((event) => {
+                client.rpc.emitEvent(event.type, event);
+            });
+            const moduleJs = await fetchModule(path);
+            const collectionResult = await collector.collect(() => evaluateModule(moduleJs, path), path);
+            return await runner.run(collectionResult.testSuite, path);
+        }
+        finally {
+            collector?.dispose();
+            runner?.dispose();
+            events?.clearAllListeners();
+            state.getState().setStatus('idle');
+        }
+    };
+    return client;
+};

package/dist/spy/index.d.ts

@@ -0,0 +1,2 @@
+export * from '@vitest/spy';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spy/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAC"}

package/dist/spy/index.js

@@ -0,0 +1,2 @@
+// @vitest/spy is available as a no-dependency package, so we can re-use it in React Native Harness!
+export * from '@vitest/spy';

package/dist/state.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+import { BridgeClient } from '@react-native-harness/bridge/client';
+type ComponentHarnessState = {
+    node: ReactNode;
+    options: unknown;
+    layout: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+type RunnerState = {
+    status: 'loading' | 'idle' | 'running';
+    componentHarness: ComponentHarnessState | null;
+    client: BridgeClient | null;
+    setStatus: (status: 'idle' | 'running') => void;
+    render: (node: ReactNode, options: unknown) => void;
+    cleanup: () => void;
+    bootstrap: () => Promise<void>;
+    reportLayout: (x: number, y: number, width: number, height: number) => void;
+};
+export declare const state: import("zustand/react").UseBoundStore<import("zustand/vanilla").StoreApi<RunnerState>>;
+export {};
+//# sourceMappingURL=state.d.ts.map

package/dist/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAElC,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAGnE,KAAK,qBAAqB,GAAG;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACjE,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;IACvC,gBAAgB,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC/C,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;IAChD,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACpD,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7E,CAAC;AAUF,eAAO,MAAM,KAAK,wFA+Bf,CAAC"}

package/dist/state.js

@@ -0,0 +1,37 @@
+import { create } from 'zustand/react';
+import { getClient } from './runtime.js';
+function assertComponentHarnessReady(state) {
+    if (!state.componentHarness) {
+        throw new Error('ComponentHarness is not ready');
+    }
+}
+export const state = create((set) => ({
+    status: 'loading',
+    componentHarness: null,
+    client: null,
+    setStatus: (status) => set({ status }),
+    render: (node, options) => set({
+        componentHarness: {
+            node,
+            options,
+            layout: { x: 0, y: 0, width: 0, height: 0 },
+        },
+    }),
+    cleanup: () => set({ componentHarness: null }),
+    bootstrap: async () => {
+        const client = await getClient();
+        set({ client, status: 'idle' });
+        client.rpc.reportReady();
+    },
+    reportLayout: (x, y, width, height) => {
+        set((state) => {
+            assertComponentHarnessReady(state);
+            return {
+                componentHarness: {
+                    ...state.componentHarness,
+                    layout: { x, y, width, height },
+                },
+            };
+        });
+    },
+}));