@testsmith/perfornium 0.6.4 → 0.6.5

package/dist/protocols/rest/request/auth-handler.d.ts

@@ -0,0 +1,4 @@
+import { AxiosRequestConfig } from 'axios';
+export declare class AuthHandler {
+    static handleAuthentication(config: AxiosRequestConfig, headers: Record<string, string>, auth: any): void;
+}

package/dist/protocols/rest/request/auth-handler.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthHandler = void 0;
+class AuthHandler {
+    static handleAuthentication(config, headers, auth) {
+        switch (auth.type) {
+            case 'basic':
+                if (auth.username && auth.password) {
+                    config.auth = { username: auth.username, password: auth.password };
+                }
+                break;
+            case 'bearer':
+                if (auth.token) {
+                    headers['Authorization'] = `Bearer ${auth.token}`;
+                }
+                break;
+            case 'digest':
+                if (auth.username && auth.password) {
+                    config.auth = { username: auth.username, password: auth.password };
+                }
+                break;
+            case 'oauth':
+                if (auth.token) {
+                    headers['Authorization'] = `OAuth ${auth.token}`;
+                }
+                break;
+        }
+    }
+}
+exports.AuthHandler = AuthHandler;

package/dist/protocols/rest/request/body-processor.d.ts

@@ -0,0 +1,11 @@
+export declare class BodyProcessor {
+    static processBodyPayload(body: any): {
+        data: any;
+        contentType?: string;
+    };
+    static isJsonString(str: string): boolean;
+    static isXmlString(str: string): boolean;
+    static isTemplateString(body: string): boolean;
+    static detectTemplateContentType(templateBody: string): string | undefined;
+    static hasContentTypeHeader(headers: Record<string, string>): boolean;
+}

