@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/tests/modules/collector/CodeCache.test.js

@@ -1,86 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { CodeCache } from '../../../src/modules/collector/CodeCache.js';
-const sampleResult = {
-    files: [
-        {
-            url: 'https://vmoranv.github.io/jshookmcp/app.js',
-            content: 'console.log("hello")',
-            size: 20,
-            type: 'external',
-        },
-    ],
-    dependencies: { nodes: [], edges: [] },
-    totalSize: 20,
-    collectTime: 5,
-};
-describe('CodeCache', () => {
-    let cacheDir;
-    beforeEach(async () => {
-        cacheDir = await mkdtemp(join(tmpdir(), 'jshook-cache-'));
-    });
-    afterEach(async () => {
-        await rm(cacheDir, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('initializes cache directory', async () => {
-        const cache = new CodeCache({ cacheDir });
-        await expect(cache.init()).resolves.toBeUndefined();
-    });
-    it('stores and retrieves values from cache', async () => {
-        const cache = new CodeCache({ cacheDir, maxAge: 60_000 });
-        await cache.set('https://vmoranv.github.io/jshookmcp', sampleResult);
-        const result = await cache.get('https://vmoranv.github.io/jshookmcp');
-        expect(result).not.toBeNull();
-        expect(result?.files[0]?.url).toBe('https://vmoranv.github.io/jshookmcp/app.js');
-        expect(result?.totalSize).toBe(20);
-    });
-    it('returns null for expired entries', async () => {
-        const cache = new CodeCache({ cacheDir, maxAge: 1 });
-        await cache.set('https://vmoranv.github.io/jshookmcp/expired', sampleResult);
-        await new Promise((resolve) => setTimeout(resolve, 5));
-        const result = await cache.get('https://vmoranv.github.io/jshookmcp/expired');
-        expect(result).toBeNull();
-    });
-    it('cleanup removes oldest files when exceeding max size', async () => {
-        const cache = new CodeCache({ cacheDir, maxSize: 200, maxAge: 60_000 });
-        for (let i = 0; i < 6; i++) {
-            await cache.set(`https://vmoranv.github.io/jshookmcp/${i}`, {
-                ...sampleResult,
-                files: [
-                    {
-                        url: `https://vmoranv.github.io/jshookmcp/${i}.js`,
-                        content: 'x'.repeat(300),
-                        size: 300,
-                        type: 'external',
-                    },
-                ],
-                totalSize: 300,
-            });
-            await new Promise((resolve) => setTimeout(resolve, 2));
-        }
-        const before = await cache.getStats();
-        await cache.cleanup();
-        const after = await cache.getStats();
-        expect(before.diskEntries).toBeGreaterThan(0);
-        expect(after.diskEntries).toBeLessThan(before.diskEntries);
-    });
-    it('clear removes both memory and disk cache entries', async () => {
-        const cache = new CodeCache({ cacheDir, maxAge: 60_000 });
-        await cache.set('https://vmoranv.github.io/jshookmcp/a', sampleResult);
-        await cache.set('https://vmoranv.github.io/jshookmcp/b', sampleResult);
-        expect((await cache.getStats()).diskEntries).toBeGreaterThan(0);
-        await cache.clear();
-        const stats = await cache.getStats();
-        expect(stats.diskEntries).toBe(0);
-        expect(stats.memoryEntries).toBe(0);
-    });
-    it('warmup calls get for each provided URL', async () => {
-        const cache = new CodeCache({ cacheDir });
-        const getSpy = vi.spyOn(cache, 'get').mockResolvedValue(null);
-        await cache.warmup(['https://vmoranv.github.io/jshookmcp/one', 'https://vmoranv.github.io/jshookmcp/two']);
-        expect(getSpy).toHaveBeenCalledTimes(2);
-    });
-});

package/dist/tests/modules/collector/CodeCollector.test.d.ts

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

package/dist/tests/modules/collector/CodeCollector.test.js

@@ -1,128 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const launchMock = vi.hoisted(() => vi.fn());
-const connectMock = vi.hoisted(() => vi.fn());
-const findBrowserExecutableMock = vi.hoisted(() => vi.fn());
-vi.mock('rebrowser-puppeteer-core', () => ({
-    default: {
-        launch: launchMock,
-        connect: connectMock,
-    },
-}));
-vi.mock('@src/utils/browserExecutable', () => ({
-    findBrowserExecutable: findBrowserExecutableMock,
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        success: vi.fn(),
-    },
-}));
-import { CodeCollector } from '../../../src/modules/collector/CodeCollector.js';
-function createBrowserMock() {
-    return {
-        on: vi.fn(),
-        pages: vi.fn().mockResolvedValue([]),
-        newPage: vi.fn(),
-        close: vi.fn().mockResolvedValue(undefined),
-        disconnect: vi.fn().mockResolvedValue(undefined),
-        version: vi.fn().mockResolvedValue('Chrome/123'),
-    };
-}
-describe('CodeCollector', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        findBrowserExecutableMock.mockReturnValue(undefined);
-    });
-    it('initializes browser and reports running status', async () => {
-        const browser = createBrowserMock();
-        launchMock.mockResolvedValue(browser);
-        const collector = new CodeCollector({ headless: true, timeout: 1000 });
-        await collector.init();
-        expect(launchMock).toHaveBeenCalledTimes(1);
-        await expect(collector.getStatus()).resolves.toMatchObject({
-            running: true,
-            pagesCount: 0,
-            effectiveHeadless: true,
-        });
-    });
-    it('throws when configured executablePath does not exist', async () => {
-        const collector = new CodeCollector({
-            headless: true,
-            timeout: 1000,
-            executablePath: 'C:\\definitely-not-existing\\browser.exe',
-        });
-        await expect(collector.init()).rejects.toThrow('Configured browser executable was not found');
-        expect(launchMock).not.toHaveBeenCalled();
-    });
-    it('does not auto-relaunch after an explicit close until init is called again', async () => {
-        const browser = createBrowserMock();
-        const relaunchedBrowser = createBrowserMock();
-        launchMock.mockResolvedValueOnce(browser).mockResolvedValueOnce(relaunchedBrowser);
-        const collector = new CodeCollector({ headless: true, timeout: 1000 });
-        await collector.init();
-        await collector.close();
-        await expect(collector.getActivePage()).rejects.toThrow('Browser was explicitly closed. Call browser_launch or browser_attach first.');
-        expect(launchMock).toHaveBeenCalledTimes(1);
-        await collector.init();
-        expect(launchMock).toHaveBeenCalledTimes(2);
-    });
-    it('filters URLs against wildcard rules', () => {
-        const collector = new CodeCollector({ headless: true, timeout: 1000 });
-        expect(collector.shouldCollectUrl('https://vmoranv.github.io/jshookmcp/app.js', ['*vmoranv.github.io/jshookmcp/*'])).toBe(true);
-        expect(collector.shouldCollectUrl('https://cdn.other.com/lib.js', ['*vmoranv.github.io/jshookmcp/*'])).toBe(false);
-    });
-    it('retries navigation until success', async () => {
-        const collector = new CodeCollector({ headless: true, timeout: 1000 });
-        const page = {
-            goto: vi
-                .fn()
-                .mockRejectedValueOnce(new Error('temporary'))
-                .mockResolvedValueOnce(undefined),
-        };
-        await expect(collector.navigateWithRetry(page, 'https://vmoranv.github.io/jshookmcp', { waitUntil: 'load' }, 3)).resolves.toBeUndefined();
-        expect(page.goto).toHaveBeenCalledTimes(2);
-    });
-    it('throws last navigation error after max retries', async () => {
-        const collector = new CodeCollector({ headless: true, timeout: 1000 });
-        const page = { goto: vi.fn().mockRejectedValue(new Error('fatal')) };
-        await expect(collector.navigateWithRetry(page, 'https://vmoranv.github.io/jshookmcp', { waitUntil: 'load' }, 2)).rejects.toThrow('fatal');
-        expect(page.goto).toHaveBeenCalledTimes(2);
-    });
-    it('returns pattern-matched files with size limits and truncation flag', () => {
-        const collector = new CodeCollector({ headless: true, timeout: 1000 });
-        collector.collectedFilesCache = new Map([
-            ['https://site/a.js', { url: 'https://site/a.js', content: 'a'.repeat(10), size: 10, type: 'external' }],
-            ['https://site/b.js', { url: 'https://site/b.js', content: 'b'.repeat(10), size: 10, type: 'external' }],
-            ['https://site/c.css', { url: 'https://site/c.css', content: 'c', size: 1, type: 'external' }],
-        ]);
-        const result = collector.getFilesByPattern('\\.js$', 3, 15);
-        expect(result.matched).toBe(2);
-        expect(result.returned).toBe(1);
-        expect(result.truncated).toBe(true);
-        expect(result.totalSize).toBe(10);
-    });
-    it('returns top priority files ordered by scoring helper', () => {
-        const collector = new CodeCollector({ headless: true, timeout: 1000 });
-        collector.collectedFilesCache = new Map([
-            [
-                'https://site/vendor.js',
-                { url: 'https://site/vendor.js', content: 'noop', size: 2000, type: 'external' },
-            ],
-            [
-                'https://site/crypto-api-main.js',
-                {
-                    url: 'https://site/crypto-api-main.js',
-                    content: 'fetch("/x"); const cipher = "aes";',
-                    size: 800,
-                    type: 'inline',
-                },
-            ],
-        ]);
-        const result = collector.getTopPriorityFiles(1, 100_000);
-        expect(result.files).toHaveLength(1);
-        expect(result.files[0]?.url).toContain('crypto-api-main.js');
-    });
-});

