@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.class.test.js

@@ -0,0 +1,202 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const classState = vi.hoisted(() => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    },
+    networkInstances: [],
+    playwrightInstances: [],
+}));
+vi.mock('@utils/logger', () => ({
+    logger: classState.logger,
+}));
+vi.mock('@modules/monitor/NetworkMonitor', () => {
+    class NetworkMonitor {
+        enable = vi.fn(async () => { });
+        disable = vi.fn(async () => { });
+        isEnabled = vi.fn(() => true);
+        getStatus = vi.fn(() => ({
+            enabled: true,
+            requestCount: 0,
+            responseCount: 0,
+            listenerCount: 0,
+            cdpSessionActive: true,
+        }));
+        getRequests = vi.fn(() => []);
+        getResponses = vi.fn(() => []);
+        getActivity = vi.fn(() => ({}));
+        getResponseBody = vi.fn(async () => null);
+        getAllJavaScriptResponses = vi.fn(async () => []);
+        clearRecords = vi.fn();
+        clearInjectedBuffers = vi.fn(async () => ({ xhrCleared: 0, fetchCleared: 0 }));
+        resetInjectedInterceptors = vi.fn(async () => ({ xhrReset: true, fetchReset: true }));
+        getStats = vi.fn(() => ({
+            totalRequests: 0,
+            totalResponses: 0,
+            byMethod: {},
+            byStatus: {},
+            byType: {},
+        }));
+        injectXHRInterceptor = vi.fn(async () => { });
+        injectFetchInterceptor = vi.fn(async () => { });
+        getXHRRequests = vi.fn(async () => []);
+        getFetchRequests = vi.fn(async () => []);
+        constructor(_session) {
+            classState.networkInstances.push(this);
+        }
+    }
+    return { NetworkMonitor };
+});
+vi.mock('@modules/monitor/PlaywrightNetworkMonitor', () => {
+    class PlaywrightNetworkMonitor {
+        enable = vi.fn(async () => { });
+        disable = vi.fn(async () => { });
+        isEnabled = vi.fn(() => true);
+        getStatus = vi.fn(() => ({
+            enabled: true,
+            requestCount: 0,
+            responseCount: 0,
+            listenerCount: 0,
+            cdpSessionActive: false,
+        }));
+        getRequests = vi.fn(() => []);
+        getResponses = vi.fn(() => []);
+        getActivity = vi.fn(() => ({}));
+        getResponseBody = vi.fn(async () => null);
+        getAllJavaScriptResponses = vi.fn(async () => []);
+        clearRecords = vi.fn();
+        clearInjectedBuffers = vi.fn(async () => ({ xhrCleared: 0, fetchCleared: 0 }));
+        resetInjectedInterceptors = vi.fn(async () => ({ xhrReset: true, fetchReset: true }));
+        getStats = vi.fn(() => ({
+            totalRequests: 0,
+            totalResponses: 0,
+            byMethod: {},
+            byStatus: {},
+            byType: {},
+        }));
+        injectXHRInterceptor = vi.fn(async () => { });
+        injectFetchInterceptor = vi.fn(async () => { });
+        getXHRRequests = vi.fn(async () => []);
+        getFetchRequests = vi.fn(async () => []);
+        setPage = vi.fn();
+        constructor(_page) {
+            classState.playwrightInstances.push(this);
+        }
+    }
+    return { PlaywrightNetworkMonitor };
+});
+import { ConsoleMonitor } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.class.js';
+function createCdpSession() {
+    const listeners = new Map();
+    const session = {
+        send: vi.fn(async (_method) => ({})),
+        on: vi.fn((event, handler) => {
+            const handlers = listeners.get(event) ?? new Set();
+            handlers.add(handler);
+            listeners.set(event, handlers);
+        }),
+        off: vi.fn((event, handler) => {
+            listeners.get(event)?.delete(handler);
+        }),
+        detach: vi.fn().mockResolvedValue(undefined),
+        emit(event, payload) {
+            listeners.get(event)?.forEach((handler) => handler(payload));
+        },
+    };
+    return session;
+}
+describe('ConsoleMonitor.impl.core.class.ts', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        classState.networkInstances.length = 0;
+        classState.playwrightInstances.length = 0;
+    });
+    it('enables CDP mode, captures console and exception events, and attaches network monitoring', async () => {
+        const session = createCdpSession();
+        const monitor = new ConsoleMonitor({
+            getActivePage: vi.fn().mockResolvedValue({
+                createCDPSession: vi.fn().mockResolvedValue(session),
+            }),
+        });
+        await monitor.enable({ enableNetwork: true, enableExceptions: true });
+        session.emit('Runtime.consoleAPICalled', {
+            type: 'warn',
+            args: [{ value: 'careful' }],
+            timestamp: 123,
+            stackTrace: {
+                callFrames: [
+                    {
+                        functionName: 'handler',
+                        url: 'https://site/app.js',
+                        lineNumber: 4,
+                        columnNumber: 2,
+                    },
+                ],
+            },
+        });
+        session.emit('Runtime.exceptionThrown', {
+            exceptionDetails: {
+                text: 'boom',
+                exceptionId: 9,
+                stackTrace: {
+                    callFrames: [
+                        {
+                            functionName: 'explode',
+                            url: 'https://site/app.js',
+                            lineNumber: 8,
+                            columnNumber: 1,
+                        },
+                    ],
+                },
+                url: 'https://site/app.js',
+                lineNumber: 8,
+                columnNumber: 1,
+            },
+        });
+        expect(session.send).toHaveBeenCalledWith('Runtime.enable');
+        expect(session.send).toHaveBeenCalledWith('Console.enable');
+        expect(classState.networkInstances).toHaveLength(1);
+        expect(classState.networkInstances[0]?.enable).toHaveBeenCalledTimes(1);
+        expect(monitor.getLogs({ type: 'warn' })[0]).toMatchObject({
+            text: 'careful',
+            url: 'https://site/app.js',
+            lineNumber: 4,
+        });
+        expect(monitor.getExceptions()[0]).toMatchObject({
+            text: 'boom',
+            url: 'https://site/app.js',
+            lineNumber: 8,
+        });
+    });
+    it('uses Playwright mode when a page is attached and cleans handlers on disable', async () => {
+        const handlers = {};
+        const page = {
+            on: vi.fn((event, handler) => {
+                handlers[event] = handler;
+            }),
+            off: vi.fn((event, handler) => {
+                if (handlers[event] === handler) {
+                    delete handlers[event];
+                }
+            }),
+        };
+        const monitor = new ConsoleMonitor({ getActivePage: vi.fn() });
+        monitor.setPlaywrightPage(page);
+        await monitor.enable({ enableNetwork: true, enableExceptions: true });
+        handlers.console?.({
+            type: () => 'log',
+            text: () => 'from-playwright',
+        });
+        handlers.pageerror?.(new Error('page exploded'));
+        expect(classState.playwrightInstances).toHaveLength(1);
+        expect(classState.playwrightInstances[0]?.enable).toHaveBeenCalledTimes(1);
+        expect(monitor.getLogs({ type: 'log' })[0]?.text).toBe('from-playwright');
+        expect(monitor.getExceptions()[0]?.text).toBe('page exploded');
+        await monitor.disable();
+        expect(page.off).toHaveBeenCalledWith('console', expect.any(Function));
+        expect(page.off).toHaveBeenCalledWith('pageerror', expect.any(Function));
+        expect(classState.playwrightInstances[0]?.disable).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.dynamic.test.d.ts

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

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.dynamic.test.js

@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: loggerState,
+}));
+import { PrerequisiteError } from '../../../src/errors/PrerequisiteError.js';
+import { clearDynamicScriptBufferCore, enableDynamicScriptMonitoringCore, getDynamicScriptsCore, injectFunctionTracerCore, injectPropertyWatcherCore, resetDynamicScriptMonitoringCore, } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.dynamic.js';
+describe('ConsoleMonitor dynamic script helpers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('installs the dynamic monitor and generates tracer/watcher expressions', async () => {
+        const send = vi.fn(async () => ({ result: { value: [] } }));
+        const ctx = {
+            ensureSession: vi.fn(async () => { }),
+            cdpSession: { send },
+            MAX_INJECTED_DYNAMIC_SCRIPTS: 25,
+        };
+        await enableDynamicScriptMonitoringCore(ctx);
+        await injectFunctionTracerCore(ctx, 'fetch');
+        await injectPropertyWatcherCore(ctx, 'window.navigator', 'userAgent');
+        expect(send).toHaveBeenNthCalledWith(1, 'Runtime.evaluate', expect.objectContaining({
+            expression: expect.stringContaining('const maxRecords = 25;'),
+        }));
+        expect(send).toHaveBeenNthCalledWith(2, 'Runtime.evaluate', expect.objectContaining({
+            expression: expect.stringContaining('window.fetch = new Proxy'),
+        }));
+        expect(send).toHaveBeenNthCalledWith(3, 'Runtime.evaluate', expect.objectContaining({
+            expression: expect.stringContaining('Property watcher installed for window.navigator.userAgent'),
+        }));
+    });
+    it('reads, clears and resets dynamic monitor state from return-by-value expressions', async () => {
+        const send = vi
+            .fn()
+            .mockResolvedValueOnce({
+            result: {
+                value: [{ type: 'dynamic', src: '/app.js' }],
+            },
+        })
+            .mockResolvedValueOnce({
+            result: {
+                value: { dynamicScriptsCleared: 2 },
+            },
+        })
+            .mockResolvedValueOnce({
+            result: {
+                value: { scriptMonitorReset: true },
+            },
+        });
+        const ctx = {
+            ensureSession: vi.fn(async () => { }),
+            cdpSession: { send },
+            MAX_INJECTED_DYNAMIC_SCRIPTS: 10,
+        };
+        await expect(getDynamicScriptsCore(ctx)).resolves.toEqual([{ type: 'dynamic', src: '/app.js' }]);
+        await expect(clearDynamicScriptBufferCore(ctx)).resolves.toEqual({ dynamicScriptsCleared: 2 });
+        await expect(resetDynamicScriptMonitoringCore(ctx)).resolves.toEqual({ scriptMonitorReset: true });
+    });
+    it('returns safe fallbacks or prerequisite errors when no session is available', async () => {
+        const ctx = {
+            ensureSession: vi.fn(async () => { }),
+            cdpSession: null,
+            MAX_INJECTED_DYNAMIC_SCRIPTS: 10,
+        };
+        await expect(clearDynamicScriptBufferCore(ctx)).resolves.toEqual({ dynamicScriptsCleared: 0 });
+        await expect(resetDynamicScriptMonitoringCore(ctx)).resolves.toEqual({ scriptMonitorReset: false });
+        await expect(getDynamicScriptsCore(ctx)).rejects.toBeInstanceOf(PrerequisiteError);
+        await expect(injectFunctionTracerCore(ctx, 'fetch')).rejects.toBeInstanceOf(PrerequisiteError);
+        await expect(injectPropertyWatcherCore(ctx, 'window', 'name')).rejects.toBeInstanceOf(PrerequisiteError);
+    });
+});

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.logs.test.d.ts

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

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.logs.test.js

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: loggerState,
+}));
+import { clearExceptionsCore, clearLogsCore, getExceptionsCore, getLogsCore, getStatsCore, } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.logs.js';
+describe('ConsoleMonitor logs core helpers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('filters logs by type, timestamp and limit and reports stats', () => {
+        const ctx = {
+            messages: [
+                { type: 'log', text: 'a', timestamp: 1 },
+                { type: 'warn', text: 'b', timestamp: 5 },
+                { type: 'warn', text: 'c', timestamp: 10 },
+            ],
+            exceptions: [],
+        };
+        expect(getLogsCore(ctx, { type: 'warn', since: 2, limit: 1 })).toEqual([
+            { type: 'warn', text: 'c', timestamp: 10 },
+        ]);
+        expect(getStatsCore(ctx)).toEqual({
+            totalMessages: 3,
+            byType: { log: 1, warn: 2 },
+        });
+        expect(loggerState.debug).toHaveBeenCalled();
+    });
+    it('filters and clears exceptions and logs collections', () => {
+        const ctx = {
+            messages: [{ type: 'error', text: 'boom', timestamp: 20 }],
+            exceptions: [
+                { message: 'x', timestamp: 1, url: 'https://a.test/x.js' },
+                { message: 'y', timestamp: 10, url: 'https://a.test/y.js' },
+            ],
+        };
+        expect(getExceptionsCore(ctx, { url: 'y.js', since: 5 })).toEqual([
+            { message: 'y', timestamp: 10, url: 'https://a.test/y.js' },
+        ]);
+        clearLogsCore(ctx);
+        clearExceptionsCore(ctx);
+        expect(ctx.messages).toEqual([]);
+        expect(ctx.exceptions).toEqual([]);
+        expect(loggerState.info).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.network.test.d.ts

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

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.network.test.js

@@ -0,0 +1,134 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: loggerState,
+}));
+import { PrerequisiteError } from '../../../src/errors/PrerequisiteError.js';
+import { clearInjectedBuffersCore, clearNetworkRecordsCore, getAllJavaScriptResponsesCore, getFetchRequestsCore, getNetworkActivityCore, getNetworkRequestsCore, getNetworkResponsesCore, getNetworkStatsCore, getNetworkStatusCore, getResponseBodyCore, getXHRRequestsCore, injectFetchInterceptorCore, injectXHRInterceptorCore, isNetworkEnabledCore, resetInjectedInterceptorsCore, } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.network.js';
+function createMonitor(enabled = true) {
+    return {
+        isEnabled: vi.fn(() => enabled),
+        getStatus: vi.fn(() => ({
+            enabled,
+            requestCount: 1,
+            responseCount: 2,
+            listenerCount: 3,
+            cdpSessionActive: true,
+        })),
+        getRequests: vi.fn(() => [{ requestId: 'req-1' }]),
+        getResponses: vi.fn(() => [{ requestId: 'req-1', status: 200 }]),
+        getActivity: vi.fn(() => ({ request: { requestId: 'req-1' } })),
+        getResponseBody: vi.fn(async () => ({ body: 'payload', base64Encoded: false })),
+        getAllJavaScriptResponses: vi.fn(async () => [{ requestId: 'js-1' }]),
+        clearRecords: vi.fn(),
+        clearInjectedBuffers: vi.fn(async () => ({ xhrCleared: 1, fetchCleared: 2 })),
+        resetInjectedInterceptors: vi.fn(async () => ({ xhrReset: true, fetchReset: true })),
+        getStats: vi.fn(() => ({
+            totalRequests: 1,
+            totalResponses: 1,
+            byMethod: { GET: 1 },
+            byStatus: { 200: 1 },
+            byType: { XHR: 1 },
+        })),
+        injectXHRInterceptor: vi.fn(async () => { }),
+        injectFetchInterceptor: vi.fn(async () => { }),
+        getXHRRequests: vi.fn(async () => [{ id: 'xhr' }]),
+        getFetchRequests: vi.fn(async () => [{ id: 'fetch' }]),
+    };
+}
+describe('ConsoleMonitor network core helpers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('falls back to inert defaults when no network monitor is configured', async () => {
+        const ctx = {
+            cdpSession: null,
+            clearDynamicScriptBuffer: vi.fn(async () => ({ dynamicScriptsCleared: 0 })),
+            resetDynamicScriptMonitoring: vi.fn(async () => ({ scriptMonitorReset: false })),
+        };
+        expect(isNetworkEnabledCore(ctx)).toBe(false);
+        expect(getNetworkStatusCore(ctx)).toEqual({
+            enabled: false,
+            requestCount: 0,
+            responseCount: 0,
+            listenerCount: 0,
+            cdpSessionActive: false,
+        });
+        expect(getNetworkRequestsCore(ctx)).toEqual([]);
+        expect(getNetworkResponsesCore(ctx)).toEqual([]);
+        expect(getNetworkActivityCore(ctx, 'req-1')).toEqual({});
+        await expect(getResponseBodyCore(ctx, 'req-1')).resolves.toBeNull();
+        await expect(getAllJavaScriptResponsesCore(ctx)).resolves.toEqual([]);
+        await expect(getXHRRequestsCore(ctx)).resolves.toEqual([]);
+        await expect(getFetchRequestsCore(ctx)).resolves.toEqual([]);
+        expect(getNetworkStatsCore(ctx)).toEqual({
+            totalRequests: 0,
+            totalResponses: 0,
+            byMethod: {},
+            byStatus: {},
+            byType: {},
+        });
+        expect(loggerState.error).toHaveBeenCalled();
+    });
+    it('delegates reads and reset operations to the playwright monitor when present', async () => {
+        const playwrightNetworkMonitor = createMonitor(true);
+        const ctx = {
+            playwrightNetworkMonitor,
+            networkMonitor: createMonitor(false),
+            cdpSession: {},
+            clearDynamicScriptBuffer: vi.fn(async () => ({ dynamicScriptsCleared: 99 })),
+            resetDynamicScriptMonitoring: vi.fn(async () => ({ scriptMonitorReset: true })),
+        };
+        expect(isNetworkEnabledCore(ctx)).toBe(true);
+        expect(getNetworkStatusCore(ctx).requestCount).toBe(1);
+        expect(getNetworkRequestsCore(ctx)).toEqual([{ requestId: 'req-1' }]);
+        expect(getNetworkResponsesCore(ctx)).toEqual([{ requestId: 'req-1', status: 200 }]);
+        await expect(getResponseBodyCore(ctx, 'req-1')).resolves.toEqual({
+            body: 'payload',
+            base64Encoded: false,
+        });
+        await expect(clearInjectedBuffersCore(ctx)).resolves.toEqual({
+            xhrCleared: 1,
+            fetchCleared: 2,
+            dynamicScriptsCleared: 0,
+        });
+        await expect(resetInjectedInterceptorsCore(ctx)).resolves.toEqual({
+            xhrReset: true,
+            fetchReset: true,
+            scriptMonitorReset: false,
+        });
+        clearNetworkRecordsCore(ctx);
+        expect(playwrightNetworkMonitor.clearRecords).toHaveBeenCalled();
+    });
+    it('combines CDP monitor and dynamic-script results and validates interceptor prerequisites', async () => {
+        const networkMonitor = createMonitor(true);
+        const ctx = {
+            networkMonitor,
+            cdpSession: {},
+            clearDynamicScriptBuffer: vi.fn(async () => ({ dynamicScriptsCleared: 4 })),
+            resetDynamicScriptMonitoring: vi.fn(async () => ({ scriptMonitorReset: true })),
+        };
+        await expect(clearInjectedBuffersCore(ctx)).resolves.toEqual({
+            xhrCleared: 1,
+            fetchCleared: 2,
+            dynamicScriptsCleared: 4,
+        });
+        await expect(resetInjectedInterceptorsCore(ctx)).resolves.toEqual({
+            xhrReset: true,
+            fetchReset: true,
+            scriptMonitorReset: true,
+        });
+        await expect(injectXHRInterceptorCore(ctx)).resolves.toBeUndefined();
+        await expect(injectFetchInterceptorCore(ctx)).resolves.toBeUndefined();
+        await expect(injectXHRInterceptorCore({
+            cdpSession: {},
+            clearDynamicScriptBuffer: vi.fn(),
+            resetDynamicScriptMonitoring: vi.fn(),
+        })).rejects.toBeInstanceOf(PrerequisiteError);
+    });
+});

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.object-cache.test.d.ts

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

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.object-cache.test.js

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: loggerState,
+}));
+import { clearObjectCacheCore, inspectObjectCore, } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.object-cache.js';
+describe('ConsoleMonitor object cache helpers', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('inspects objects through CDP, normalizes property values and caches the result', async () => {
+        const send = vi.fn(async () => ({
+            result: [
+                { name: 'count', value: { type: 'number', value: 3 } },
+                { name: 'nested', value: { type: 'object', objectId: 'obj-2', description: 'Object' } },
+            ],
+        }));
+        const ctx = {
+            ensureSession: vi.fn(async () => { }),
+            cdpSession: { send },
+            objectCache: new Map(),
+            MAX_OBJECT_CACHE_SIZE: 2,
+            extractValue: vi.fn((value) => value.value ?? `[${value.type}]`),
+        };
+        const first = await inspectObjectCore(ctx, 'obj-1');
+        const second = await inspectObjectCore(ctx, 'obj-1');
+        expect(first).toEqual({
+            count: { value: 3, type: 'number', objectId: undefined, description: undefined },
+            nested: { value: '[object]', type: 'object', objectId: 'obj-2', description: 'Object' },
+        });
+        expect(second).toBe(first);
+        expect(send).toHaveBeenCalledTimes(1);
+    });
+    it('evicts the oldest cached entry when the cache is at capacity and can be cleared', async () => {
+        const send = vi.fn(async ({ objectId }) => ({
+            result: [{ name: 'id', value: { type: 'string', value: objectId } }],
+        }));
+        const ctx = {
+            ensureSession: vi.fn(async () => { }),
+            cdpSession: { send: vi.fn(async (_method, params) => send(params)) },
+            objectCache: new Map([
+                ['oldest', { id: { value: 'oldest', type: 'string' } }],
+            ]),
+            MAX_OBJECT_CACHE_SIZE: 1,
+            extractValue: vi.fn((value) => value.value),
+        };
+        await inspectObjectCore(ctx, 'new-object');
+        expect(ctx.objectCache.has('oldest')).toBe(false);
+        expect(ctx.objectCache.has('new-object')).toBe(true);
+        clearObjectCacheCore(ctx);
+        expect(ctx.objectCache.size).toBe(0);
+        expect(loggerState.info).toHaveBeenCalled();
+    });
+});

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.test.d.ts

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