package/dist/protocols/rest/request/body-processor.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BodyProcessor = void 0;
+class BodyProcessor {
+    static processBodyPayload(body) {
+        if (typeof body === 'string') {
+            const trimmedBody = body.trim();
+            if (BodyProcessor.isJsonString(trimmedBody)) {
+                return { data: body, contentType: 'application/json' };
+            }
+            if (BodyProcessor.isXmlString(trimmedBody)) {
+                return { data: body, contentType: 'application/xml' };
+            }
+            if (BodyProcessor.isTemplateString(body)) {
+                const detectedType = BodyProcessor.detectTemplateContentType(body);
+                return { data: body, contentType: detectedType };
+            }
+            return { data: body, contentType: 'text/plain' };
+        }
+        else {
+            return { data: JSON.stringify(body), contentType: 'application/json' };
+        }
+    }
+    static isJsonString(str) {
+        if (!str.startsWith('{') && !str.startsWith('[')) {
+            return false;
+        }
+        try {
+            JSON.parse(str);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static isXmlString(str) {
+        return str.startsWith('<?xml') ||
+            (str.startsWith('<') && str.includes('>') && str.endsWith('>'));
+    }
+    static isTemplateString(body) {
+        return body.includes('{{template:') ||
+            (body.includes('{{') && body.includes('}}'));
+    }
+    static detectTemplateContentType(templateBody) {
+        const templateMatch = templateBody.match(/\{\{template:([^}]+)\}\}/);
+        if (templateMatch) {
+            const templatePath = templateMatch[1];
+            if (templatePath.endsWith('.json'))
+                return 'application/json';
+            if (templatePath.endsWith('.xml'))
+                return 'application/xml';
+        }
+        return undefined;
+    }
+    static hasContentTypeHeader(headers) {
+        if (!headers)
+            return false;
+        const headerKeys = Object.keys(headers).map(key => key.toLowerCase());
+        return headerKeys.includes('content-type');
+    }
+}
+exports.BodyProcessor = BodyProcessor;

package/dist/protocols/rest/request/index.d.ts

@@ -0,0 +1,2 @@
+export { BodyProcessor } from './body-processor';
+export { AuthHandler } from './auth-handler';

package/dist/protocols/rest/request/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthHandler = exports.BodyProcessor = void 0;
+var body_processor_1 = require("./body-processor");
+Object.defineProperty(exports, "BodyProcessor", { enumerable: true, get: function () { return body_processor_1.BodyProcessor; } });
+var auth_handler_1 = require("./auth-handler");
+Object.defineProperty(exports, "AuthHandler", { enumerable: true, get: function () { return auth_handler_1.AuthHandler; } });

package/dist/protocols/rest/response/checks.d.ts

@@ -0,0 +1,6 @@
+import { AxiosResponse } from 'axios';
+import { ProtocolResult } from '../../base';
+export declare class ResponseChecks {
+    static runChecks(checks: any[], response: AxiosResponse, duration: number, result: ProtocolResult): void;
+    static getJsonPath(obj: any, path: string): any;
+}

package/dist/protocols/rest/response/checks.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseChecks = void 0;
+class ResponseChecks {
+    static runChecks(checks, response, duration, result) {
+        let hasFailure = false;
+        const errors = [];
+        for (const check of checks) {
+            try {
+                let passed = true;
+                switch (check.type) {
+                    case 'status':
+                        passed = response.status === check.value;
+                        if (!passed)
+                            errors.push(`Expected status ${check.value}, got ${response.status}`);
+                        break;
+                    case 'response_time':
+                        const expectedTime = typeof check.value === 'string'
+                            ? parseInt(check.value.replace(/[<>]/g, ''))
+                            : check.value;
+                        if (check.operator === 'lt' || check.value.toString().startsWith('<')) {
+                            passed = duration < expectedTime;
+                            if (!passed)
+                                errors.push(`Response time ${duration}ms exceeded ${expectedTime}ms`);
+                        }
+                        break;
+                    case 'json_path':
+                        const value = ResponseChecks.getJsonPath(response.data, check.value);
+                        passed = value !== undefined && value !== null;
+                        if (!passed)
+                            errors.push(`JSON path ${check.value} not found`);
+                        break;
+                    case 'text_contains':
+                        const text = typeof response.data === 'string'
+                            ? response.data
+                            : JSON.stringify(response.data);
+                        passed = text.includes(check.value);
+                        if (!passed)
+                            errors.push(`Response does not contain "${check.value}"`);
+                        break;
+                }
+                if (!passed)
+                    hasFailure = true;
+            }
+            catch (error) {
+                errors.push(`Check error: ${error}`);
+                hasFailure = true;
+            }
+        }
+        if (hasFailure) {
+            result.success = false;
+            result.error = `Checks failed: ${errors.join(', ')}`;
+        }
+    }
+    static getJsonPath(obj, path) {
+        if (!obj)
+            return undefined;
+        const keys = path.replace(/^\$\./, '').split('.');
+        let current = obj;
+        for (const key of keys) {
+            if (current && typeof current === 'object' && key in current) {
+                current = current[key];
+            }
+            else {
+                return undefined;
+            }
+        }
+        return current;
+    }
+}
+exports.ResponseChecks = ResponseChecks;

package/dist/protocols/rest/response/index.d.ts

@@ -0,0 +1,2 @@
+export { SizeCalculator } from './size-calculator';
+export { ResponseChecks } from './checks';

package/dist/protocols/rest/response/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseChecks = exports.SizeCalculator = void 0;
+var size_calculator_1 = require("./size-calculator");
+Object.defineProperty(exports, "SizeCalculator", { enumerable: true, get: function () { return size_calculator_1.SizeCalculator; } });
+var checks_1 = require("./checks");
+Object.defineProperty(exports, "ResponseChecks", { enumerable: true, get: function () { return checks_1.ResponseChecks; } });

package/dist/protocols/rest/response/size-calculator.d.ts

@@ -0,0 +1,12 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+export declare class SizeCalculator {
+    static calculateRequestSizes(config: AxiosRequestConfig): {
+        requestHeadersSize: number;
+        requestBodySize: number;
+    };
+    static calculateResponseSizes(response: AxiosResponse, getResponseText: (data: any) => string): {
+        headersSize: number;
+        bodySize: number;
+    };
+    static detectDataType(response: AxiosResponse): 'text' | 'bin' | '';
+}

package/dist/protocols/rest/response/size-calculator.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SizeCalculator = void 0;
+class SizeCalculator {
+    static calculateRequestSizes(config) {
+        let requestHeadersSize = 0;
+        let requestBodySize = 0;
+        if (config.headers) {
+            const headersString = Object.entries(config.headers)
+                .map(([key, value]) => `${key}: ${value}`)
+                .join('\r\n');
+            requestHeadersSize = Buffer.byteLength(headersString + '\r\n\r\n', 'utf8');
+        }
+        if (config.data) {
+            if (typeof config.data === 'string') {
+                requestBodySize = Buffer.byteLength(config.data, 'utf8');
+            }
+            else if (Buffer.isBuffer(config.data)) {
+                requestBodySize = config.data.length;
+            }
+            else if (typeof config.data === 'object') {
+                try {
+                    const dataString = JSON.stringify(config.data);
+                    requestBodySize = Buffer.byteLength(dataString, 'utf8');
+                }
+                catch {
+                    requestBodySize = 0;
+                }
+            }
+        }
+        return { requestHeadersSize, requestBodySize };
+    }
+    static calculateResponseSizes(response, getResponseText) {
+        let headersSize = 0;
+        let bodySize = 0;
+        if (response.headers) {
+            const headersString = Object.entries(response.headers)
+                .map(([key, value]) => `${key}: ${value}`)
+                .join('\r\n');
+            headersSize = Buffer.byteLength(headersString + '\r\n\r\n', 'utf8');
+        }
+        if (response.data) {
+            const responseText = getResponseText(response.data);
+            bodySize = Buffer.byteLength(responseText, 'utf8');
+        }
+        return { headersSize, bodySize };
+    }
+    static detectDataType(response) {
+        const contentType = response.headers['content-type'] || '';
+        if (contentType.includes('text/') ||
+            contentType.includes('application/json') ||
+            contentType.includes('application/xml') ||
+            contentType.includes('application/javascript')) {
+            return 'text';
+        }
+        else if (contentType.includes('image/') ||
+            contentType.includes('application/octet-stream') ||
+            contentType.includes('application/pdf')) {
+            return 'bin';
+        }
+        return '';
+    }
+}
+exports.SizeCalculator = SizeCalculator;

package/dist/protocols/web/browser/highlight.d.ts

@@ -0,0 +1,7 @@
+import { Page } from 'playwright';
+import { HighlightConfig } from '../../../config';
+export declare class ElementHighlighter {
+    private highlightConfig;
+    constructor(highlightConfig: boolean | HighlightConfig | undefined);
+    highlightElement(page: Page, selector: string): Promise<void>;
+}

package/dist/protocols/web/browser/highlight.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementHighlighter = void 0;
+const logger_1 = require("../../../utils/logger");
+class ElementHighlighter {
+    constructor(highlightConfig) {
+        this.highlightConfig = highlightConfig;
+    }
+    async highlightElement(page, selector) {
+        if (!this.highlightConfig)
+            return;
+        const config = typeof this.highlightConfig === 'boolean'
+            ? { enabled: this.highlightConfig }
+            : this.highlightConfig;
+        if (!config.enabled)
+            return;
+        const duration = config.duration || 500;
+        const color = config.color || '#ff0000';
+        const style = config.style || 'border';
+        try {
+            const locator = page.locator(selector).first();
+            const count = await locator.count();
+            if (count === 0)
+                return;
+            await locator.evaluate((el, opts) => {
+                const { color, style, duration } = opts;
+                const originalStyle = el.getAttribute('style') || '';
+                let highlightStyle = '';
+                if (style === 'border' || style === 'both') {
+                    highlightStyle += `outline: 3px solid ${color} !important; outline-offset: 2px !important;`;
+                }
+                if (style === 'background' || style === 'both') {
+                    highlightStyle += `background-color: ${color}33 !important;`;
+                }
+                el.setAttribute('style', originalStyle + highlightStyle);
+                setTimeout(() => {
+                    el.setAttribute('style', originalStyle);
+                }, duration);
+            }, { color, style, duration });
+            await page.waitForTimeout(duration);
+        }
+        catch (error) {
+            logger_1.logger.debug(`Failed to highlight element ${selector}:`, error);
+        }
+    }
+}
+exports.ElementHighlighter = ElementHighlighter;

package/dist/protocols/web/browser/index.d.ts

@@ -0,0 +1,4 @@
+export { BrowserManager } from './manager';
+export { StorageManager } from './storage';
+export { ElementHighlighter } from './highlight';
+export { ScreenshotCapture } from './screenshot';

package/dist/protocols/web/browser/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScreenshotCapture = exports.ElementHighlighter = exports.StorageManager = exports.BrowserManager = void 0;
+var manager_1 = require("./manager");
+Object.defineProperty(exports, "BrowserManager", { enumerable: true, get: function () { return manager_1.BrowserManager; } });
+var storage_1 = require("./storage");
+Object.defineProperty(exports, "StorageManager", { enumerable: true, get: function () { return storage_1.StorageManager; } });
+var highlight_1 = require("./highlight");
+Object.defineProperty(exports, "ElementHighlighter", { enumerable: true, get: function () { return highlight_1.ElementHighlighter; } });
+var screenshot_1 = require("./screenshot");
+Object.defineProperty(exports, "ScreenshotCapture", { enumerable: true, get: function () { return screenshot_1.ScreenshotCapture; } });

package/dist/protocols/web/browser/manager.d.ts

@@ -0,0 +1,20 @@
+import { Browser, BrowserContext, Page } from 'playwright';
+import { BrowserConfig } from '../../../config';
+export declare class BrowserManager {
+    private config;
+    private browsers;
+    private contexts;
+    private pages;
+    constructor(config: BrowserConfig);
+    getPage(vuId: number, onPageCreated?: (page: Page, context: BrowserContext) => Promise<void>): Promise<Page>;
+    getExistingPage(vuId: number): Page | undefined;
+    getContext(vuId: number): BrowserContext | undefined;
+    getBrowser(vuId: number): Browser | undefined;
+    private createBrowserForVU;
+    getBrowserInfo(vuId: number): {
+        connected: boolean;
+    } | null;
+    getActiveVUCount(): number;
+    cleanupVU(vuId: number): Promise<void>;
+    cleanupAll(): Promise<void>;
+}

package/dist/protocols/web/browser/manager.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserManager = void 0;
+const playwright_1 = require("playwright");
+const logger_1 = require("../../../utils/logger");
+class BrowserManager {
+    constructor(config) {
+        this.config = config;
+        this.browsers = new Map();
+        this.contexts = new Map();
+        this.pages = new Map();
+    }
+    async getPage(vuId, onPageCreated) {
+        let page = this.pages.get(vuId);
+        if (!page) {
+            const browser = await this.createBrowserForVU(vuId);
+            this.browsers.set(vuId, browser);
+            const context = await browser.newContext({
+                viewport: this.config.viewport || { width: 1280, height: 720 },
+                ignoreHTTPSErrors: true,
+                storageState: undefined
+            });
+            page = await context.newPage();
+            page.setDefaultTimeout(30000);
+            page.setDefaultNavigationTimeout(30000);
+            if (onPageCreated) {
+                await onPageCreated(page, context);
+            }
+            this.contexts.set(vuId, context);
+            this.pages.set(vuId, page);
+            logger_1.logger.debug(`VU ${vuId}: Created enhanced browser with Web Vitals support`);
+        }
+        return page;
+    }
+    getExistingPage(vuId) {
+        return this.pages.get(vuId);
+    }
+    getContext(vuId) {
+        return this.contexts.get(vuId);
+    }
+    getBrowser(vuId) {
+        return this.browsers.get(vuId);
+    }
+    async createBrowserForVU(vuId) {
+        const browserType = this.config.type || 'chromium';
+        const launchOptions = {
+            headless: this.config.headless !== false,
+            slowMo: this.config.slow_mo || 0,
+            args: [
+                '--no-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-web-security',
+                '--disable-features=VizDisplayCompositor',
+                '--disable-http-cache',
+                '--disable-cache',
+                '--disable-application-cache',
+                '--disable-offline-load-stale-cache',
+                '--disk-cache-size=0',
+                '--media-cache-size=0',
+                '--no-first-run',
+                '--no-default-browser-check',
+                '--disable-background-networking',
+                '--disable-sync',
+                '--metrics-recording-only',
+                '--mute-audio',
+                '--disable-renderer-backgrounding',
+                '--enable-precise-memory-info',
+                '--enable-performance-manager-web-contents-observer',
+                '--enable-experimental-web-platform-features'
+            ]
+        };
+        let browser;
+        try {
+            switch (browserType) {
+                case 'chromium':
+                    browser = await playwright_1.chromium.launch(launchOptions);
+                    break;
+                case 'chrome':
+                    browser = await playwright_1.chromium.launch({ ...launchOptions, channel: 'chrome' });
+                    break;
+                case 'msedge':
+                    browser = await playwright_1.chromium.launch({ ...launchOptions, channel: 'msedge' });
+                    break;
+                case 'firefox':
+                    browser = await playwright_1.firefox.launch(launchOptions);
+                    break;
+                case 'webkit':
+                    browser = await playwright_1.webkit.launch(launchOptions);
+                    break;
+                default:
+                    throw new Error(`Unsupported browser type: ${browserType}. Supported: chromium, chrome, msedge, firefox, webkit`);
+            }
+            logger_1.logger.debug(`VU ${vuId}: Launched enhanced ${browserType} browser with Web Vitals support`);
+            return browser;
+        }
+        catch (error) {
+            logger_1.logger.error(`VU ${vuId}: Failed to launch ${browserType} browser:`, error);
+            throw error;
+        }
+    }
+    getBrowserInfo(vuId) {
+        const browser = this.browsers.get(vuId);
+        if (!browser)
+            return null;
+        return { connected: browser.isConnected() };
+    }
+    getActiveVUCount() {
+        return this.browsers.size;
+    }
+    async cleanupVU(vuId) {
+        logger_1.logger.debug(`Cleaning up enhanced browser resources for VU ${vuId}...`);
+        const page = this.pages.get(vuId);
+        if (page) {
+            try {
+                if (!page.isClosed()) {
+                    await page.close();
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn(`VU ${vuId}: Error closing page:`, error);
+            }
+            this.pages.delete(vuId);
+        }
+        const context = this.contexts.get(vuId);
+        if (context) {
+            try {
+                await context.close();
+            }
+            catch (error) {
+                if (!error?.message?.includes('Failed to find context') &&
+                    !error?.message?.includes('Target closed') &&
+                    !error?.message?.includes('has been closed')) {
+                    logger_1.logger.warn(`VU ${vuId}: Error closing context:`, error);
+                }
+            }
+            this.contexts.delete(vuId);
+        }
+        const browser = this.browsers.get(vuId);
+        if (browser) {
+            try {
+                if (browser.isConnected()) {
+                    await browser.close();
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn(`VU ${vuId}: Error closing browser:`, error);
+            }
+            this.browsers.delete(vuId);
+        }
+        logger_1.logger.debug(`VU ${vuId}: Enhanced browser cleanup completed`);
+    }
+    async cleanupAll() {
+        const browserCount = this.browsers.size;
+        logger_1.logger.debug(`Cleaning up ${browserCount} enhanced browsers...`);
+        for (const [vuId, page] of this.pages) {
+            try {
+                if (!page.isClosed()) {
+                    await page.close();
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn(`VU ${vuId}: Error closing page:`, error);
+            }
+        }
+        for (const [vuId, context] of this.contexts) {
+            try {
+                await context.close();
+            }
+            catch (error) {
+                logger_1.logger.warn(`VU ${vuId}: Error closing context:`, error);
+            }
+        }
+        for (const [vuId, browser] of this.browsers) {
+            try {
+                if (browser.isConnected()) {
+                    await browser.close();
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn(`VU ${vuId}: Error closing browser:`, error);
+            }
+        }
+        this.pages.clear();
+        this.contexts.clear();
+        this.browsers.clear();
+        logger_1.logger.debug(`Enhanced cleanup completed - ${browserCount} browsers closed`);
+    }
+}
+exports.BrowserManager = BrowserManager;

package/dist/protocols/web/browser/screenshot.d.ts

@@ -0,0 +1,8 @@
+import { Page } from 'playwright';
+import { ScreenshotConfig } from '../../../config';
+export declare class ScreenshotCapture {
+    private screenshotConfig;
+    constructor(screenshotConfig: boolean | ScreenshotConfig | undefined);
+    captureFailureScreenshot(page: Page, vuId: number, command: string): Promise<string>;
+    isEnabled(): boolean;
+}

package/dist/protocols/web/browser/screenshot.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScreenshotCapture = void 0;
+const logger_1 = require("../../../utils/logger");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+class ScreenshotCapture {
+    constructor(screenshotConfig) {
+        this.screenshotConfig = screenshotConfig;
+    }
+    async captureFailureScreenshot(page, vuId, command) {
+        let outputDir = 'screenshots';
+        let fullPage = true;
+        if (typeof this.screenshotConfig === 'object') {
+            outputDir = this.screenshotConfig.output_dir || 'screenshots';
+            fullPage = this.screenshotConfig.full_page !== false;
+        }
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const sanitizedCommand = command.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const filename = `failure_vu${vuId}_${sanitizedCommand}_${timestamp}.png`;
+        const screenshotPath = path.join(outputDir, filename);
+        await page.screenshot({
+            path: screenshotPath,
+            fullPage
+        });
+        logger_1.logger.info(`📸 Screenshot captured: ${screenshotPath}`);
+        return screenshotPath;
+    }
+    isEnabled() {
+        return !!this.screenshotConfig;
+    }
+}
+exports.ScreenshotCapture = ScreenshotCapture;

package/dist/protocols/web/browser/storage.d.ts

@@ -0,0 +1,5 @@
+import { Page, BrowserContext } from 'playwright';
+import { ClearStorageConfig } from '../../../config';
+export declare class StorageManager {
+    clearStorageIfConfigured(page: Page, context: BrowserContext, clearConfig: boolean | ClearStorageConfig | undefined): Promise<void>;
+}