package/dist/tests/modules/collector/CodeCompressor.test.d.ts

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

package/dist/tests/modules/collector/CodeCompressor.test.js

@@ -1,69 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-vi.mock('@src/utils/logger', () => ({
-    logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        success: vi.fn(),
-    },
-}));
-import { CodeCompressor } from '../../../src/modules/collector/CodeCompressor.js';
-describe('CodeCompressor', () => {
-    it('compresses and decompresses roundtrip content', async () => {
-        const compressor = new CodeCompressor();
-        const source = 'const x = 1;'.repeat(200);
-        const compressed = await compressor.compress(source);
-        const restored = await compressor.decompress(compressed.compressed);
-        expect(restored).toBe(source);
-        expect(compressed.originalSize).toBe(source.length);
-    });
-    it('uses cache on repeated compression with same input', async () => {
-        const compressor = new CodeCompressor();
-        const source = 'cache-me'.repeat(100);
-        await compressor.compress(source, { useCache: true });
-        await compressor.compress(source, { useCache: true });
-        const stats = compressor.getStats();
-        expect(stats.cacheMisses).toBeGreaterThanOrEqual(1);
-        expect(stats.cacheHits).toBeGreaterThanOrEqual(1);
-    });
-    it('falls back to base64 passthrough when batch item compression fails', async () => {
-        const compressor = new CodeCompressor();
-        const originalCompress = compressor.compress.bind(compressor);
-        vi.spyOn(compressor, 'compress').mockImplementation(async (code, options) => {
-            if (code.includes('bad-item')) {
-                throw new Error('forced failure');
-            }
-            return originalCompress(code, options);
-        });
-        const result = await compressor.compressBatch([
-            { url: 'good.js', content: 'good-content'.repeat(50) },
-            { url: 'bad.js', content: 'bad-item' },
-        ]);
-        const bad = result.find((item) => item.url === 'bad.js');
-        expect(bad).toBeDefined();
-        expect(bad?.compressionRatio).toBe(0);
-        expect(bad?.compressed).toBe(Buffer.from('bad-item').toString('base64'));
-    });
-    it('evaluates compression thresholds correctly', () => {
-        const compressor = new CodeCompressor();
-        expect(compressor.shouldCompress('x'.repeat(1025))).toBe(true);
-        expect(compressor.shouldCompress('x'.repeat(1000), 2000)).toBe(false);
-    });
-    it('selects compression levels by input size', () => {
-        const compressor = new CodeCompressor();
-        expect(compressor.selectCompressionLevel(5 * 1024)).toBe(1);
-        expect(compressor.selectCompressionLevel(50 * 1024)).toBe(6);
-        expect(compressor.selectCompressionLevel(300 * 1024)).toBe(9);
-        expect(compressor.selectCompressionLevel(2 * 1024 * 1024)).toBe(6);
-    });
-    it('stream-compresses large payload into multiple chunks', async () => {
-        const compressor = new CodeCompressor();
-        const onProgress = vi.fn();
-        const source = 'stream-payload-'.repeat(500);
-        const result = await compressor.compressStream(source, { chunkSize: 512, onProgress });
-        expect(result.chunks).toBeGreaterThan(1);
-        expect(result.originalSize).toBe(source.length);
-        expect(onProgress).toHaveBeenCalled();
-    });
-});

