@react-native-harness/jest 1.2.0-rc.1 → 1.3.0

package/dist/__tests__/harness-session.test.js

@@ -0,0 +1,250 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createHarnessSession } from '../harness-session.js';
+const pluginManagerMocks = vi.hoisted(() => ({
+    callHook: vi.fn(async () => undefined),
+}));
+const getConfigMock = vi.hoisted(() => vi.fn());
+const resolveHarnessMetroPortMock = vi.hoisted(() => vi.fn());
+const getMetroInstanceMock = vi.hoisted(() => vi.fn());
+const createHarnessBridgeMock = vi.hoisted(() => vi.fn());
+const createCrashMonitorMock = vi.hoisted(() => vi.fn());
+vi.mock('@react-native-harness/plugins', async () => {
+    const actual = await vi.importActual('@react-native-harness/plugins');
+    return {
+        ...actual,
+        createHarnessPluginManager: vi.fn(() => ({
+            callHook: pluginManagerMocks.callHook,
+        })),
+    };
+});
+vi.mock('@react-native-harness/config', async () => {
+    const actual = await vi.importActual('@react-native-harness/config');
+    return {
+        ...actual,
+        getConfig: getConfigMock,
+    };
+});
+vi.mock('../metro-port.js', async () => {
+    const actual = await vi.importActual('../metro-port.js');
+    return {
+        ...actual,
+        resolveHarnessMetroPort: resolveHarnessMetroPortMock,
+    };
+});
+vi.mock('@react-native-harness/bundler-metro', async () => {
+    const actual = await vi.importActual('@react-native-harness/bundler-metro');
+    return {
+        ...actual,
+        getMetroInstance: getMetroInstanceMock,
+    };
+});
+vi.mock('@react-native-harness/bridge/server', async () => {
+    const actual = await vi.importActual('@react-native-harness/bridge/server');
+    return {
+        ...actual,
+        createHarnessBridge: createHarnessBridgeMock,
+    };
+});
+vi.mock('../crash-monitor.js', async () => {
+    const actual = await vi.importActual('../crash-monitor.js');
+    return {
+        ...actual,
+        createCrashMonitor: createCrashMonitorMock,
+    };
+});
+const createAppMonitor = () => ({
+    start: vi.fn(async () => undefined),
+    stop: vi.fn(async () => undefined),
+    dispose: vi.fn(async () => undefined),
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+});
+const makeBridge = () => ({
+    ws: {},
+    connection: null,
+    on: vi.fn(),
+    off: vi.fn(),
+    nextConnection: vi.fn(),
+    dispose: vi.fn(async () => undefined),
+});
+const makeMetroInstance = () => ({
+    events: {
+        addListener: vi.fn(),
+        removeListener: vi.fn(),
+    },
+    waitUntilHealthy: vi.fn(async () => 'packager-status:running'),
+    prewarm: vi.fn(async () => false),
+    dispose: vi.fn(async () => undefined),
+});
+const makeLockManager = () => ({
+    acquire: vi.fn(async () => ({
+        release: vi.fn(async () => undefined),
+    })),
+});
+const makeCrashMonitor = () => ({
+    watch: vi.fn(),
+    isAlive: vi.fn(() => false),
+    stop: vi.fn(async () => undefined),
+    start: vi.fn(async () => undefined),
+    reset: vi.fn(),
+    dispose: vi.fn(async () => undefined),
+});
+const makeDeviceState = () => ({
+    permissions: {
+        apply: vi.fn(async () => ({ mutation: null })),
+        revert: vi.fn(),
+        resetOutstanding: vi.fn(async () => undefined),
+    },
+});
+const makePlatformRunner = (overrides = {}) => ({
+    startApp: vi.fn(async () => undefined),
+    restartApp: vi.fn(async () => undefined),
+    stopApp: vi.fn(async () => undefined),
+    dispose: vi.fn(async () => undefined),
+    isAppRunning: vi.fn(async () => false),
+    createAppMonitor: vi.fn(() => createAppMonitor()),
+    ...overrides,
+});
+const globalConfig = {
+    rootDir: '/project',
+    watch: false,
+    watchAll: false,
+    collectCoverage: false,
+};
+const harnessConfig = {
+    entryPoint: 'index.js',
+    appRegistryComponentName: 'App',
+    runners: [
+        {
+            name: 'ios',
+            platformId: 'ios',
+            runner: './__tests__/fixtures/mock-platform-runner.ts',
+            config: {},
+        },
+    ],
+    defaultRunner: 'ios',
+    metroPort: 8081,
+    bridgeTimeout: 1000,
+    platformReadyTimeout: 1000,
+    bundleStartTimeout: 1000,
+    maxAppRestarts: 1,
+    resetEnvironmentBetweenTestFiles: true,
+    detectNativeCrashes: false,
+    forwardClientLogs: false,
+    permissions: false,
+    plugins: [],
+    unstable__skipAlreadyIncludedModules: false,
+    unstable__enableMetroCache: false,
+    disableViewFlattening: false,
+};
+describe('createHarnessSession permission cleanup', () => {
+    let bridge;
+    let metroInstance;
+    let crashMonitor;
+    let lockManager;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        bridge = makeBridge();
+        metroInstance = makeMetroInstance();
+        crashMonitor = makeCrashMonitor();
+        lockManager = makeLockManager();
+        getConfigMock.mockResolvedValue({ config: harnessConfig });
+        resolveHarnessMetroPortMock.mockResolvedValue({
+            config: harnessConfig,
+            initialMetroPort: 8081,
+            didFallback: false,
+            metroPortLease: { release: vi.fn(async () => undefined) },
+        });
+        getMetroInstanceMock.mockResolvedValue(metroInstance);
+        createHarnessBridgeMock.mockResolvedValue(bridge);
+        createCrashMonitorMock.mockReturnValue(crashMonitor);
+    });
+    afterEach(() => {
+        delete globalThis.__HARNESS_TEST_PLATFORM_RUNNER__;
+    });
+    it('resets outstanding permission mutations before restart between test files', async () => {
+        const deviceState = makeDeviceState();
+        const platformRunner = makePlatformRunner({
+            deviceState,
+            isAppRunning: vi.fn(async () => true),
+        });
+        bridge.connection = {};
+        crashMonitor.isAlive.mockReturnValue(true);
+        globalThis.__HARNESS_TEST_PLATFORM_RUNNER__ = platformRunner;
+        const session = await createHarnessSession(globalConfig, { lockManager });
+        const callOrder = [];
+        deviceState.permissions.resetOutstanding.mockImplementation(async () => {
+            callOrder.push('resetOutstanding');
+        });
+        platformRunner.stopApp = vi.fn(async () => {
+            callOrder.push('stopApp');
+        });
+        await session.restartApp('/test/example.ts');
+        expect(deviceState.permissions.resetOutstanding).toHaveBeenCalledTimes(1);
+        expect(deviceState.permissions.apply).not.toHaveBeenCalled();
+        expect(callOrder).toEqual(['resetOutstanding', 'stopApp']);
+        await session.dispose();
+    });
+    it('reapplies configured permissions after cleanup before restart between test files', async () => {
+        const deviceState = makeDeviceState();
+        const platformRunner = makePlatformRunner({
+            deviceState,
+            isAppRunning: vi.fn(async () => true),
+        });
+        bridge.connection = {};
+        crashMonitor.isAlive.mockReturnValue(true);
+        globalThis.__HARNESS_TEST_PLATFORM_RUNNER__ = platformRunner;
+        const permissionsEnabledConfig = {
+            ...harnessConfig,
+            permissions: true,
+        };
+        getConfigMock.mockResolvedValue({ config: permissionsEnabledConfig });
+        resolveHarnessMetroPortMock.mockResolvedValue({
+            config: permissionsEnabledConfig,
+            initialMetroPort: 8081,
+            didFallback: false,
+            metroPortLease: { release: vi.fn(async () => undefined) },
+        });
+        const session = await createHarnessSession(globalConfig, { lockManager });
+        const callOrder = [];
+        deviceState.permissions.apply.mockClear();
+        deviceState.permissions.resetOutstanding.mockImplementation(async () => {
+            callOrder.push('resetOutstanding');
+        });
+        deviceState.permissions.apply.mockImplementation(async () => {
+            callOrder.push('applyConfiguredPermissions');
+            return { mutation: null };
+        });
+        platformRunner.stopApp = vi.fn(async () => {
+            callOrder.push('stopApp');
+        });
+        await session.restartApp('/test/example.ts');
+        expect(deviceState.permissions.resetOutstanding).toHaveBeenCalledTimes(1);
+        expect(deviceState.permissions.apply).toHaveBeenCalledWith({
+            kind: 'permission-all',
+            decision: 'grant',
+        });
+        expect(callOrder).toEqual([
+            'resetOutstanding',
+            'applyConfiguredPermissions',
+            'stopApp',
+        ]);
+        await session.dispose();
+    });
+    it('resets outstanding permission mutations during dispose', async () => {
+        const deviceState = makeDeviceState();
+        const callOrder = [];
+        const platformRunner = makePlatformRunner({ deviceState });
+        deviceState.permissions.resetOutstanding.mockImplementation(async () => {
+            callOrder.push('resetOutstanding');
+        });
+        platformRunner.dispose = vi.fn(async () => {
+            callOrder.push('dispose');
+        });
+        globalThis.__HARNESS_TEST_PLATFORM_RUNNER__ = platformRunner;
+        const session = await createHarnessSession(globalConfig, { lockManager });
+        await session.dispose();
+        expect(deviceState.permissions.resetOutstanding).toHaveBeenCalledTimes(1);
+        expect(callOrder).toEqual(['resetOutstanding', 'dispose']);
+    });
+});