package/dist/tests/modules/monitor/ConsoleMonitor.impl.core.test.js

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest';
+import { ConsoleMonitor as CoreConsoleMonitor } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.js';
+import { ConsoleMonitor as ClassConsoleMonitor } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.class.js';
+describe('ConsoleMonitor.impl.core.ts', () => {
+    it('re-exports the ConsoleMonitor class from the class module', () => {
+        expect(CoreConsoleMonitor).toBe(ClassConsoleMonitor);
+    });
+});

package/dist/tests/modules/monitor/ConsoleMonitor.impl.reexports.test.d.ts

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

package/dist/tests/modules/monitor/ConsoleMonitor.impl.reexports.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest';
+import { ConsoleMonitor as ImplConsoleMonitor } from '../../../src/modules/monitor/ConsoleMonitor.impl.js';
+import { ConsoleMonitor as CoreConsoleMonitor } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.js';
+import { ConsoleMonitor as ClassConsoleMonitor } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.class.js';
+describe('ConsoleMonitor internal re-exports', () => {
+    it('exposes the same ConsoleMonitor class through impl and core wrappers', () => {
+        expect(ImplConsoleMonitor).toBe(ClassConsoleMonitor);
+        expect(CoreConsoleMonitor).toBe(ClassConsoleMonitor);
+    });
+});

package/dist/tests/modules/monitor/ConsoleMonitor.impl.test.d.ts

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

package/dist/tests/modules/monitor/ConsoleMonitor.impl.test.js

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest';
+import { ConsoleMonitor as ImplConsoleMonitor } from '../../../src/modules/monitor/ConsoleMonitor.impl.js';
+import { ConsoleMonitor as CoreConsoleMonitor } from '../../../src/modules/monitor/ConsoleMonitor.impl.core.js';
+describe('ConsoleMonitor.impl.ts', () => {
+    it('re-exports the internal ConsoleMonitor class', () => {
+        expect(ImplConsoleMonitor).toBe(CoreConsoleMonitor);
+    });
+});

package/dist/tests/modules/monitor/NetworkMonitor.impl.additional.test.d.ts

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