package/dist/tests/modules/collector/DOMInspector.test.d.ts

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

package/dist/tests/modules/collector/DOMInspector.test.js

@@ -1,142 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-vi.mock('@src/utils/logger', () => ({
-    logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        success: vi.fn(),
-    },
-}));
-import { DOMInspector } from '../../../src/modules/collector/DOMInspector.js';
-describe('DOMInspector', () => {
-    let page;
-    let collector;
-    let inspector;
-    beforeEach(() => {
-        page = {
-            evaluate: vi.fn(),
-            waitForSelector: vi.fn(),
-            frames: vi.fn(() => [{}]),
-        };
-        collector = {
-            getActivePage: vi.fn().mockResolvedValue(page),
-        };
-        inspector = new DOMInspector(collector);
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it('returns selector metadata when element exists', async () => {
-        page.evaluate.mockResolvedValue({
-            found: true,
-            nodeName: 'BUTTON',
-            textContent: 'Submit',
-            visible: true,
-        });
-        const result = await inspector.querySelector('#submit');
-        expect(result.found).toBe(true);
-        expect(result.nodeName).toBe('BUTTON');
-        expect(page.evaluate).toHaveBeenCalled();
-    });
-    it('returns found=false when querySelector evaluation fails', async () => {
-        page.evaluate.mockRejectedValue(new Error('eval failed'));
-        const result = await inspector.querySelector('.missing');
-        expect(result).toEqual({ found: false });
-    });
-    it('returns elements with diagnostics from querySelectorAll', async () => {
-        page.evaluate
-            .mockResolvedValueOnce('complete')
-            .mockResolvedValueOnce({
-            elements: [
-                { found: true, nodeName: 'DIV', textContent: 'A' },
-                { found: true, nodeName: 'DIV', textContent: 'B' },
-            ],
-            diagnostics: { readyState: 'complete', shadowRootCount: 0 },
-        });
-        const result = await inspector.querySelectorAll('.item', 2);
-        expect(result.elements).toHaveLength(2);
-        expect(result.elements[1]?.textContent).toBe('B');
-        expect(result.diagnostics).toMatchObject({
-            readyState: 'complete',
-            frameCount: 1,
-            shadowRootCount: 0,
-            retried: false,
-            waitedForReadyState: false,
-        });
-    });
-    it('waits for document readyState before querying', async () => {
-        vi.useFakeTimers();
-        page.evaluate
-            .mockResolvedValueOnce('loading')
-            .mockResolvedValueOnce('interactive')
-            .mockResolvedValueOnce('complete')
-            .mockResolvedValueOnce({
-            elements: [{ found: true, nodeName: 'INPUT', textContent: '' }],
-            diagnostics: { readyState: 'complete', shadowRootCount: 0 },
-        });
-        const resultPromise = inspector.querySelectorAll('input', 5);
-        await vi.advanceTimersByTimeAsync(300);
-        const result = await resultPromise;
-        expect(result.elements).toHaveLength(1);
-        expect(result.diagnostics.waitedForReadyState).toBe(true);
-        expect(page.evaluate).toHaveBeenCalledTimes(4);
-    });
-    it('retries once when querySelectorAll is empty after hydration', async () => {
-        vi.useFakeTimers();
-        page.evaluate
-            .mockResolvedValueOnce('complete')
-            .mockResolvedValueOnce({
-            elements: [],
-            diagnostics: { readyState: 'complete', shadowRootCount: 0 },
-        })
-            .mockResolvedValueOnce({
-            elements: [{ found: true, nodeName: 'INPUT', textContent: 'email' }],
-            diagnostics: { readyState: 'complete', shadowRootCount: 1 },
-        });
-        const resultPromise = inspector.querySelectorAll('input', 5);
-        await vi.advanceTimersByTimeAsync(500);
-        const result = await resultPromise;
-        expect(result.elements).toHaveLength(1);
-        expect(result.diagnostics.retried).toBe(true);
-        expect(result.diagnostics.shadowRootCount).toBe(1);
-    });
-    it('returns clickable elements with shadow DOM diagnostics', async () => {
-        page.evaluate
-            .mockResolvedValueOnce('complete')
-            .mockResolvedValueOnce({
-            elements: [
-                {
-                    selector: '#submit',
-                    text: 'Submit',
-                    type: 'button',
-                    visible: true,
-                },
-            ],
-            diagnostics: { readyState: 'complete', shadowRootCount: 2 },
-        });
-        const result = await inspector.findClickable('submit');
-        expect(result.elements).toHaveLength(1);
-        expect(result.elements[0]?.selector).toBe('#submit');
-        expect(result.diagnostics).toMatchObject({
-            readyState: 'complete',
-            shadowRootCount: 2,
-            retried: false,
-        });
-    });
-    it('waitForElement returns null on timeout error', async () => {
-        page.waitForSelector.mockRejectedValue(new Error('timeout'));
-        const result = await inspector.waitForElement('#slow', 5);
-        expect(result).toBeNull();
-    });
-    it('returns null when computed style query throws', async () => {
-        page.evaluate.mockRejectedValue(new Error('style error'));
-        await expect(inspector.getComputedStyle('.btn')).resolves.toBeNull();
-    });
-    it('closes and detaches cdp session when present', async () => {
-        const detach = vi.fn().mockResolvedValue(undefined);
-        inspector.cdpSession = { detach };
-        await inspector.close();
-        expect(detach).toHaveBeenCalledTimes(1);
-    });
-});

package/dist/tests/modules/collector/PageController.test.d.ts

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

package/dist/tests/modules/collector/PageController.test.js

@@ -1,73 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-vi.mock('@src/utils/logger', () => ({
-    logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        success: vi.fn(),
-    },
-}));
-import { PageController } from '../../../src/modules/collector/PageController.js';
-describe('PageController', () => {
-    let page;
-    let collector;
-    let controller;
-    beforeEach(() => {
-        page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            title: vi.fn().mockResolvedValue('Demo'),
-            url: vi.fn().mockReturnValue('https://vmoranv.github.io/jshookmcp/final'),
-            click: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn(),
-            waitForSelector: vi.fn().mockResolvedValue(undefined),
-            setViewport: vi.fn().mockResolvedValue(undefined),
-            setUserAgent: vi.fn().mockResolvedValue(undefined),
-            $: vi.fn(),
-        };
-        collector = { getActivePage: vi.fn().mockResolvedValue(page) };
-        controller = new PageController(collector);
-    });
-    it('navigates with defaults and returns page metadata', async () => {
-        const result = await controller.navigate('https://vmoranv.github.io/jshookmcp');
-        expect(page.goto).toHaveBeenCalledWith('https://vmoranv.github.io/jshookmcp', {
-            waitUntil: 'networkidle2',
-            timeout: 30000,
-        });
-        expect(result.url).toBe('https://vmoranv.github.io/jshookmcp/final');
-        expect(result.title).toBe('Demo');
-    });
-    it('click uses default click options', async () => {
-        await controller.click('#submit');
-        expect(page.click).toHaveBeenCalledWith('#submit', {
-            button: 'left',
-            clickCount: 1,
-            delay: undefined,
-        });
-    });
-    it('waitForSelector returns success payload when element appears', async () => {
-        page.evaluate.mockResolvedValue({ tagName: 'button', id: 'submit' });
-        const result = await controller.waitForSelector('#submit', 1000);
-        expect(result.success).toBe(true);
-        expect(result.element?.id).toBe('submit');
-    });
-    it('waitForSelector returns failure payload on timeout', async () => {
-        page.waitForSelector.mockRejectedValue(new Error('timeout'));
-        const result = await controller.waitForSelector('#missing', 10);
-        expect(result.success).toBe(false);
-        expect(result.message).toContain('Timeout waiting for selector');
-    });
-    it('emulateDevice resolves aliases and applies device settings', async () => {
-        const resolved = await controller.emulateDevice('iPhone 13 Pro');
-        expect(resolved).toBe('iPhone');
-        expect(page.setViewport).toHaveBeenCalled();
-        expect(page.setUserAgent).toHaveBeenCalled();
-    });
-    it('emulateDevice rejects unsupported device names', async () => {
-        await expect(controller.emulateDevice('BlackBerry Classic')).rejects.toThrow('Unsupported device');
-    });
-    it('uploadFile throws when file input element is missing', async () => {
-        page.$.mockResolvedValue(null);
-        await expect(controller.uploadFile('#upload', 'D:/tmp/a.txt')).rejects.toThrow('File input not found');
-    });
-});

