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

package/dist/bundler/bundle.d.ts

@@ -0,0 +1,2 @@
+export declare const fetchModule: (fileName: string) => Promise<string>;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundler/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/bundler/bundle.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,WAAW,GAAU,UAAU,MAAM,KAAG,OAAO,CAAC,MAAM,CAIlE,CAAC"}

package/dist/bundler/bundle.js

@@ -0,0 +1,16 @@
+import { Platform } from 'react-native';
+import { getDevServerUrl } from '../utils/dev-server.js';
+const getModuleUrl = (fileName) => {
+    const devServerUrl = getDevServerUrl();
+    const bundleName = fileName.split('.').slice(0, -1).join('.') + '.bundle';
+    const urlSearchParams = new URLSearchParams({
+        modulesOnly: 'true',
+        platform: Platform.OS,
+    });
+    return `${devServerUrl}/${bundleName}?${urlSearchParams.toString()}`;
+};
+export const fetchModule = async (fileName) => {
+    const url = getModuleUrl(fileName);
+    const response = await fetch(url);
+    return response.text();
+};

package/dist/bundler/dev-server.d.ts

@@ -0,0 +1,2 @@
+export declare const getDevServerUrl: () => string;
+//# sourceMappingURL=dev-server.d.ts.map

package/dist/bundler/dev-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-server.d.ts","sourceRoot":"","sources":["../../src/bundler/dev-server.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe,QAAO,MAGlC,CAAC"}

package/dist/bundler/dev-server.js

@@ -0,0 +1,5 @@
+import getDevServer from 'react-native/Libraries/Core/Devtools/getDevServer';
+export const getDevServerUrl = () => {
+    const devServer = getDevServer();
+    return devServer.url;
+};

package/dist/bundler/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class ModuleNotFoundError extends Error {
+    readonly modulePath: string;
+    constructor(modulePath: string);
+}
+export declare class MalformedModuleError extends Error {
+    readonly modulePath: string;
+    readonly reason: string;
+    constructor(modulePath: string, reason: string);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/bundler/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,mBAAoB,SAAQ,KAAK;aAChB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,oBAAqB,SAAQ,KAAK;aAE3B,UAAU,EAAE,MAAM;aAClB,MAAM,EAAE,MAAM;gBADd,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM;CAKjC"}

package/dist/bundler/errors.js

@@ -0,0 +1,18 @@
+export class ModuleNotFoundError extends Error {
+    modulePath;
+    constructor(modulePath) {
+        super(`Module ${modulePath} not found`);
+        this.modulePath = modulePath;
+        this.name = 'ModuleNotFoundError';
+    }
+}
+export class MalformedModuleError extends Error {
+    modulePath;
+    reason;
+    constructor(modulePath, reason) {
+        super(`Module ${modulePath} is malformed: ${reason}`);
+        this.modulePath = modulePath;
+        this.reason = reason;
+        this.name = 'MalformedModuleError';
+    }
+}

package/dist/bundler/evaluate.d.ts

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

package/dist/bundler/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/bundler/evaluate.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,EAAE,YAAY,MAAM,KAAG,IAqBrE,CAAC"}

package/dist/bundler/evaluate.js

@@ -0,0 +1,18 @@
+import { MalformedModuleError } from './errors.js';
+import { EnvironmentError } from '../errors.js';
+export const evaluateModule = (moduleJs, modulePath) => {
+    const __rMatch = moduleJs.match(/__r\((\d+)\)/);
+    if (!__rMatch) {
+        throw new MalformedModuleError(modulePath, 'No __r function found');
+    }
+    const __rParam = __rMatch[1];
+    if (!__rParam) {
+        throw new MalformedModuleError(modulePath, 'No __r parameter found');
+    }
+    // eslint-disable-next-line no-eval
+    eval(moduleJs);
+    if (!__r) {
+        throw new EnvironmentError('module evaluation', '__r is not defined');
+    }
+    __r(Number(__rParam));
+};

package/dist/bundler/index.d.ts

@@ -0,0 +1,3 @@
+export { fetchModule } from './bundle.js';
+export { evaluateModule } from './evaluate.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bundler/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC"}

package/dist/bundler/index.js

@@ -0,0 +1,2 @@
+export { fetchModule } from './bundle.js';
+export { evaluateModule } from './evaluate.js';

package/dist/client/factory.d.ts

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

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

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

package/dist/client/factory.js

@@ -0,0 +1,41 @@
+import { getBridgeClient } from '@react-native-harness/bridge/client';
+import { store } from '../ui/state.js';
+import { getTestRunner } from '../runner/index.js';
+import { getTestCollector } from '../collector/index.js';
+import { combineEventEmitters } from '../utils/emitter.js';
+import { getWSServer } from './getWSServer.js';
+import { fetchModule, evaluateModule } from '../bundler/index.js';
+export const getClient = async () => {
+    const client = await getBridgeClient(getWSServer(), {
+        runTests: async () => {
+            throw new Error('Not implemented');
+        },
+    });
+    client.rpc.$functions.runTests = async (path) => {
+        if (store.getState().status === 'running') {
+            throw new Error('Already running tests');
+        }
+        store.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();
+            store.getState().setStatus('idle');
+        }
+    };
+    return client;
+};

