@react-native-harness/jest 1.0.0-canary.1766225407244 → 1.0.0

package/dist/__tests__/client-log-handler.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client-log-handler.test.d.ts.map

package/dist/__tests__/client-log-handler.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-log-handler.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/client-log-handler.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/client-log-handler.test.js

@@ -0,0 +1,262 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { formatClientLogMessage, formatClientLogLine, handleClientLogEvent, createClientLogListener, } from '../client-log-handler.js';
+// Mock the log function
+vi.mock('../logs.js', () => ({
+    log: vi.fn(),
+}));
+import { log } from '../logs.js';
+describe('client-log-handler', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('formatClientLogMessage', () => {
+        it('should format a single string', () => {
+            const result = formatClientLogMessage(['Hello, world!']);
+            expect(result).toBe('Hello, world!');
+        });
+        it('should join multiple strings with spaces', () => {
+            const result = formatClientLogMessage(['Hello', 'world', '!']);
+            expect(result).toBe('Hello world !');
+        });
+        it('should format objects', () => {
+            const result = formatClientLogMessage([{ key: 'value' }]);
+            // util.format uses inspect-style output for objects
+            expect(result).toContain('key');
+            expect(result).toContain('value');
+        });
+        it('should format arrays', () => {
+            const result = formatClientLogMessage([[1, 2, 3]]);
+            expect(result).toContain('1');
+            expect(result).toContain('2');
+            expect(result).toContain('3');
+        });
+        it('should handle mixed types', () => {
+            const result = formatClientLogMessage([
+                'Message:',
+                { count: 42 },
+                'items',
+            ]);
+            expect(result).toContain('Message:');
+            expect(result).toContain('count');
+            expect(result).toContain('42');
+            expect(result).toContain('items');
+        });
+        it('should format numbers', () => {
+            const result = formatClientLogMessage([123, 456]);
+            expect(result).toBe('123 456');
+        });
+        it('should format booleans', () => {
+            const result = formatClientLogMessage([true, false]);
+            expect(result).toBe('true false');
+        });
+        it('should format null and undefined', () => {
+            const result = formatClientLogMessage([null, undefined]);
+            expect(result).toBe('null undefined');
+        });
+        it('should handle empty array', () => {
+            const result = formatClientLogMessage([]);
+            expect(result).toBe('');
+        });
+        describe('printf-style format specifiers', () => {
+            it('should handle %s string substitution', () => {
+                const result = formatClientLogMessage(['%s world', 'hello']);
+                expect(result).toBe('hello world');
+            });
+            it('should handle %d integer substitution', () => {
+                const result = formatClientLogMessage(['Count: %d', 42]);
+                expect(result).toBe('Count: 42');
+            });
+            it('should handle %i integer substitution', () => {
+                const result = formatClientLogMessage(['Value: %i', 123]);
+                expect(result).toBe('Value: 123');
+            });
+            it('should handle %f float substitution', () => {
+                const result = formatClientLogMessage(['Pi: %f', 3.14159]);
+                expect(result).toContain('3.14159');
+            });
+            it('should handle multiple substitutions', () => {
+                const result = formatClientLogMessage(['Hello %s, you have %d messages', 'Alice', 5]);
+                expect(result).toBe('Hello Alice, you have 5 messages');
+            });
+            it('should handle %j JSON substitution', () => {
+                const result = formatClientLogMessage(['Data: %j', { key: 'value' }]);
+                expect(result).toBe('Data: {"key":"value"}');
+            });
+            it('should handle %o object substitution', () => {
+                const result = formatClientLogMessage(['Object: %o', { a: 1 }]);
+                // %o produces inspect-style output, just check it contains the key
+                expect(result).toContain('a');
+            });
+            it('should handle %% as literal percent when substituting', () => {
+                // %% is only converted to % when there are substitutions
+                const result = formatClientLogMessage(['%s is 100%% complete', 'Task']);
+                expect(result).toBe('Task is 100% complete');
+            });
+            it('should append extra arguments after substitution', () => {
+                const result = formatClientLogMessage(['Hello %s', 'world', 'extra', 'args']);
+                expect(result).toBe('Hello world extra args');
+            });
+        });
+    });
+    describe('formatClientLogLine', () => {
+        it('should format log level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'log',
+                data: ['Test message'],
+            };
+            const result = formatClientLogLine(event);
+            // The result will contain ANSI codes for styling, so we check it contains the message
+            expect(result).toContain('Test message');
+        });
+        it('should format error level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'error',
+                data: ['Error occurred'],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('Error occurred');
+        });
+        it('should format warn level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'warn',
+                data: ['Warning message'],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('Warning message');
+        });
+        it('should format info level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'info',
+                data: ['Info message'],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('Info message');
+        });
+        it('should format debug level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'debug',
+                data: ['Debug message'],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('Debug message');
+        });
+        it('should format trace level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'trace',
+                data: ['Trace message'],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('Trace message');
+        });
+        it('should handle multiple data items', () => {
+            const event = {
+                type: 'client_log',
+                level: 'log',
+                data: ['User:', { id: 1, name: 'Test' }],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('User:');
+            expect(result).toContain('id');
+            expect(result).toContain('Test');
+        });
+    });
+    describe('handleClientLogEvent', () => {
+        it('should handle client_log events and call log', () => {
+            const event = {
+                type: 'client_log',
+                level: 'log',
+                data: ['Test message'],
+            };
+            const result = handleClientLogEvent(event);
+            expect(result).toBe(true);
+            expect(log).toHaveBeenCalledTimes(1);
+            expect(log).toHaveBeenCalledWith(expect.stringContaining('Test message'));
+        });
+        it('should return false for non-client_log events', () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const event = { type: 'bundle_build_started' };
+            const result = handleClientLogEvent(event);
+            expect(result).toBe(false);
+            expect(log).not.toHaveBeenCalled();
+        });
+        it('should handle error level logs', () => {
+            const event = {
+                type: 'client_log',
+                level: 'error',
+                data: ['Something went wrong'],
+            };
+            handleClientLogEvent(event);
+            expect(log).toHaveBeenCalledWith(expect.stringContaining('Something went wrong'));
+        });
+        it('should handle warn level logs', () => {
+            const event = {
+                type: 'client_log',
+                level: 'warn',
+                data: ['Deprecation warning'],
+            };
+            handleClientLogEvent(event);
+            expect(log).toHaveBeenCalledWith(expect.stringContaining('Deprecation warning'));
+        });
+    });
+    describe('createClientLogListener', () => {
+        it('should create a listener function', () => {
+            const listener = createClientLogListener();
+            expect(typeof listener).toBe('function');
+        });
+        it('should handle client_log events when called', () => {
+            const listener = createClientLogListener();
+            const event = {
+                type: 'client_log',
+                level: 'info',
+                data: ['Listener test'],
+            };
+            listener(event);
+            expect(log).toHaveBeenCalledWith(expect.stringContaining('Listener test'));
+        });
+        it('should ignore non-client_log events', () => {
+            const listener = createClientLogListener();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const event = { type: 'initialize_done' };
+            listener(event);
+            expect(log).not.toHaveBeenCalled();
+        });
+    });
+    describe('group events', () => {
+        it('should handle group events without logging', () => {
+            const event = {
+                type: 'client_log',
+                level: 'group',
+                data: ['Group label'],
+            };
+            const result = handleClientLogEvent(event);
+            expect(result).toBe(true);
+            expect(log).not.toHaveBeenCalled();
+        });
+        it('should handle groupCollapsed events without logging', () => {
+            const event = {
+                type: 'client_log',
+                level: 'groupCollapsed',
+                data: ['Collapsed'],
+            };
+            const result = handleClientLogEvent(event);
+            expect(result).toBe(true);
+            expect(log).not.toHaveBeenCalled();
+        });
+        it('should handle groupEnd events without logging', () => {
+            const event = {
+                type: 'client_log',
+                level: 'groupEnd',
+                data: [],
+            };
+            const result = handleClientLogEvent(event);
+            expect(result).toBe(true);
+            expect(log).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/cli-args.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli-args.test.d.ts.map

package/dist/cli-args.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-args.test.d.ts","sourceRoot":"","sources":["../src/cli-args.test.ts"],"names":[],"mappings":""}

package/dist/cli-args.test.js

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

package/dist/client-log-handler.d.ts

@@ -0,0 +1,23 @@
+import type { ReportableEvent } from '@react-native-harness/bundler-metro';
+export type ClientLogEvent = Extract<ReportableEvent, {
+    type: 'client_log';
+}>;
+/**
+ * Formats a client log event data array into a string message.
+ * Uses util.format for printf-style format specifier support (%s, %d, %j, etc.)
+ */
+export declare const formatClientLogMessage: (data: unknown[]) => string;
+/**
+ * Formats a client log event into a log line with styled level prefix.
+ */
+export declare const formatClientLogLine: (event: ClientLogEvent) => string;
+/**
+ * Handles a client_log event by formatting and logging it.
+ * Returns true if the event was handled, false otherwise.
+ */
+export declare const handleClientLogEvent: (event: ReportableEvent) => boolean;
+/**
+ * Creates a client log event listener that can be added to the Metro reporter.
+ */
+export declare const createClientLogListener: () => ((event: ReportableEvent) => void);
+//# sourceMappingURL=client-log-handler.d.ts.map

package/dist/client-log-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-log-handler.d.ts","sourceRoot":"","sources":["../src/client-log-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAK3E,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC;AA6C9E;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,OAAO,EAAE,KAAG,MAKxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,cAAc,KAAG,MAI3D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,eAAe,KAAG,OAiB7D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAAO,CAAC,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAI3E,CAAC"}

package/dist/client-log-handler.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk';
+import util from 'node:util';
+import { log } from './logs.js';
+/**
+ * Gets the display level for a log level.
+ * Note: Metro treats 'trace' as 'log' because Hermes doesn't include stack traces.
+ */
+const getDisplayLevel = (level) => {
+    // Metro converts trace to log for display (Hermes doesn't provide stack traces)
+    if (level === 'trace') {
+        return 'LOG';
+    }
+    return level.toUpperCase();
+};
+/**
+ * Creates a styled tag for a log level with colored box appearance.
+ */
+const createLevelTag = (level) => {
+    const displayLevel = getDisplayLevel(level);
+    const label = ` ${displayLevel} `;
+    if (!chalk.supportsColor) {
+        return `[${displayLevel}]`;
+    }
+    switch (level) {
+        case 'error':
+            return chalk.reset.inverse.bold.red(label);
+        case 'warn':
+            return chalk.reset.inverse.bold.yellow(label);
+        case 'info':
+            return chalk.reset.inverse.bold.cyan(label);
+        case 'debug':
+            return chalk.reset.inverse.bold.blue(label);
+        case 'trace':
+            // Trace displays as LOG but with a distinct color
+            return chalk.reset.inverse.bold.magenta(label);
+        case 'log':
+        default:
+            return chalk.reset.inverse.bold.white(label);
+    }
+};
+/**
+ * Formats a client log event data array into a string message.
+ * Uses util.format for printf-style format specifier support (%s, %d, %j, etc.)
+ */
+export const formatClientLogMessage = (data) => {
+    if (data.length === 0) {
+        return '';
+    }
+    return util.format(...data);
+};
+/**
+ * Formats a client log event into a log line with styled level prefix.
+ */
+export const formatClientLogLine = (event) => {
+    const tag = createLevelTag(event.level);
+    const message = formatClientLogMessage(event.data);
+    return `${tag} ${message}`;
+};
+/**
+ * Handles a client_log event by formatting and logging it.
+ * Returns true if the event was handled, false otherwise.
+ */
+export const handleClientLogEvent = (event) => {
+    if (event.type !== 'client_log') {
+        return false;
+    }
+    // Skip group events - they don't produce output
+    if (event.level === 'group' ||
+        event.level === 'groupCollapsed' ||
+        event.level === 'groupEnd') {
+        return true;
+    }
+    const logLine = formatClientLogLine(event);
+    log(logLine);
+    return true;
+};
+/**
+ * Creates a client log event listener that can be added to the Metro reporter.
+ */
+export const createClientLogListener = () => {
+    return (event) => {
+        handleClientLogEvent(event);
+    };
+};

package/dist/crash-monitor.d.ts

@@ -0,0 +1,16 @@
+import { HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { BridgeServer } from '@react-native-harness/bridge/server';
+export type CrashMonitor = {
+    startMonitoring(testFilePath: string): Promise<never>;
+    stopMonitoring(): void;
+    markIntentionalRestart(): void;
+    clearIntentionalRestart(): void;
+    dispose(): void;
+};
+export type CrashMonitorOptions = {
+    interval: number;
+    platformRunner: HarnessPlatformRunner;
+    bridgeServer: BridgeServer;
+};
+export declare const createCrashMonitor: ({ interval, platformRunner, bridgeServer, }: CrashMonitorOptions) => CrashMonitor;
+//# sourceMappingURL=crash-monitor.d.ts.map

package/dist/crash-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crash-monitor.d.ts","sourceRoot":"","sources":["../src/crash-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAInE,MAAM,MAAM,YAAY,GAAG;IACzB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACtD,cAAc,IAAI,IAAI,CAAC;IACvB,sBAAsB,IAAI,IAAI,CAAC;IAC/B,uBAAuB,IAAI,IAAI,CAAC;IAChC,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,qBAAqB,CAAC;IACtC,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,6CAIhC,mBAAmB,KAAG,YAqFxB,CAAC"}

package/dist/crash-monitor.js

@@ -0,0 +1,75 @@
+import { NativeCrashError } from './errors.js';
+import { logger } from '@react-native-harness/tools';
+export const createCrashMonitor = ({ interval, platformRunner, bridgeServer, }) => {
+    let pollingInterval = null;
+    let isIntentionalRestart = false;
+    let currentTestFilePath = null;
+    let rejectFn = null;
+    const handleDisconnect = () => {
+        // Verify if it's actually a crash by checking if app is still running
+        if (!isIntentionalRestart && currentTestFilePath) {
+            // Capture the value to avoid it being null when setTimeout callback runs
+            const testFilePath = currentTestFilePath;
+            logger.debug('Bridge disconnected, checking if app crashed');
+            // Use a slight delay to allow the OS to clean up the process
+            setTimeout(async () => {
+                const isRunning = await platformRunner.isAppRunning();
+                if (!isRunning && !isIntentionalRestart && rejectFn) {
+                    logger.debug(`Native crash detected during: ${testFilePath}`);
+                    rejectFn(new NativeCrashError(testFilePath));
+                }
+            }, 100);
+        }
+    };
+    const startMonitoring = (testFilePath) => {
+        currentTestFilePath = testFilePath;
+        return new Promise((_, reject) => {
+            rejectFn = reject;
+            // Listen for bridge disconnect as early indicator
+            bridgeServer.on('disconnect', handleDisconnect);
+            // Poll for app running status
+            pollingInterval = setInterval(async () => {
+                // Skip check during intentional restarts
+                if (isIntentionalRestart) {
+                    return;
+                }
+                try {
+                    const isRunning = await platformRunner.isAppRunning();
+                    if (!isRunning && currentTestFilePath) {
+                        logger.debug(`Native crash detected during: ${currentTestFilePath}`);
+                        stopMonitoring();
+                        reject(new NativeCrashError(currentTestFilePath));
+                    }
+                }
+                catch (error) {
+                    logger.error('Error checking app status:', error);
+                }
+            }, interval);
+        });
+    };
+    const stopMonitoring = () => {
+        if (pollingInterval) {
+            clearInterval(pollingInterval);
+            pollingInterval = null;
+        }
+        bridgeServer.off('disconnect', handleDisconnect);
+        currentTestFilePath = null;
+        rejectFn = null;
+    };
+    const markIntentionalRestart = () => {
+        isIntentionalRestart = true;
+    };
+    const clearIntentionalRestart = () => {
+        isIntentionalRestart = false;
+    };
+    const dispose = () => {
+        stopMonitoring();
+    };
+    return {
+        startMonitoring,
+        stopMonitoring,
+        markIntentionalRestart,
+        clearIntentionalRestart,
+        dispose,
+    };
+};

package/dist/errors.d.ts

@@ -9,4 +9,12 @@ export declare class RunnerNotFoundError extends HarnessError {
 export declare class InitializationTimeoutError extends HarnessError {
     constructor();
 }
+export declare class MaxAppRestartsError extends HarnessError {
+    constructor(attempts: number);
+}
+export declare class NativeCrashError extends HarnessError {
+    readonly testFilePath: string;
+    readonly lastKnownTest?: string | undefined;
+    constructor(testFilePath: string, lastKnownTest?: string | undefined);
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,qBAAa,sBAAuB,SAAQ,YAAY;;CAKvD;AAED,qBAAa,mBAAoB,SAAQ,YAAY;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,0BAA2B,SAAQ,YAAY;;CAK3D"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,qBAAa,sBAAuB,SAAQ,YAAY;;CAKvD;AAED,qBAAa,mBAAoB,SAAQ,YAAY;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,0BAA2B,SAAQ,YAAY;;CAK3D;AAED,qBAAa,mBAAoB,SAAQ,YAAY;gBACvC,QAAQ,EAAE,MAAM;CAO7B;AAED,qBAAa,gBAAiB,SAAQ,YAAY;aAE9B,YAAY,EAAE,MAAM;aACpB,aAAa,CAAC,EAAE,MAAM;gBADtB,YAAY,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,MAAM,YAAA;CAKzC"}

package/dist/errors.js

@@ -19,3 +19,20 @@ export class InitializationTimeoutError extends HarnessError {
         this.name = 'InitializationTimeoutError';
     }
 }
+export class MaxAppRestartsError extends HarnessError {
+    constructor(attempts) {
+        super(`App failed to start after ${attempts} attempts. ` +
+            `No bundling activity detected within timeout period.`);
+        this.name = 'MaxAppRestartsError';
+    }
+}
+export class NativeCrashError extends HarnessError {
+    testFilePath;
+    lastKnownTest;
+    constructor(testFilePath, lastKnownTest) {
+        super('The native app crashed during test execution.');
+        this.testFilePath = testFilePath;
+        this.lastKnownTest = lastKnownTest;
+        this.name = 'NativeCrashError';
+    }
+}

package/dist/event-mapper.d.ts

@@ -0,0 +1,16 @@
+import type { TestEvents } from '@jest/test-result';
+import type { Test } from 'jest-runner';
+import type { BridgeEvents } from '@react-native-harness/bridge';
+import type { TestCaseResult } from '@jest/test-result';
+export type EventMapperState = {
+    currentTest?: Test;
+    suiteHierarchy: string[];
+    testResults: Map<string, TestCaseResult>;
+    fileStartTime: number;
+};
+export type HarnessEventMapper = {
+    handleBridgeEvent: (event: BridgeEvents, test: Test) => void;
+    reset: () => void;
+};
+export declare const getHarnessEventMapper: (emit: <T extends keyof TestEvents>(eventName: T, eventData: TestEvents[T]) => void) => HarnessEventMapper;
+//# sourceMappingURL=event-mapper.d.ts.map

package/dist/event-mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-mapper.d.ts","sourceRoot":"","sources":["../src/event-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EASV,YAAY,EACb,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACzC,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,iBAAiB,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IAC7D,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,MAAM,CAAC,CAAC,SAAS,MAAM,UAAU,EAC/B,SAAS,EAAE,CAAC,EACZ,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,KACrB,IAAI,KACR,kBA8JF,CAAC"}

package/dist/event-mapper.js

@@ -0,0 +1,120 @@
+export const getHarnessEventMapper = (emit) => {
+    const state = {
+        suiteHierarchy: [],
+        testResults: new Map(),
+        fileStartTime: 0,
+    };
+    const handleBridgeEvent = (event, test) => {
+        // Filter to only process test runner events
+        if (event.type.startsWith('test-') ||
+            event.type.startsWith('suite-') ||
+            event.type.startsWith('file-')) {
+            switch (event.type) {
+                case 'file-started':
+                    handleFileStarted(event, test);
+                    break;
+                case 'file-finished':
+                    handleFileFinished(event, test);
+                    break;
+                case 'suite-started':
+                    handleSuiteStarted(event);
+                    break;
+                case 'suite-finished':
+                    handleSuiteFinished(event);
+                    break;
+                case 'test-started':
+                    handleTestStarted(event, test);
+                    break;
+                case 'test-finished':
+                    handleTestFinished(event, test);
+                    break;
+            }
+        }
+    };
+    const handleFileStarted = (event, test) => {
+        state.currentTest = test;
+        state.fileStartTime = Date.now();
+        state.suiteHierarchy = [];
+        state.testResults.clear();
+        // Don't emit test-file-start here - that should be handled by the Jest runner
+        // when it actually starts running the test file
+    };
+    const handleFileFinished = (_event, _test) => {
+        // File finished - all test results should already be emitted
+        // The final TestResult will be handled by the runHarnessTestFile function
+    };
+    const handleSuiteStarted = (event) => {
+        state.suiteHierarchy.push(event.name);
+    };
+    const handleSuiteFinished = (event) => {
+        // Remove the suite from hierarchy when it finishes
+        const index = state.suiteHierarchy.lastIndexOf(event.name);
+        if (index !== -1) {
+            state.suiteHierarchy.splice(index, 1);
+        }
+    };
+    const handleTestStarted = (event, test) => {
+        const testCaseStartInfo = {
+            ancestorTitles: [...state.suiteHierarchy],
+            fullName: `${state.suiteHierarchy.join(' ')} ${event.name}`.trim(),
+            title: event.name,
+            mode: 'skip', // Default mode, will be updated based on test status
+        };
+        emit('test-case-start', [test.path, testCaseStartInfo]);
+    };
+    const handleTestFinished = (event, test) => {
+        const testCaseResult = {
+            ancestorTitles: [...state.suiteHierarchy],
+            duration: event.duration,
+            failureDetails: [],
+            failureMessages: event.error ? [formatError(event.error)] : [],
+            fullName: `${state.suiteHierarchy.join(' ')} ${event.name}`.trim(),
+            numPassingAsserts: event.status === 'passed' ? 1 : 0,
+            status: mapStatus(event.status),
+            title: event.name,
+            startedAt: Date.now() - event.duration,
+        };
+        state.testResults.set(event.name, testCaseResult);
+        emit('test-case-result', [test.path, testCaseResult]);
+    };
+    const mapStatus = (status) => {
+        return status;
+    };
+    const formatError = (error) => {
+        let errorMessage = `${error.name}: ${error.message}`;
+        if (error.codeFrame) {
+            errorMessage += '\n\n' + formatCodeFrame(error.codeFrame);
+        }
+        return errorMessage;
+    };
+    const formatCodeFrame = (codeFrame) => {
+        const lines = codeFrame.content.split('\n');
+        const lineNumber = codeFrame.location?.row || 1;
+        const column = codeFrame.location?.column || 1;
+        let formatted = `\n${codeFrame.fileName}:${lineNumber}:${column}\n`;
+        // Add context lines around the error
+        const startLine = Math.max(0, lineNumber - 3);
+        const endLine = Math.min(lines.length, lineNumber + 2);
+        for (let i = startLine; i < endLine; i++) {
+            const lineNum = i + 1;
+            const line = lines[i];
+            const isErrorLine = lineNum === lineNumber;
+            formatted += `${lineNum.toString().padStart(3)} | ${line}\n`;
+            if (isErrorLine && column > 0) {
+                const pointer = ' '.repeat(column + 5) + '^';
+                formatted += pointer + '\n';
+            }
+        }
+        return formatted;
+    };
+    const reset = () => {
+        state.suiteHierarchy = [];
+        state.testResults.clear();
+        state.fileStartTime = 0;
+        state.currentTest = undefined;
+    };
+    return {
+        handleBridgeEvent,
+        reset,
+    };
+};