package/dist/__tests__/hook-queue.test.d.ts

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

package/dist/__tests__/hook-queue.test.d.ts.map

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

package/dist/__tests__/hook-queue.test.js

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+import { createHookQueue } from '../hook-queue.js';
+describe('createHookQueue', () => {
+    it('executes scheduled work in FIFO order', async () => {
+        const queue = createHookQueue();
+        const order = [];
+        queue.schedule(async () => { order.push(1); });
+        queue.schedule(async () => { order.push(2); });
+        queue.schedule(async () => { order.push(3); });
+        await queue.drain();
+        expect(order).toEqual([1, 2, 3]);
+    });
+    it('drain awaits async work before resolving', async () => {
+        const queue = createHookQueue();
+        let resolved = false;
+        queue.schedule(async () => {
+            await new Promise((r) => setTimeout(r, 20));
+            resolved = true;
+        });
+        expect(resolved).toBe(false);
+        await queue.drain();
+        expect(resolved).toBe(true);
+    });
+    it('drain resolves immediately when nothing is scheduled', async () => {
+        const queue = createHookQueue();
+        await expect(queue.drain()).resolves.toBeUndefined();
+    });
+    it('captures the first error and re-throws it on drain', async () => {
+        const queue = createHookQueue();
+        const err = new Error('hook failed');
+        queue.schedule(async () => { throw err; });
+        await expect(queue.drain()).rejects.toBe(err);
+    });
+    it('continues executing subsequent hooks after one throws', async () => {
+        const queue = createHookQueue();
+        const ran = [];
+        queue.schedule(async () => { throw new Error('first'); });
+        queue.schedule(async () => { ran.push('second'); });
+        queue.schedule(async () => { ran.push('third'); });
+        await expect(queue.drain()).rejects.toThrow('first');
+        expect(ran).toEqual(['second', 'third']);
+    });
+    it('error is cleared after drain re-throws it', async () => {
+        const queue = createHookQueue();
+        queue.schedule(async () => { throw new Error('once'); });
+        await expect(queue.drain()).rejects.toThrow('once');
+        // Second drain should see no accumulated error.
+        await expect(queue.drain()).resolves.toBeUndefined();
+    });
+    it('surfaces only the first error when multiple hooks throw', async () => {
+        const queue = createHookQueue();
+        queue.schedule(async () => { throw new Error('first'); });
+        queue.schedule(async () => { throw new Error('second'); });
+        await expect(queue.drain()).rejects.toThrow('first');
+    });
+});