package/dist/client/getDeviceDescriptor.d.ts

@@ -0,0 +1,8 @@
+export type DeviceDescriptor = {
+    platform: 'ios' | 'android';
+    manufacturer: string;
+    model: string;
+    osVersion: string;
+};
+export declare const getDeviceDescriptor: () => DeviceDescriptor;
+//# sourceMappingURL=getDeviceDescriptor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getDeviceDescriptor.d.ts","sourceRoot":"","sources":["../../src/client/getDeviceDescriptor.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,KAAK,GAAG,SAAS,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,mBAAmB,QAAO,gBAoBtC,CAAC"}

package/dist/client/getDeviceDescriptor.js

@@ -0,0 +1,20 @@
+import { Platform } from 'react-native';
+export const getDeviceDescriptor = () => {
+    if (Platform.OS === 'ios') {
+        return {
+            platform: 'ios',
+            manufacturer: 'Apple',
+            model: 'Unknown',
+            osVersion: Platform.constants.osVersion,
+        };
+    }
+    if (Platform.OS === 'android') {
+        return {
+            platform: 'android',
+            manufacturer: Platform.constants.Manufacturer,
+            model: Platform.constants.Model,
+            osVersion: Platform.constants.Release,
+        };
+    }
+    throw new Error('Unsupported platform');
+};

package/dist/client/getWSServer.d.ts

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

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

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

package/dist/client/getWSServer.js

