qa360 2.2.20 → 2.3.1

package/dist/core/crawler/blob-url-download-handler.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Blob URL Download Handler
+ *
+ * P1 - Handle downloads initiated via createObjectURL / URL.createObjectURL
+ *
+ * Supports:
+ * - Detection of blob URL downloads
+ * - Intercepting blob URL creation
+ * - Capturing blob content
+ * - Validating blob downloads
+ * - Converting blobs to files
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
+ */
+export interface BlobDownloadConfig {
+    /** Directory to save blob downloads */
+    downloadDir?: string;
+    /** Whether to capture blob content automatically */
+    captureContent?: boolean;
+    /** Maximum blob size to capture (bytes) */
+    maxCaptureSize?: number;
+}
+export interface BlobDownloadInfo {
+    /** Blob URL */
+    url: string;
+    /** Blob ID (internal) */
+    blobId: string;
+    /** MIME type */
+    mimeType: string;
+    /** Size in bytes */
+    size: number;
+    /** Content (if captured) */
+    content?: Buffer;
+    /** Timestamp */
+    timestamp: number;
+    /** Source element that triggered download */
+    source?: string;
+}
+export interface BlobDownloadResult {
+    success: boolean;
+    blob?: BlobDownloadInfo;
+    error?: string;
+}
+/**
+ * Blob URL Download Handler class
+ */
+export declare class BlobURLDownloadHandler {
+    private downloads;
+    private downloadDir;
+    private captureContent;
+    private maxCaptureSize;
+    private stats;
+    constructor(config?: BlobDownloadConfig);
+    private ensureDownloadDir;
+    /**
+     * Setup blob URL interception on a page
+     * Overrides URL.createObjectURL to capture blob creation
+     */
+    setupBlobInterception(page: any): Promise<void>;
+    /**
+     * Wait for blob URL creation matching a pattern
+     */
+    waitForBlob(page: any, options?: {
+        /** MIME type to match */
+        mimeType?: string | RegExp;
+        /** Minimum size */
+        minSize?: number;
+        /** Maximum size */
+        maxSize?: number;
+        /** Timeout in ms */
+        timeout?: number;
+    }): Promise<BlobDownloadResult>;
+    /**
+     * Trigger a blob download by clicking an element
+     */
+    clickAndWaitForBlob(page: any, selector: string, options?: {
+        mimeType?: string | RegExp;
+        timeout?: number;
+        action?: 'click' | 'dblclick';
+    }): Promise<BlobDownloadResult>;
+    /**
+     * Save a blob to a file
+     */
+    saveBlob(blob: BlobDownloadInfo, filename?: string): Promise<string>;
+    /**
+     * Get all captured blobs
+     */
+    getAllBlobs(): BlobDownloadInfo[];
+    /**
+     * Get blob by ID
+     */
+    getBlob(blobId: string): BlobDownloadInfo | undefined;
+    /**
+     * Get the last blob
+     */
+    getLastBlob(): BlobDownloadInfo | undefined;
+    /**
+     * Get all blobs by MIME type
+     */
+    getBlobsByMimeType(mimeType: string | RegExp): BlobDownloadInfo[];
+    /**
+     * Clear all captured blobs
+     */
+    clearBlobs(): void;
+    /**
+     * Get file extension from MIME type
+     */
+    private getExtension;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        totalBlobs: number;
+        capturedBlobs: number;
+        totalSize: number;
+        averageSize: number;
+    };
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Get download directory
+     */
+    getDownloadDir(): string;
+    /**
+     * Verify blob content
+     */
+    verifyBlob(blob: BlobDownloadInfo, verification: {
+        /** Expected content pattern */
+        contentPattern?: string | RegExp;
+        /** Minimum size */
+        minSize?: number;
+        /** Maximum size */
+        maxSize?: number;
+    }): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+}
+/**
+ * Factory function to create Blob URL Download Handler
+ */
+export declare function createBlobURLDownloadHandler(config?: BlobDownloadConfig): BlobURLDownloadHandler;
+export default BlobURLDownloadHandler;

package/dist/core/crawler/blob-url-download-handler.js