package/dist/tests/modules/collector/PageScriptCollectors.test.d.ts

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

package/dist/tests/modules/collector/PageScriptCollectors.test.js

@@ -1,87 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-vi.mock('@src/utils/logger', () => ({
-    logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        success: vi.fn(),
-    },
-}));
-import { analyzeDependencies, calculatePriorityScore, collectInlineScripts, collectServiceWorkers, collectWebWorkers, extractDependencies, } from '../../../src/modules/collector/PageScriptCollectors.js';
-describe('PageScriptCollectors', () => {
-    it('extractDependencies parses import/require/dynamic import uniquely', () => {
-        const code = `
-      import x from './a';
-      const y = require("./b");
-      const z = import('./a');
-    `;
-        const deps = extractDependencies(code);
-        expect(deps.sort()).toEqual(['./a', './b']);
-    });
-    it('analyzeDependencies builds nodes and import edges', () => {
-        const files = [
-            { url: 'https://site/a.js', content: `import b from "b";`, type: 'external', size: 10 },
-            { url: 'https://site/b.js', content: 'export default 1', type: 'external', size: 10 },
-        ];
-        const graph = analyzeDependencies(files);
-        expect(graph.nodes).toHaveLength(2);
-        expect(graph.edges).toEqual([
-            { from: 'https://site/a.js', to: 'https://site/b.js', type: 'import' },
-        ]);
-    });
-    it('calculatePriorityScore rewards meaningful urls and penalizes vendor bundles', () => {
-        const high = calculatePriorityScore({
-            url: 'https://x/main-crypto-api.js',
-            type: 'inline',
-            size: 5000,
-            content: '',
-        });
-        const low = calculatePriorityScore({
-            url: 'https://x/vendor/ui-framework.bundle.js',
-            type: 'external',
-            size: 400000,
-            content: '',
-        });
-        expect(high).toBeGreaterThan(low);
-    });
-    it('collectInlineScripts applies max file cap and preserves metadata', async () => {
-        const page = {
-            evaluate: vi.fn().mockResolvedValue([
-                { url: 'inline-script-0', content: 'a', size: 1, type: 'inline', metadata: { truncated: false } },
-                { url: 'inline-script-1', content: 'b', size: 1, type: 'inline', metadata: { truncated: true } },
-                { url: 'inline-script-2', content: 'c', size: 1, type: 'inline', metadata: { truncated: false } },
-            ]),
-        };
-        const result = await collectInlineScripts(page, 10, 2);
-        expect(result).toHaveLength(2);
-        expect(result[1]?.metadata?.truncated).toBe(true);
-    });
-    it('collectServiceWorkers gathers successful worker scripts and skips failed ones', async () => {
-        const page = {
-            evaluate: vi
-                .fn()
-                .mockResolvedValueOnce([
-                { url: 'https://site/sw-1.js', scope: '/', state: 'activated' },
-                { url: 'https://site/sw-2.js', scope: '/', state: 'activated' },
-            ])
-                .mockResolvedValueOnce('self.addEventListener("fetch",()=>{})')
-                .mockRejectedValueOnce(new Error('fetch failed')),
-        };
-        const files = await collectServiceWorkers(page);
-        expect(files).toHaveLength(1);
-        expect(files[0]?.type).toBe('service-worker');
-        expect(files[0]?.url).toContain('sw-1.js');
-    });
-    it('collectWebWorkers resolves relative URLs against current page URL', async () => {
-        const page = {
-            evaluateOnNewDocument: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValueOnce(['/worker.js']).mockResolvedValueOnce('onmessage=()=>{}'),
-            url: vi.fn().mockReturnValue('https://site/app/index.html'),
-        };
-        const files = await collectWebWorkers(page);
-        expect(files).toHaveLength(1);
-        expect(files[0]?.url).toBe('https://site/worker.js');
-        expect(files[0]?.type).toBe('web-worker');
-    });
-});

package/dist/tests/modules/collector/SmartCodeCollector.test.d.ts

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