@@ -0,0 +1,7 @@
+import { getDevServerUrl } from '../utils/dev-server.js';
+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}`;
+};

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export { getClient } from './factory.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/client/index.js

@@ -0,0 +1 @@
+export { getClient } from './factory.js';

package/dist/collector/errors.d.ts

@@ -0,0 +1,8 @@
+export type TestErrorCode = 'CONTEXT_NOT_INITIALIZED' | 'OUTSIDE_DESCRIBE_BLOCK' | 'INVALID_TEST_NAME' | 'DUPLICATE_TEST_NAME' | 'INVALID_FUNCTION';
+export declare class TestError extends Error {
+    code: TestErrorCode;
+    functionName: string;
+    context?: Record<string, unknown> | undefined;
+    constructor(code: TestErrorCode, functionName: string, context?: Record<string, unknown> | undefined);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/collector/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GACrB,yBAAyB,GACzB,wBAAwB,GACxB,mBAAmB,GACnB,qBAAqB,GACrB,kBAAkB,CAAC;AAEvB,qBAAa,SAAU,SAAQ,KAAK;IAEzB,IAAI,EAAE,aAAa;IACnB,YAAY,EAAE,MAAM;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;gBAFjC,IAAI,EAAE,aAAa,EACnB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAA;CAe3C"}

package/dist/collector/errors.js

@@ -0,0 +1,20 @@
+export class TestError extends Error {
+    code;
+    functionName;
+    context;
+    constructor(code, functionName, context) {
+        const baseMessages = {
+            CONTEXT_NOT_INITIALIZED: 'Test context not initialized. Call collectTests() first.',
+            OUTSIDE_DESCRIBE_BLOCK: `${functionName}() must be called within a describe() block`,
+            INVALID_TEST_NAME: `${functionName}() requires a non-empty string name`,
+            DUPLICATE_TEST_NAME: `Duplicate test name "${context?.name}" in suite "${context?.suiteName}"`,
+            INVALID_FUNCTION: `${functionName}() requires a function as the second parameter`,
+        };
+        const message = baseMessages[code] || `Unknown error in ${functionName}()`;
+        super(message);
+        this.code = code;
+        this.functionName = functionName;
+        this.context = context;
+        this.name = 'TestError';
+    }
+}

package/dist/collector/factory.d.ts

@@ -0,0 +1,3 @@
+import { TestCollector } from './types.js';
+export declare const getTestCollector: () => TestCollector;
+//# sourceMappingURL=factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/collector/factory.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,gBAAgB,QAAO,aA0BnC,CAAC"}

package/dist/collector/factory.js

@@ -0,0 +1,25 @@
+import { getEmitter } from '../utils/emitter.js';
+import { collectTests } from './functions.js';
+export const getTestCollector = () => {
+    const events = getEmitter();
+    return {
+        events,
+        collect: async (fn, testFilePath) => {
+            const start = Date.now();
+            events.emit({
+                type: 'collection-started',
+                file: testFilePath,
+            });
+            const result = await collectTests(fn);
+            events.emit({
+                type: 'collection-finished',
+                file: testFilePath,
+                duration: Date.now() - start,
+            });
+            return result;
+        },
+        dispose: () => {
+            events.clearAllListeners();
+        },
+    };
+};

package/dist/collector/functions.d.ts

@@ -0,0 +1,22 @@
+import type { CollectionResult } from '@react-native-harness/bridge';
+import type { TestFn } from './types.js';
+export declare const describe: ((name: string, fn: () => void) => void) & {
+    skip: (name: string, fn: () => void) => void;
+    only: (name: string, fn: () => void) => void;
+};
+export declare const test: ((name: string, fn: TestFn) => void) & {
+    skip: (name: string, fn: TestFn) => void;
+    only: (name: string, fn: TestFn) => void;
+    todo: (name: string) => void;
+};
+export declare const it: ((name: string, fn: TestFn) => void) & {
+    skip: (name: string, fn: TestFn) => void;
+    only: (name: string, fn: TestFn) => void;
+    todo: (name: string) => void;
+};
+export declare function beforeAll(fn: TestFn): void;
+export declare function afterAll(fn: TestFn): void;
+export declare function beforeEach(fn: TestFn): void;
+export declare function afterEach(fn: TestFn): void;
+export declare const collectTests: (fn: () => void) => CollectionResult;
+//# sourceMappingURL=functions.d.ts.map

package/dist/collector/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../../src/collector/functions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AA8KzC,eAAO,MAAM,QAAQ,UACZ,MAAM,MAAM,MAAM,IAAI;iBAsBd,MAAM,MAAM,MAAM,IAAI;iBAqBtB,MAAM,MAAM,MAAM,IAAI;CAsBtC,CAAC;AAEF,eAAO,MAAM,IAAI,UACR,MAAM,MAAM,MAAM;iBAaV,MAAM,MAAM,MAAM;iBAWlB,MAAM,MAAM,MAAM;iBAWlB,MAAM;CAiBtB,CAAC;AAEF,eAAO,MAAM,EAAE,UAtDN,MAAM,MAAM,MAAM;iBAaV,MAAM,MAAM,MAAM;iBAWlB,MAAM,MAAM,MAAM;iBAWlB,MAAM;CAmBD,CAAC;AAEvB,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,QAQnC;AAED,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,QAQlC;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,QAQpC;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,QAQnC;AAgBD,eAAO,MAAM,YAAY,GAAI,IAAI,MAAM,IAAI,KAAG,gBAiB7C,CAAC"}

package/dist/collector/functions.js

@@ -0,0 +1,271 @@
+import { TestError } from './errors.js';
+import { validateTestName, validateTestFunction } from './validation.js';
+// Computation functions for two-phase approach
+const computeTestStatus = (test, suiteContext) => {
+    if (test.options.todo)
+        return 'todo';
+    if (test.options.skip)
+        return 'skipped';
+    if (test.options.only)
+        return 'active';
+    if (suiteContext.hasFocusedTests)
+        return 'skipped';
+    return 'active';
+};
+const computeSuiteStatus = (suite, parentContext) => {
+    if (suite.options.skip)
+        return 'skipped';
+    if (suite.options.only)
+        return 'active';
+    if (parentContext.hasFocusedChildren)
+        return 'skipped';
+    return 'active';
+};
+const convertRawTestCaseToTestCase = (rawTest, suiteContext) => {
+    return {
+        name: rawTest.name,
+        fn: rawTest.fn,
+        status: computeTestStatus(rawTest, suiteContext),
+    };
+};
+const convertRawTestSuiteToTestSuite = (rawSuite, parentContext = {
+    hasFocusedChildren: false,
+}, parentSuite) => {
+    // Validate duplicate test names within this suite
+    const testNames = new Set();
+    for (const test of rawSuite.tests) {
+        if (testNames.has(test.name)) {
+            throw new TestError('DUPLICATE_TEST_NAME', 'test', {
+                name: test.name,
+                suiteName: rawSuite.name,
+            });
+        }
+        testNames.add(test.name);
+    }
+    // Check if this suite has focused tests
+    const hasFocusedTests = rawSuite.tests.some((test) => test.options.only);
+    // Check if this suite has focused children
+    const hasFocusedChildren = rawSuite.suites.some((suite) => suite.options.only || suite.tests.some((test) => test.options.only));
+    // Convert tests
+    const tests = rawSuite.tests.map((test) => convertRawTestCaseToTestCase(test, { hasFocusedTests }));
+    // Create the suite first so we can reference it when converting children
+    const suite = {
+        name: rawSuite.name,
+        tests,
+        suites: [],
+        parent: parentSuite,
+        beforeAll: rawSuite.hooks.beforeAll,
+        afterAll: rawSuite.hooks.afterAll,
+        beforeEach: rawSuite.hooks.beforeEach,
+        afterEach: rawSuite.hooks.afterEach,
+        status: computeSuiteStatus(rawSuite, parentContext),
+        _hasFocused: hasFocusedTests || hasFocusedChildren || rawSuite.options.only,
+    };
+    // Convert child suites with this suite as their parent
+    suite.suites = rawSuite.suites.map((childSuite) => convertRawTestSuiteToTestSuite(childSuite, { hasFocusedChildren }, suite));
+    return suite;
+};
+let currentContext = null;
+const clearState = () => {
+    const rootSuite = createRawSuite('root');
+    return {
+        rootSuite,
+        currentSuite: rootSuite,
+    };
+};
+const getCurrentSuite = () => {
+    if (!currentContext) {
+        throw new TestError('CONTEXT_NOT_INITIALIZED', 'getCurrentSuite');
+    }
+    return currentContext.currentSuite;
+};
+const getRootSuite = () => {
+    if (!currentContext) {
+        throw new TestError('CONTEXT_NOT_INITIALIZED', 'getRootSuite');
+    }
+    return currentContext.rootSuite;
+};
+const setCurrentSuite = (suite) => {
+    if (!currentContext) {
+        throw new TestError('CONTEXT_NOT_INITIALIZED', 'setCurrentSuite');
+    }
+    currentContext.currentSuite = suite;
+};
+const createRawSuite = (name, options = {}) => {
+    return {
+        name,
+        tests: [],
+        suites: [],
+        hooks: {
+            beforeAll: [],
+            afterAll: [],
+            beforeEach: [],
+            afterEach: [],
+        },
+        options,
+    };
+};
+export const describe = Object.assign((name, fn) => {
+    validateTestName(name, 'describe');
+    validateTestFunction(fn, 'describe');
+    const suite = createRawSuite(name);
+    const previousSuite = getCurrentSuite();
+    setCurrentSuite(suite);
+    try {
+        fn();
+    }
+    finally {
+        setCurrentSuite(previousSuite);
+    }
+    // Add the suite to its parent
+    if (previousSuite) {
+        previousSuite.suites.push(suite);
+    }
+    else {
+        getRootSuite().suites.push(suite);
+    }
+}, {
+    skip: (name, fn) => {
+        validateTestName(name, 'describe.skip');
+        validateTestFunction(fn, 'describe.skip');
+        const suite = createRawSuite(name, { skip: true });
+        const previousSuite = getCurrentSuite();
+        setCurrentSuite(suite);
+        try {
+            fn();
+        }
+        finally {
+            setCurrentSuite(previousSuite);
+        }
+        // Add the suite to its parent
+        if (previousSuite) {
+            previousSuite.suites.push(suite);
+        }
+        else {
+            getRootSuite().suites.push(suite);
+        }
+    },
+    only: (name, fn) => {
+        validateTestName(name, 'describe.only');
+        validateTestFunction(fn, 'describe.only');
+        const suite = createRawSuite(name, { only: true });
+        const previousSuite = getCurrentSuite();
+        setCurrentSuite(suite);
+        try {
+            fn();
+        }
+        finally {
+            setCurrentSuite(previousSuite);
+        }
+        // Add the suite to its parent
+        if (previousSuite) {
+            previousSuite.suites.push(suite);
+        }
+        else {
+            getRootSuite().suites.push(suite);
+        }
+    },
+});
+export const test = Object.assign((name, fn) => {
+    validateTestName(name, 'test');
+    validateTestFunction(fn, 'test');
+    const currentSuite = getCurrentSuite();
+    if (!currentSuite) {
+        throw new TestError('OUTSIDE_DESCRIBE_BLOCK', 'test');
+    }
+    // Add test with default options
+    currentSuite.tests.push({ name, fn, options: {} });
+}, {
+    skip: (name, fn) => {
+        validateTestName(name, 'test.skip');
+        validateTestFunction(fn, 'test.skip');
+        const currentSuite = getCurrentSuite();
+        if (!currentSuite) {
+            throw new TestError('OUTSIDE_DESCRIBE_BLOCK', 'test.skip');
+        }
+        currentSuite.tests.push({ name, fn, options: { skip: true } });
+    },
+    only: (name, fn) => {
+        validateTestName(name, 'test.only');
+        validateTestFunction(fn, 'test.only');
+        const currentSuite = getCurrentSuite();
+        if (!currentSuite) {
+            throw new TestError('OUTSIDE_DESCRIBE_BLOCK', 'test.only');
+        }
+        currentSuite.tests.push({ name, fn, options: { only: true } });
+    },
+    todo: (name) => {
+        validateTestName(name, 'test.todo');
+        const currentSuite = getCurrentSuite();
+        if (!currentSuite) {
+            throw new TestError('OUTSIDE_DESCRIBE_BLOCK', 'test.todo');
+        }
+        currentSuite.tests.push({
+            name,
+            fn: () => {
+                // Empty function for todo tests
+            },
+            options: { todo: true },
+        });
+    },
+});
+export const it = test;
+export function beforeAll(fn) {
+    validateTestFunction(fn, 'beforeAll');
+    const currentSuite = getCurrentSuite();
+    if (!currentSuite) {
+        throw new TestError('OUTSIDE_DESCRIBE_BLOCK', 'beforeAll');
+    }
+    currentSuite.hooks.beforeAll.push(fn);
+}
+export function afterAll(fn) {
+    validateTestFunction(fn, 'afterAll');
+    const currentSuite = getCurrentSuite();
+    if (!currentSuite) {
+        throw new TestError('OUTSIDE_DESCRIBE_BLOCK', 'afterAll');
+    }
+    currentSuite.hooks.afterAll.push(fn);
+}
+export function beforeEach(fn) {
+    validateTestFunction(fn, 'beforeEach');
+    const currentSuite = getCurrentSuite();
+    if (!currentSuite) {
+        throw new TestError('OUTSIDE_DESCRIBE_BLOCK', 'beforeEach');
+    }
+    currentSuite.hooks.beforeEach.push(fn);
+}
+export function afterEach(fn) {
+    validateTestFunction(fn, 'afterEach');
+    const currentSuite = getCurrentSuite();
+    if (!currentSuite) {
+        throw new TestError('OUTSIDE_DESCRIBE_BLOCK', 'afterEach');
+    }
+    currentSuite.hooks.afterEach.push(fn);
+}
+/**
+ * Recursively counts the total number of tests that will actually be executed.
+ * Only counts active tests since skipped and todo tests are not executed.
+ */
+const countTests = (suite) => {
+    let count = suite.tests.filter((test) => test.status === 'active').length;
+    for (const childSuite of suite.suites) {
+        count += countTests(childSuite);
+    }
+    return count;
+};
+export const collectTests = (fn) => {
+    currentContext = clearState();
+    try {
+        fn();
+        // Convert raw structure to final structure using computation phase
+        const testSuite = convertRawTestSuiteToTestSuite(getRootSuite());
+        const totalTests = countTests(testSuite);
+        return {
+            testSuite,
+            totalTests,
+        };
+    }
+    finally {
+        currentContext = null;
+    }
+};

package/dist/collector/index.d.ts

@@ -0,0 +1,5 @@
+export { describe, test, it, beforeAll, afterAll, beforeEach, afterEach, } from './functions.js';
+export { TestError, type TestErrorCode } from './errors.js';
+export type { TestCollector, TestCollectorEventsEmitter } from './types.js';
+export { getTestCollector } from './factory.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collector/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,IAAI,EACJ,EAAE,EACF,SAAS,EACT,QAAQ,EACR,UAAU,EACV,SAAS,GACV,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5D,YAAY,EAAE,aAAa,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/dist/collector/index.js

@@ -0,0 +1,3 @@
+export { describe, test, it, beforeAll, afterAll, beforeEach, afterEach, } from './functions.js';
+export { TestError } from './errors.js';
+export { getTestCollector } from './factory.js';

package/dist/collector/types.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '../utils/emitter.js';
+import { TestCollectorEvents, CollectionResult } from '@react-native-harness/bridge';
+export type TestFn = () => void | Promise<void>;
+export type TestCollectorEventsEmitter = EventEmitter<TestCollectorEvents>;
+export type TestCollector = {
+    events: TestCollectorEventsEmitter;
+    collect: (fn: () => void, testFilePath: string) => Promise<CollectionResult>;
+    dispose: () => void;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/collector/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAEtC,MAAM,MAAM,MAAM,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEhD,MAAM,MAAM,0BAA0B,GAAG,YAAY,CAAC,mBAAmB,CAAC,CAAC;AAE3E,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,0BAA0B,CAAC;IACnC,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC7E,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC"}

package/dist/collector/types.js

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

package/dist/collector/validation.d.ts

@@ -0,0 +1,4 @@
+import { TestFn } from './types.js';
+export declare const validateTestName: (name: string, functionName: string) => void;
+export declare const validateTestFunction: (fn: TestFn, functionName: string) => void;
+//# sourceMappingURL=validation.d.ts.map

package/dist/collector/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/collector/validation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEpC,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,EAAE,cAAc,MAAM,KAAG,IAMrE,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,IAAI,MAAM,EACV,cAAc,MAAM,KACnB,IAMF,CAAC"}