package/dist/__tests__/index.test.js

@@ -1,42 +1,99 @@
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { HarnessError } from '@react-native-harness/tools';
 import JestHarness from '../index.js';
-import { StartupStallError } from '../errors.js';
+const resolveUndefined = async () => undefined;
+// ---------------------------------------------------------------------------
+// Module mocks
+// ---------------------------------------------------------------------------
+const mockSession = {
+    config: { metroPort: 8081 },
+    context: {},
+    ensureAppReady: vi.fn(resolveUndefined),
+    runTestFile: vi.fn(async () => ({
+        name: '',
+        tests: [],
+        suites: [],
+        status: 'passed',
+        duration: 0,
+    })),
+    restartApp: vi.fn(resolveUndefined),
+    resetCrashState: vi.fn(),
+    flushClientLogs: vi.fn(() => []),
+    callHook: vi.fn(resolveUndefined),
+    setRunState: vi.fn(),
+    dispose: vi.fn(resolveUndefined),
+};
+const mockCreateHarnessSession = vi.hoisted(() => vi.fn(async () => mockSession));
+const mockExecuteRun = vi.hoisted(() => vi.fn(async () => undefined));
+vi.mock('../harness-session.js', () => ({
+    createHarnessSession: mockCreateHarnessSession,
+}));
+vi.mock('../execute-run.js', () => ({
+    executeRun: mockExecuteRun,
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const makeOptions = () => ({ serial: true });
+const makeWatcher = () => ({ isInterrupted: () => false });
+const makeTest = () => ({
+    path: '/test/example.ts',
+    context: { config: {} },
+});
+const makeGlobalConfig = (overrides = {}) => ({ rootDir: '/project', watch: false, watchAll: false, collectCoverage: false, ...overrides });
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockSession.dispose.mockResolvedValue(undefined);
+    mockExecuteRun.mockResolvedValue(undefined);
+    mockCreateHarnessSession.mockResolvedValue(mockSession);
+});
 describe('JestHarness', () => {
-    it('reports StartupStallError without a stack trace', async () => {
-        const runner = new JestHarness({});
-        const onFailure = vi.fn();
-        const harness = {
-            ensureAppReady: vi
-                .fn()
-                .mockRejectedValue(new StartupStallError(1500, 3)),
-            callHook: vi.fn(async () => undefined),
-            setRunState: vi.fn(),
-            getRunState: vi.fn(() => null),
-            crashSupervisor: {
-                beginTestRun: vi.fn(),
-                waitForCrash: vi.fn(),
-                cancelCrashWaiters: vi.fn(),
-                reset: vi.fn(),
-            },
-        };
-        await runner._createInBandTestRun([
-            {
-                path: '/tmp/example.harness.ts',
-                context: {
-                    config: {},
-                },
-            },
-        ], {
-            isInterrupted: () => false,
-        }, harness, {
-            detectNativeCrashes: true,
-            resetEnvironmentBetweenTestFiles: false,
-        }, () => Promise.resolve(), () => Promise.resolve(), onFailure);
-        expect(onFailure).toHaveBeenCalledWith(expect.objectContaining({
-            path: '/tmp/example.harness.ts',
-        }), {
-            message: 'The app did not request its Metro bundle after 3 launch attempts within 1500ms. Last Metro status: unknown.',
-            stack: '',
+    describe('session lifecycle', () => {
+        it('creates a session on the first run', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
+        });
+        it('reuses the session across runs in watch mode', async () => {
+            const runner = new JestHarness(makeGlobalConfig({ watch: true }));
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
+            expect(mockSession.dispose).not.toHaveBeenCalled();
+        });
+        it('disposes the session after each run in normal mode', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            expect(mockSession.dispose).toHaveBeenCalledOnce();
+        });
+        it('creates a fresh session for each run in normal mode', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            expect(mockCreateHarnessSession).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('error handling', () => {
+        it('converts HarnessError into a formatted string before throwing', async () => {
+            class TestHarnessError extends HarnessError {
+                constructor() { super('something went wrong'); this.name = 'TestHarnessError'; }
+            }
+            mockCreateHarnessSession.mockRejectedValue(new TestHarnessError());
+            const runner = new JestHarness(makeGlobalConfig());
+            await expect(runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions())).rejects.toBeTypeOf('string');
+        });
+        it('propagates non-HarnessError exceptions as-is', async () => {
+            const cause = new TypeError('unexpected');
+            mockCreateHarnessSession.mockRejectedValue(cause);
+            const runner = new JestHarness(makeGlobalConfig());
+            await expect(runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions())).rejects.toBe(cause);
+        });
+        it('throws when called without serial flag', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            await expect(runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), { serial: false })).rejects.toThrow('Parallel test running is not supported');
         });
     });
 });

package/dist/__tests__/resource-lock.test.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { createResourceLockManager, hashResourceLockKey, } from '../resource-lock.js';
+import { createResourceLockManager } from '../resource-lock.js';
 describe('resource lock manager', () => {
     let rootDir;
     beforeEach(async () => {
@@ -54,10 +54,11 @@ describe('resource lock manager', () => {
         await expect(acquirePromise).rejects.toMatchObject({
             name: 'AbortError',
         });
-        const queueDir = path.join(rootDir, hashResourceLockKey(key), 'queue');
-        const queuedEntries = await fs.readdir(queueDir);
-        expect(queuedEntries).toHaveLength(0);
+        // The aborted waiter must have cleaned up its ticket. Verify by releasing
+        // the first lock and confirming a fresh acquire completes immediately.
         await firstLease.release();
+        const cleanupLease = await manager.acquire(key);
+        await cleanupLease.release();
     });
     it('keeps queued tickets alive while the waiting process is still active', async () => {
         const manager = createResourceLockManager({
@@ -76,29 +77,27 @@ describe('resource lock manager', () => {
         await secondLease.release();
     });
     it('reclaims a stale owner before granting the lock', async () => {
-        const manager = createResourceLockManager({
+        const key = 'web:browser:chromium';
+        // Simulate a live process holding the lock.
+        const manager1 = createResourceLockManager({
+            rootDir,
+            pollIntervalMs: 5,
+            heartbeatIntervalMs: 20,
+        });
+        const staleLease = await manager1.acquire(key);
+        // A second manager whose isProcessActive always returns false will consider
+        // any owner — including the live one above — immediately stale and reclaim it.
+        const manager2 = createResourceLockManager({
             rootDir,
             pollIntervalMs: 5,
             heartbeatIntervalMs: 20,
             staleLockTimeoutMs: 50,
             isProcessActive: () => false,
         });
-        const key = 'web:browser:chromium';
-        const keyDir = path.join(rootDir, hashResourceLockKey(key));
-        const queueDir = path.join(keyDir, 'queue');
-        const ownerFilePath = path.join(keyDir, 'owner.json');
-        await fs.mkdir(queueDir, { recursive: true });
-        await fs.writeFile(ownerFilePath, JSON.stringify({
-            ticketId: 'stale-owner',
-            key,
-            pid: 999999,
-            createdAt: Date.now() - 1000,
-            heartbeatAt: Date.now() - 1000,
-        }), 'utf8');
-        const lease = await manager.acquire(key);
-        const owner = JSON.parse(await fs.readFile(ownerFilePath, 'utf8'));
-        expect(owner.ticketId).not.toBe('stale-owner');
+        const lease = await manager2.acquire(key);
         await lease.release();
+        // manager1 was evicted; its release is best-effort.
+        await staleLease.release();
     });
     it('keeps owner metadata valid when heartbeat writes overlap', async () => {
         const manager = createResourceLockManager({
@@ -108,20 +107,21 @@ describe('resource lock manager', () => {
             staleLockTimeoutMs: 200,
         });
         const key = 'ios:simulator:iPhone 17 Pro:26.2';
-        const ownerFilePath = path.join(rootDir, hashResourceLockKey(key), 'owner.json');
         const actualWriteFile = fs.writeFile.bind(fs);
         const writeFileSpy = vi
             .spyOn(fs, 'writeFile')
             .mockImplementation(async (file, data, options) => {
-            if (typeof file === 'string' &&
-                file.startsWith(ownerFilePath) &&
-                file !== ownerFilePath) {
+            // Delay atomic temp-file writes to simulate overlapping heartbeat flushes.
+            if (typeof file === 'string' && file.startsWith(rootDir) && file.endsWith('.tmp')) {
                 await new Promise((resolve) => setTimeout(resolve, 25));
             }
             return await actualWriteFile(file, data, options);
         });
         try {
             const lease = await manager.acquire(key);
+            // Discover the owner file after acquire creates the key directory.
+            const [keyDirName] = await fs.readdir(rootDir);
+            const ownerFilePath = path.join(rootDir, keyDirName, 'owner.json');
             const initialOwner = JSON.parse(await fs.readFile(ownerFilePath, 'utf8'));
             await new Promise((resolve) => setTimeout(resolve, 80));
             for (let index = 0; index < 5; index += 1) {

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

@@ -1,23 +1,22 @@
 import type { ReportableEvent } from '@react-native-harness/bundler-metro';
+import type { TestResult as JestTestResult } from '@jest/test-result';
 export type ClientLogEvent = Extract<ReportableEvent, {
     type: 'client_log';
 }>;
+export type ClientLogBuffer = NonNullable<JestTestResult['console']>;
+export type ClientLogEntry = ClientLogBuffer[number];
+export type ClientLogCollector = {
+    handleEvent: (event: ReportableEvent) => void;
+    flush: () => ClientLogBuffer;
+};
 /**
  * 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.
+ * Formats a client log event into Jest's buffered console entry format.
  */
-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);
+export declare const formatClientLogEntry: (event: ClientLogEvent) => ClientLogEntry | null;
+export declare const createClientLogCollector: () => ClientLogCollector;
 //# sourceMappingURL=client-log-handler.d.ts.map

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

@@ -1 +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"}
+{"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;AAC3E,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGtE,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC;AAC9E,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;AACrE,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;AACrD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAC9C,KAAK,EAAE,MAAM,eAAe,CAAC;CAC9B,CAAC;AAuBF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,OAAO,EAAE,KAAG,MAMxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,KACpB,cAAc,GAAG,IAYnB,CAAC;AAEF,eAAO,MAAM,wBAAwB,QAAO,kBAoB3C,CAAC"}