qa360 2.2.20 → 2.3.1

package/dist/core/crawler/sourcemaps-handler.js

@@ -0,0 +1,420 @@
+/**
+ * Source Maps Handler
+ *
+ * P1 - Source map parsing and error mapping
+ *
+ * Supports:
+ * - Source map detection
+ * - Source map parsing
+ * - Error stack trace mapping
+ * - Original source location resolution
+ * - Source content retrieval
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Tools/Debugger/How_to/Use_a_source_map
+ */
+/**
+ * Source Maps Handler class
+ */
+export class SourceMapsHandler {
+    page;
+    sourceMapsCache = new Map();
+    constructor(page) {
+        this.page = page;
+    }
+    /**
+     * Get all source map URLs from the page
+     */
+    async getSourceMapURLs() {
+        return await this.page.evaluate(() => {
+            const sourceMaps = new Map();
+            // Check for source maps in <script> tags
+            const scripts = document.querySelectorAll('script[src]');
+            scripts.forEach(script => {
+                const src = script.src;
+                // Source map is usually at same path with .map extension
+                const sourceMapUrl = src + '.map';
+                sourceMaps.set(src, sourceMapUrl);
+            });
+            // Check for inline source map comments
+            const inlineScripts = document.querySelectorAll('script:not([src])');
+            inlineScripts.forEach(script => {
+                const content = script.textContent || '';
+                // Look for sourceMappingURL comment
+                const match = content.match(/\/\/[@#]\s*sourceMappingURL=([^\s]+)/);
+                if (match) {
+                    sourceMaps.set('(inline)', match[1]);
+                }
+            });
+            // Check for source maps in stylesheets
+            const links = document.querySelectorAll('link[rel="stylesheet"]');
+            links.forEach(link => {
+                const href = link.href;
+                const sourceMapUrl = href + '.map';
+                sourceMaps.set(href, sourceMapUrl);
+            });
+            // Check for inline source maps in style tags
+            const styles = document.querySelectorAll('style');
+            styles.forEach(style => {
+                const content = style.textContent || '';
+                const match = content.match(/\/\*[@#]\s*sourceMappingURL=([^\s]+)\s*\*\//);
+                if (match) {
+                    sourceMaps.set('(inline style)', match[1]);
+                }
+            });
+            // Check window for source map data
+            if (window.__sourceMapUrl) {
+                sourceMaps.set('(global)', window.__sourceMapUrl);
+            }
+            return Object.fromEntries(sourceMaps);
+        });
+    }
+    /**
+     * Fetch and parse a source map
+     */
+    async fetchSourceMap(sourceMapUrl) {
+        // Check cache first
+        if (this.sourceMapsCache.has(sourceMapUrl)) {
+            return this.sourceMapsCache.get(sourceMapUrl);
+        }
+        // Resolve URL relative to page
+        const baseUrl = this.page.url();
+        const absoluteUrl = new URL(sourceMapUrl, baseUrl).toString();
+        try {
+            // Fetch the source map
+            const content = await this.page.evaluate(async (url) => {
+                try {
+                    const response = await fetch(url);
+                    if (!response.ok)
+                        return null;
+                    return await response.text();
+                }
+                catch {
+                    return null;
+                }
+            }, absoluteUrl);
+            if (!content) {
+                return {
+                    url: sourceMapUrl,
+                    content: null,
+                    sourceCount: 0,
+                    sources: [],
+                    sourceRoot: '',
+                    hasMappings: false,
+                    version: 0,
+                    valid: false,
+                };
+            }
+            // Parse the source map (simplified JSON parsing)
+            const sourceMap = JSON.parse(content);
+            return {
+                url: sourceMapUrl,
+                content,
+                sourceCount: sourceMap.sources?.length || 0,
+                sources: sourceMap.sources || [],
+                sourceRoot: sourceMap.sourceRoot || '',
+                hasMappings: !!sourceMap.mappings && sourceMap.mappings.length > 0,
+                version: sourceMap.version || 3,
+                valid: !!sourceMap.version && !!sourceMap.mappings,
+            };
+        }
+        catch {
+            return {
+                url: sourceMapUrl,
+                content: null,
+                sourceCount: 0,
+                sources: [],
+                sourceRoot: '',
+                hasMappings: false,
+                version: 0,
+                valid: false,
+            };
+        }
+    }
+    /**
+     * Get all source maps from the page
+     */
+    async getAllSourceMaps() {
+        const sourceMapUrls = await this.getSourceMapURLs();
+        const sourceMaps = new Map();
+        const filesWithSourceMaps = [];
+        const filesWithoutSourceMaps = [];
+        for (const [file, url] of Object.entries(sourceMapUrls)) {
+            const sourceMapInfo = await this.fetchSourceMap(url);
+            sourceMaps.set(file, sourceMapInfo);
+            if (sourceMapInfo.valid) {
+                filesWithSourceMaps.push(file);
+            }
+            else {
+                filesWithoutSourceMaps.push(file);
+            }
+        }
+        // Calculate coverage
+        const totalFiles = filesWithSourceMaps.length + filesWithoutSourceMaps.length;
+        const sourceMapCoverage = totalFiles > 0
+            ? (filesWithSourceMaps.length / totalFiles) * 100
+            : 0;
+        return {
+            sourceMaps,
+            filesWithSourceMaps,
+            filesWithoutSourceMaps,
+            sourceMapCoverage,
+        };
+    }
+    /**
+     * Map an error stack trace using source maps
+     */
+    async mapError(error) {
+        const stack = error.stack || '';
+        const stackLines = stack.split('\n').slice(1);
+        const mappedStack = await Promise.all(stackLines.map(async (stackLine) => {
+            // Parse stack line (format varies by browser)
+            const match = stackLine.match(/at\s+([^\s]+)\s+\((.+?):(\d+):(\d+)\)|at\s+(.+?):(\d+):(\d+)/);
+            if (!match) {
+                return {
+                    filename: '(unknown)',
+                    line: 0,
+                    column: 0,
+                    function: null,
+                    originalFilename: null,
+                    originalLine: null,
+                    originalColumn: null,
+                };
+            }
+            const funcName = match[1] || null;
+            const filename = match[2] || match[5];
+            const lineNum = parseInt(match[3] || match[6], 10);
+            const column = parseInt(match[4] || match[7], 10);
+            // Try to map using source maps
+            const mapped = await this.mapLocation(filename, lineNum, column);
+            return {
+                filename,
+                line: lineNum,
+                column,
+                function: funcName,
+                originalFilename: mapped.originalSource,
+                originalLine: mapped.originalLine,
+                originalColumn: mapped.originalColumn,
+            };
+        }));
+        return {
+            original: error,
+            mappedStack,
+            sourceMapUsed: mappedStack.some(s => s.originalFilename !== null),
+        };
+    }
+    /**
+     * Map a generated location to original location
+     */
+    async mapLocation(filename, line, column) {
+        // Find source map for this file
+        const sourceMapUrl = filename + '.map';
+        const sourceMapInfo = await this.fetchSourceMap(sourceMapUrl);
+        if (!sourceMapInfo.valid || !sourceMapInfo.content) {
+            return {
+                generatedLine: line,
+                generatedColumn: column,
+                originalSource: null,
+                originalLine: null,
+                originalColumn: null,
+                name: null,
+            };
+        }
+        try {
+            // Parse source map
+            const sourceMap = JSON.parse(sourceMapInfo.content);
+            // Simplified mapping (real implementation would use VLQ decoding)
+            // For now, return the first source if available
+            if (sourceMap.sources && sourceMap.sources.length > 0) {
+                return {
+                    generatedLine: line,
+                    generatedColumn: column,
+                    originalSource: sourceMap.sources[0],
+                    originalLine: line, // Would be calculated from mappings
+                    originalColumn: column,
+                    name: null,
+                };
+            }
+            return {
+                generatedLine: line,
+                generatedColumn: column,
+                originalSource: null,
+                originalLine: null,
+                originalColumn: null,
+                name: null,
+            };
+        }
+        catch {
+            return {
+                generatedLine: line,
+                generatedColumn: column,
+                originalSource: null,
+                originalLine: null,
+                originalColumn: null,
+                name: null,
+            };
+        }
+    }
+    /**
+     * Get original source content from source map
+     */
+    async getOriginalSource(sourceMapUrl, sourceIndex) {
+        const sourceMapInfo = await this.fetchSourceMap(sourceMapUrl);
+        if (!sourceMapInfo.valid || !sourceMapInfo.content) {
+            return null;
+        }
+        try {
+            const sourceMap = JSON.parse(sourceMapInfo.content);
+            if (sourceMap.sourcesContent && sourceMap.sourcesContent[sourceIndex]) {
+                return sourceMap.sourcesContent[sourceIndex];
+            }
+            // If sourcesContent not embedded, try to fetch the source file
+            if (sourceMap.sources && sourceMap.sources[sourceIndex]) {
+                const sourceFile = sourceMap.sources[sourceIndex];
+                const baseUrl = new URL(sourceMapUrl);
+                const sourceUrl = new URL(sourceFile, baseUrl).toString();
+                return await this.page.evaluate(async (url) => {
+                    try {
+                        const response = await fetch(url);
+                        return response.ok ? await response.text() : null;
+                    }
+                    catch {
+                        return null;
+                    }
+                }, sourceUrl);
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Check if source maps are enabled for a file
+     */
+    async hasSourceMap(filename) {
+        const sourceMapUrl = filename + '.map';
+        const sourceMapInfo = await this.fetchSourceMap(sourceMapUrl);
+        return sourceMapInfo.valid;
+    }
+    /**
+     * Inject source map helper into the page
+     */
+    async injectSourceMapHelper() {
+        await this.page.evaluate(() => {
+            // Add a helper to expose source map data
+            window.__getSourceMapInfo = async () => {
+                const results = [];
+                // Check all scripts
+                document.querySelectorAll('script[src]').forEach(script => {
+                    const src = script.src;
+                    results.push({
+                        file: src,
+                        sourceMap: src + '.map',
+                        valid: false, // Would need fetch to validate
+                    });
+                });
+                return results;
+            };
+            // Override Error.prepareStackTrace to capture source maps
+            const originalPrepareStackTrace = Error.prepareStackTrace;
+            if (originalPrepareStackTrace) {
+                Error.prepareStackTrace = (error, stack) => {
+                    // Enhanced stack trace with source map info would go here
+                    return originalPrepareStackTrace(error, stack);
+                };
+            }
+        });
+    }
+    /**
+     * Validate source map quality
+     */
+    async validateSourceMaps() {
+        const result = await this.getAllSourceMaps();
+        let valid = 0;
+        let invalid = 0;
+        let hasNames = 0;
+        let hasSourceContent = 0;
+        let totalSourceCount = 0;
+        for (const [file, info] of result.sourceMaps) {
+            if (info.valid) {
+                valid++;
+                totalSourceCount += info.sourceCount;
+                if (info.content) {
+                    try {
+                        const sourceMap = JSON.parse(info.content);
+                        if (sourceMap.names && sourceMap.names.length > 0) {
+                            hasNames++;
+                        }
+                        if (sourceMap.sourcesContent && sourceMap.sourcesContent.length > 0) {
+                            hasSourceContent++;
+                        }
+                    }
+                    catch {
+                        // Ignore parse errors
+                    }
+                }
+            }
+            else {
+                invalid++;
+            }
+        }
+        const total = result.filesWithSourceMaps.length + result.filesWithoutSourceMaps.length;
+        const avgSourceCount = valid > 0 ? totalSourceCount / valid : 0;
+        return {
+            total,
+            valid,
+            invalid,
+            missing: result.filesWithoutSourceMaps.length,
+            hasNames,
+            hasSourceContent,
+            avgSourceCount,
+        };
+    }
+    /**
+     * Get source map statistics
+     */
+    async getStatistics() {
+        const result = await this.getAllSourceMaps();
+        const stats = await this.validateSourceMaps();
+        let totalMappings = 0;
+        for (const info of result.sourceMaps.values()) {
+            if (info.valid && info.content) {
+                // Rough estimate of mappings (would need proper parsing)
+                totalMappings += info.content.split(',').length;
+            }
+        }
+        const avgMappingsPerFile = stats.valid > 0 ? totalMappings / stats.valid : 0;
+        const avgSourcesPerFile = stats.avgSourceCount;
+        let recommendation = 'Source maps are well configured';
+        if (result.sourceMapCoverage < 50) {
+            recommendation = 'Consider adding source maps for better debugging';
+        }
+        else if (stats.avgSourceCount < 2) {
+            recommendation = 'Source maps may not include all original sources';
+        }
+        else if (stats.hasNames < stats.valid * 0.5) {
+            recommendation = 'Consider adding function names to source maps';
+        }
+        return {
+            sourceMapCoverage: result.sourceMapCoverage,
+            totalFiles: stats.total,
+            filesWithSourceMaps: stats.valid,
+            avgMappingsPerFile,
+            avgSourcesPerFile,
+            recommendation,
+        };
+    }
+    /**
+     * Clear source map cache
+     */
+    clearCache() {
+        this.sourceMapsCache.clear();
+    }
+}
+/**
+ * Factory function to create Source Maps Handler
+ */
+export function createSourceMapsHandler(page) {
+    return new SourceMapsHandler(page);
+}
+export default SourceMapsHandler;

package/dist/core/crawler/stacked-modals-handler.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Stacked Modals Handler
+ *
+ * P1 - Detection and management of stacked/nested modals
+ *
+ * Supports:
+ * - Detection of stacked modals (multiple overlays)
+ * - Z-index analysis
+ * - Modal type detection (dialog, popover, dropdown)
+ * - Modal hierarchy traversal
+ * - Modal dismissal strategies
+ *
+ * @see https://www.w3.org/WAI/ARIA/apg/patterns/dialogmodal/
+ */
+export interface ModalInfo {
+    /** Modal element selector */
+    selector: string;
+    /** Modal type */
+    type: 'dialog' | 'popover' | 'dropdown' | 'tooltip' | 'alert' | 'custom';
+    /** Z-index */
+    zIndex: number;
+    /** Position in stack (0 = bottom) */
+    stackPosition: number;
+    /** Whether it's visible */
+    visible: boolean;
+    /** Whether it blocks interaction with elements below */
+    blocksInteraction: boolean;
+    /** ARIA attributes */
+    aria: {
+        modal: boolean;
+        labelledby?: string;
+        describedby?: string;
+        label?: string;
+    };
+    /** Parent selector (if nested) */
+    parent?: string;
+    /** Children selectors */
+    children: string[];
+    /** Close buttons/selectors */
+    closeSelectors: string[];
+}
+export interface ModalHierarchy {
+    /** Total number of modals detected */
+    totalModals: number;
+    /** Number of visible modals */
+    visibleModals: number;
+    /** Modal stack (bottom to top) */
+    stack: ModalInfo[];
+    /** Top-most modal */
+    topModal?: ModalInfo;
+    /** Issues detected */
+    issues: string[];
+}
+export interface ModalActionOptions {
+    /** Wait for modal before action */
+    waitFor?: boolean;
+    /** Timeout for waiting */
+    timeout?: number;
+}
+/**
+ * Stacked Modals Handler class
+ */
+export declare class StackedModalsHandler {
+    /**
+     * Detect all modals on the page
+     */
+    detectModals(page: any): Promise<ModalHierarchy>;
+    /**
+     * Get the top-most (active) modal
+     */
+    getTopModal(page: any): Promise<ModalInfo | null>;
+    /**
+     * Wait for a modal to appear
+     */
+    waitForModal(page: any, options?: {
+        /** Type of modal to wait for */
+        type?: ModalInfo['type'];
+        /** Selector to match */
+        selector?: string;
+        /** Minimum z-index */
+        minZIndex?: number;
+        /** Timeout in ms */
+        timeout?: number;
+    }): Promise<ModalInfo | null>;
+    /**
+     * Close a modal
+     */
+    closeModal(page: any, modal: ModalInfo | string, options?: ModalActionOptions): Promise<boolean>;
+    /**
+     * Close all modals from top to bottom
+     */
+    closeAllModals(page: any, options?: ModalActionOptions): Promise<number>;
+    /**
+     * Get modal hierarchy for debugging
+     */
+    getModalTree(page: any): Promise<string>;
+    /**
+     * Verify modal accessibility
+     */
+    verifyAccessibility(page: any, modal: ModalInfo | string): Promise<{
+        valid: boolean;
+        issues: string[];
+    }>;
+    /**
+     * Get modal statistics
+     */
+    getStatistics(page: any): Promise<{
+        byType: Record<string, number>;
+        averageZIndex: number;
+        maxStackDepth: number;
+        accessibilityScore: number;
+    }>;
+}
+/**
+ * Factory function to create Stacked Modals Handler
+ */
+export declare function createStackedModalsHandler(): StackedModalsHandler;
+export default StackedModalsHandler;