@@ -0,0 +1,392 @@
+/**
+ * Blob URL Download Handler
+ *
+ * P1 - Handle downloads initiated via createObjectURL / URL.createObjectURL
+ *
+ * Supports:
+ * - Detection of blob URL downloads
+ * - Intercepting blob URL creation
+ * - Capturing blob content
+ * - Validating blob downloads
+ * - Converting blobs to files
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
+ */
+import { promises as fs } from 'fs';
+import { join } from 'path';
+/**
+ * Blob URL Download Handler class
+ */
+export class BlobURLDownloadHandler {
+    downloads = new Map();
+    downloadDir;
+    captureContent;
+    maxCaptureSize;
+    stats = {
+        totalBlobs: 0,
+        capturedBlobs: 0,
+        totalSize: 0,
+    };
+    constructor(config = {}) {
+        this.downloadDir = config.downloadDir || '/tmp/qa360-blob-downloads';
+        this.captureContent = config.captureContent !== false;
+        this.maxCaptureSize = config.maxCaptureSize || 10 * 1024 * 1024; // 10MB default
+        this.ensureDownloadDir();
+    }
+    async ensureDownloadDir() {
+        try {
+            await fs.mkdir(this.downloadDir, { recursive: true });
+        }
+        catch {
+            // Directory might already exist
+        }
+    }
+    /**
+     * Setup blob URL interception on a page
+     * Overrides URL.createObjectURL to capture blob creation
+     */
+    async setupBlobInterception(page) {
+        await page.evaluate((config) => {
+            // Store original createObjectURL
+            const originalCreateObjectURL = URL.createObjectURL;
+            // Initialize blob storage on window
+            if (!window.__qa360Blobs) {
+                window.__qa360Blobs = [];
+            }
+            // Override URL.createObjectURL
+            URL.createObjectURL = function (blob) {
+                const url = originalCreateObjectURL.call(URL, blob);
+                // Capture blob info
+                const blobInfo = {
+                    url,
+                    id: `blob-${Date.now()}-${Math.random().toString(36).substring(7)}`,
+                    mimeType: blob.type || 'application/octet-stream',
+                    size: blob.size || 0,
+                    timestamp: Date.now(),
+                };
+                // Capture content if enabled and size is reasonable
+                if (config.capture && blob.size <= config.maxSize) {
+                    const reader = new FileReader();
+                    reader.onload = () => {
+                        blobInfo.content = reader.result;
+                    };
+                    reader.readAsDataURL(blob);
+                }
+                window.__qa360Blobs.push(blobInfo);
+                console.log(`📦 Blob created: ${blobInfo.mimeType} (${blobInfo.size} bytes)`);
+                return url;
+            };
+            // Also override URL.revokeObjectURL to track cleanup
+            const originalRevokeObjectURL = URL.revokeObjectURL;
+            URL.revokeObjectURL = function (url) {
+                originalRevokeObjectURL.call(URL, url);
+                const blobs = window.__qa360Blobs || [];
+                const index = blobs.findIndex((b) => b.url === url);
+                if (index !== -1) {
+                    blobs[index].revoked = true;
+                    blobs[index].revokedAt = Date.now();
+                }
+            };
+            // Track blob downloads via download attribute on links
+            document.addEventListener('click', (e) => {
+                const target = e.target;
+                if (target.tagName === 'A' && target instanceof HTMLAnchorElement) {
+                    const href = target.href;
+                    if (href && href.startsWith('blob:')) {
+                        const blobs = window.__qa360Blobs || [];
+                        const blob = blobs.find((b) => b.url === href);
+                        if (blob) {
+                            blob.downloaded = true;
+                            blob.downloadSource = {
+                                tagName: target.tagName,
+                                id: target.id,
+                                className: target.className,
+                                textContent: target.textContent?.substring(0, 50),
+                            };
+                        }
+                    }
+                }
+            }, true);
+        }, {
+            capture: this.captureContent,
+            maxSize: this.maxCaptureSize,
+        });
+    }
+    /**
+     * Wait for blob URL creation matching a pattern
+     */
+    async waitForBlob(page, options = {}) {
+        const timeout = options.timeout || 30000;
+        const startTime = Date.now();
+        return new Promise((resolve) => {
+            const checkInterval = setInterval(async () => {
+                try {
+                    const blobs = await page.evaluate(() => {
+                        return window.__qa360Blobs || [];
+                    });
+                    for (const blob of blobs) {
+                        // Check MIME type filter
+                        if (options.mimeType) {
+                            const matches = typeof options.mimeType === 'string'
+                                ? blob.mimeType.includes(options.mimeType)
+                                : options.mimeType.test(blob.mimeType);
+                            if (!matches)
+                                continue;
+                        }
+                        // Check size filters
+                        if (options.minSize && blob.size < options.minSize)
+                            continue;
+                        if (options.maxSize && blob.size > options.maxSize)
+                            continue;
+                        clearInterval(checkInterval);
+                        // Fetch blob content
+                        let content;
+                        if (this.captureContent) {
+                            try {
+                                const contentDataUrl = await page.evaluate((blobUrl) => {
+                                    const blobs = window.__qa360Blobs || [];
+                                    const blob = blobs.find((b) => b.url === blobUrl);
+                                    return blob?.content;
+                                }, blob.url);
+                                if (contentDataUrl) {
+                                    const base64 = contentDataUrl.split(',')[1];
+                                    content = Buffer.from(base64, 'base64');
+                                }
+                            }
+                            catch {
+                                // Content not available
+                            }
+                        }
+                        const downloadInfo = {
+                            url: blob.url,
+                            blobId: blob.id,
+                            mimeType: blob.mimeType,
+                            size: blob.size,
+                            content,
+                            timestamp: blob.timestamp,
+                            source: blob.downloadSource?.textContent,
+                        };
+                        this.downloads.set(blob.id, downloadInfo);
+                        this.stats.totalBlobs++;
+                        if (content) {
+                            this.stats.capturedBlobs++;
+                            this.stats.totalSize += content.length;
+                        }
+                        resolve({
+                            success: true,
+                            blob: downloadInfo,
+                        });
+                        return;
+                    }
+                    if (Date.now() - startTime > timeout) {
+                        clearInterval(checkInterval);
+                        resolve({
+                            success: false,
+                            error: `Timeout waiting for blob URL creation`,
+                        });
+                    }
+                }
+                catch (e) {
+                    clearInterval(checkInterval);
+                    resolve({
+                        success: false,
+                        error: e instanceof Error ? e.message : String(e),
+                    });
+                }
+            }, 100);
+        });
+    }
+    /**
+     * Trigger a blob download by clicking an element
+     */
+    async clickAndWaitForBlob(page, selector, options = {}) {
+        await this.setupBlobInterception(page);
+        const timeout = options.timeout || 30000;
+        const startTime = Date.now();
+        // Start waiting for blob before clicking
+        const blobPromise = this.waitForBlob(page, {
+            mimeType: options.mimeType,
+            timeout,
+        });
+        // Perform the click
+        try {
+            const element = page.locator(selector).first();
+            await element.waitFor({ state: 'visible', timeout: 5000 });
+            if (options.action === 'dblclick') {
+                await element.dblclick();
+            }
+            else {
+                await element.click();
+            }
+            const result = await blobPromise;
+            // Add source info
+            if (result.blob) {
+                const sourceInfo = await page.evaluate((sel) => {
+                    const el = document.querySelector(sel);
+                    if (!el)
+                        return null;
+                    return {
+                        tagName: el.tagName,
+                        id: el.id,
+                        className: el.className,
+                        textContent: el.textContent?.substring(0, 50),
+                    };
+                }, selector);
+                result.blob.source = sourceInfo?.textContent || selector;
+            }
+            return result;
+        }
+        catch (e) {
+            return {
+                success: false,
+                error: e instanceof Error ? e.message : String(e),
+            };
+        }
+    }
+    /**
+     * Save a blob to a file
+     */
+    async saveBlob(blob, filename) {
+        const finalFilename = filename || `blob-${blob.blobId}.${this.getExtension(blob.mimeType)}`;
+        const path = join(this.downloadDir, finalFilename);
+        if (blob.content) {
+            await fs.writeFile(path, blob.content);
+            return path;
+        }
+        // If content wasn't captured, try to fetch it from the page context
+        throw new Error('Blob content not available for saving');
+    }
+    /**
+     * Get all captured blobs
+     */
+    getAllBlobs() {
+        return Array.from(this.downloads.values());
+    }
+    /**
+     * Get blob by ID
+     */
+    getBlob(blobId) {
+        return this.downloads.get(blobId);
+    }
+    /**
+     * Get the last blob
+     */
+    getLastBlob() {
+        const blobs = Array.from(this.downloads.values());
+        if (blobs.length === 0)
+            return undefined;
+        return blobs.sort((a, b) => b.timestamp - a.timestamp)[0];
+    }
+    /**
+     * Get all blobs by MIME type
+     */
+    getBlobsByMimeType(mimeType) {
+        const blobs = this.getAllBlobs();
+        return blobs.filter(blob => {
+            if (typeof mimeType === 'string') {
+                return blob.mimeType.includes(mimeType);
+            }
+            return mimeType.test(blob.mimeType);
+        });
+    }
+    /**
+     * Clear all captured blobs
+     */
+    clearBlobs() {
+        this.downloads.clear();
+    }
+    /**
+     * Get file extension from MIME type
+     */
+    getExtension(mimeType) {
+        const extensions = {
+            'application/pdf': 'pdf',
+            'application/json': 'json',
+            'application/xml': 'xml',
+            'text/xml': 'xml',
+            'text/html': 'html',
+            'text/plain': 'txt',
+            'text/csv': 'csv',
+            'image/jpeg': 'jpg',
+            'image/png': 'png',
+            'image/gif': 'gif',
+            'image/webp': 'webp',
+            'image/svg+xml': 'svg',
+            'video/mp4': 'mp4',
+            'video/webm': 'webm',
+            'audio/mpeg': 'mp3',
+            'audio/wav': 'wav',
+            'application/zip': 'zip',
+            'application/x-zip-compressed': 'zip',
+        };
+        for (const [type, ext] of Object.entries(extensions)) {
+            if (mimeType.startsWith(type)) {
+                return ext;
+            }
+        }
+        return 'bin';
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            averageSize: this.stats.capturedBlobs > 0
+                ? this.stats.totalSize / this.stats.capturedBlobs
+                : 0,
+        };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalBlobs: 0,
+            capturedBlobs: 0,
+            totalSize: 0,
+        };
+    }
+    /**
+     * Get download directory
+     */
+    getDownloadDir() {
+        return this.downloadDir;
+    }
+    /**
+     * Verify blob content
+     */
+    async verifyBlob(blob, verification) {
+        const errors = [];
+        if (verification.minSize && blob.size < verification.minSize) {
+            errors.push(`Size ${blob.size} is below minimum ${verification.minSize}`);
+        }
+        if (verification.maxSize && blob.size > verification.maxSize) {
+            errors.push(`Size ${blob.size} exceeds maximum ${verification.maxSize}`);
+        }
+        if (verification.contentPattern && blob.content) {
+            const content = blob.content.toString('utf-8');
+            if (typeof verification.contentPattern === 'string') {
+                if (!content.includes(verification.contentPattern)) {
+                    errors.push(`Content does not include "${verification.contentPattern}"`);
+                }
+            }
+            else {
+                if (!verification.contentPattern.test(content)) {
+                    errors.push('Content does not match expected pattern');
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+}
+/**
+ * Factory function to create Blob URL Download Handler
+ */
+export function createBlobURLDownloadHandler(config) {
+    return new BlobURLDownloadHandler(config);
+}
+export default BlobURLDownloadHandler;

package/dist/core/crawler/consent-handler.d.ts

@@ -0,0 +1,49 @@
+/**
+ * QA360 Consent Handler
+ *
+ * Automatically detects and dismisses GDPR/CCPA cookie consent banners.
+ * Supports all major Consent Management Platforms (CMPs).
+ *
+ * Philosophy: "80% of EU sites block interaction with consent banners"
+ */
+import type { Page } from '@playwright/test';
+/**
+ * Consent handling options
+ */
+export interface ConsentOptions {
+    /** Action to take: 'accept', 'reject', or 'ignore' */
+    action?: 'accept' | 'reject' | 'ignore';
+    /** Timeout for banner detection (ms) */
+    timeout?: number;
+    /** Custom selector override */
+    customSelector?: string;
+}
+/**
+ * Consent Handler - Auto-detects and handles GDPR/CCPA banners
+ */
+export declare class ConsentHandler {
+    /**
+     * Handle consent banners on the page
+     *
+     * @param page - Playwright Page instance
+     * @param options - Consent handling options
+     * @returns true if a banner was found and handled, false otherwise
+     */
+    static handleConsent(page: Page, options?: ConsentOptions): Promise<boolean>;
+    /**
+     * Try a specific CMP
+     */
+    private static tryCMP;
+    /**
+     * Handle custom consent selector
+     */
+    private static handleCustom;
+    /**
+     * Get all supported CMP names
+     */
+    static getSupportedCMPs(): string[];
+}
+/**
+ * Quick function to handle consent (convenience wrapper)
+ */
+export declare function handleConsent(page: Page, options?: ConsentOptions): Promise<boolean>;