qa360 2.3.0 → 2.3.1

package/dist/core/crawler/framework-wait-handler.js

@@ -0,0 +1,464 @@
+/**
+ * Framework Wait Handler
+ *
+ * P1 - Framework-aware waiting for SPA applications
+ *
+ * Supports:
+ * - React hydration waiting
+ * - React Suspense lazy loading
+ * - Vue nextTick / reactive updates
+ * - Angular zone.js stability
+ * - Svelte tick waiting
+ * - SolidJS fine-grained reactivity
+ *
+ * @see https://playwright.dev/docs/pom
+ */
+/**
+ * Framework Wait Handler class
+ */
+export class FrameworkWaitHandler {
+    defaultTimeout;
+    defaultInterval;
+    constructor(config = {}) {
+        this.defaultTimeout = config.timeout || 30000;
+        this.defaultInterval = config.interval || 100;
+    }
+    /**
+     * Detect which framework is running on the page
+     */
+    async detectFramework(page) {
+        const result = await page.evaluate(() => {
+            const detection = {
+                framework: null,
+                confidence: 0,
+            };
+            // React detection
+            const reactRoot = document.querySelector('[data-reactroot]');
+            const reactRoot2 = document.querySelector('#root');
+            const reactRoot3 = document.querySelector('#app');
+            const reactAttributes = document.querySelectorAll('[data-react-check-sum]');
+            if (typeof window.React !== 'undefined' ||
+                typeof window.__REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' ||
+                reactRoot || reactAttributes.length > 0) {
+                detection.framework = 'react';
+                detection.confidence = 0.9;
+                // Try to get React version
+                const reactEl = document.querySelector('[data-reactroot], #root, #app');
+                if (reactEl && reactEl._reactRootContainer) {
+                    detection.version = '18';
+                }
+            }
+            // Vue detection
+            if (typeof window.Vue !== 'undefined' ||
+                typeof window.__VUE__ !== 'undefined') {
+                detection.framework = 'vue';
+                detection.confidence = 0.95;
+                if (window.Vue?.version) {
+                    detection.version = window.Vue.version;
+                }
+            }
+            // Angular detection
+            if (typeof window.ng !== 'undefined' ||
+                document.querySelector('[ng-version]')) {
+                detection.framework = 'angular';
+                detection.confidence = 0.95;
+                const ngApp = document.querySelector('[ng-version]');
+                if (ngApp) {
+                    const version = ngApp.getAttribute('ng-version');
+                    if (version)
+                        detection.version = version;
+                }
+            }
+            // Svelte detection
+            if (typeof window.__SVELTE__ !== 'undefined') {
+                detection.framework = 'svelte';
+                detection.confidence = 0.9;
+            }
+            // SolidJS detection
+            if (typeof window._$HY !== 'undefined' ||
+                typeof window.SolidJS !== 'undefined') {
+                detection.framework = 'solid';
+                detection.confidence = 0.9;
+            }
+            // Additional detection via global objects
+            if (!detection.framework) {
+                // Check for common framework-specific class names or attributes
+                const hasReactClasses = document.querySelectorAll('.css-1x, .chakra').length > 0;
+                const hasVueDirectives = document.querySelectorAll('[data-v-]').length > 0;
+                const hasAngularClasses = document.querySelectorAll('.ng-').length > 0;
+                if (hasReactClasses) {
+                    detection.framework = 'react';
+                    detection.confidence = 0.6;
+                }
+                else if (hasVueDirectives) {
+                    detection.framework = 'vue';
+                    detection.confidence = 0.6;
+                }
+                else if (hasAngularClasses) {
+                    detection.framework = 'angular';
+                    detection.confidence = 0.6;
+                }
+            }
+            return detection;
+        });
+        return result;
+    }
+    /**
+     * Wait for React hydration to complete
+     */
+    async waitForReactHydration(page, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        try {
+            await page.waitForFunction(() => {
+                // Check if React has finished hydrating
+                // Method 1: Check for __REACT_DEVTOOLS_GLOBAL_HOOK__
+                const devtools = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+                if (devtools && devtools.renderers) {
+                    return true;
+                }
+                // Method 2: Check for React roots
+                const roots = document.querySelectorAll('[data-reactroot], [data-reactid]');
+                if (roots.length > 0) {
+                    return true;
+                }
+                // Method 3: Check if React is loaded and DOM is stable
+                if (typeof window.React !== 'undefined') {
+                    // Check for common React app containers
+                    const root = document.querySelector('#root, #app, [data-root]');
+                    if (root && root.children.length > 0) {
+                        // Check if the root has rendered content
+                        return root.innerHTML.length > 0;
+                    }
+                }
+                return false;
+            }, { timeout });
+            // Additional wait for Suspense boundaries
+            await this.waitForReactSuspense(page, {
+                timeout: Math.max(5000, timeout - (Date.now() - startTime))
+            });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+                framework: 'react',
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                framework: 'react',
+                error: e instanceof Error ? e.message : 'React hydration timeout',
+            };
+        }
+    }
+    /**
+     * Wait for React Suspense lazy components to load
+     */
+    async waitForReactSuspense(page, config = {}) {
+        const timeout = config.timeout || 10000;
+        const startTime = Date.now();
+        try {
+            await page.waitForFunction(() => {
+                // Check for Suspense fallbacks (loading states)
+                const suspenseFallbacks = document.querySelectorAll('[data-suspense], .suspense-fallback, [data-loading="true"]');
+                // Check for common loading patterns in React apps
+                const loadingElements = document.querySelectorAll('[data-testid="loading"], .loading, [aria-busy="true"]');
+                // If no loading states, consider Suspense resolved
+                return suspenseFallbacks.length === 0 && loadingElements.length === 0;
+            }, { timeout });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+                framework: 'react',
+            };
+        }
+        catch (e) {
+            // Timeout is acceptable - loading states might just not exist
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+                framework: 'react',
+            };
+        }
+    }
+    /**
+     * Wait for Vue nextTick and reactive updates to flush
+     */
+    async waitForVueStable(page, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        try {
+            await page.waitForFunction(() => {
+                // Check if Vue is loaded
+                if (typeof window.Vue === 'undefined' &&
+                    typeof window.__VUE__ === 'undefined') {
+                    return true; // Not a Vue app, continue
+                }
+                // Wait for Vue's nextTick to complete
+                // Vue 3: check if __VUE__ is stable
+                const vue = window.Vue || window.__VUE__;
+                if (vue && vue.version) {
+                    // Vue 3.x
+                    if (vue.version.startsWith('3')) {
+                        // In Vue 3, we check for pending updates
+                        return document.readyState === 'complete';
+                    }
+                }
+                // Vue 2.x - check for _watcher
+                return true;
+            }, { timeout });
+            // Additional wait for Vue component updates
+            await page.evaluate(() => {
+                return new Promise((resolve) => {
+                    if (typeof window.Vue !== 'undefined' && window.Vue.nextTick) {
+                        window.Vue.nextTick(resolve);
+                    }
+                    else {
+                        resolve(undefined);
+                    }
+                });
+            });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+                framework: 'vue',
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                framework: 'vue',
+                error: e instanceof Error ? e.message : 'Vue stability timeout',
+            };
+        }
+    }
+    /**
+     * Wait for Angular zone.js to stabilize
+     */
+    async waitForAngularStable(page, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        try {
+            await page.waitForFunction(() => {
+                // Check if Angular is loaded
+                if (typeof window.ng === 'undefined' &&
+                    typeof window.getAllAngularRootElements === 'undefined') {
+                    return true; // Not an Angular app
+                }
+                // Check if Angular is stable (no pending macro tasks)
+                const ng = window.ng;
+                if (ng && ng.getTestability) {
+                    try {
+                        const testability = ng.getTestability(document.body);
+                        if (testability && testability.isStable) {
+                            return testability.isStable();
+                        }
+                    }
+                    catch {
+                        // Testability might not be enabled
+                    }
+                }
+                // Fallback: Check for ng-version and completed rendering
+                const ngApp = document.querySelector('[ng-version]');
+                if (ngApp) {
+                    // Check if Angular has rendered content
+                    return ngApp.children.length > 0;
+                }
+                return true;
+            }, { timeout });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+                framework: 'angular',
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                framework: 'angular',
+                error: e instanceof Error ? e.message : 'Angular stability timeout',
+            };
+        }
+    }
+    /**
+     * Wait for Svelte tick to complete
+     */
+    async waitForSvelteStable(page, config = {}) {
+        const timeout = config.timeout || 15000;
+        const startTime = Date.now();
+        try {
+            await page.waitForFunction(() => {
+                // Svelte doesn't have a global stability check like Angular
+                // We check for the absence of common loading patterns
+                const loadingElements = document.querySelectorAll('[data-svelte-h], [aria-busy="true"], .loading');
+                // Check if DOM is stable by comparing snapshots
+                return loadingElements.length === 0;
+            }, { timeout });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+                framework: 'svelte',
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                framework: 'svelte',
+                error: e instanceof Error ? e.message : 'Svelte stability timeout',
+            };
+        }
+    }
+    /**
+     * Wait for SolidJS reactive updates to complete
+     */
+    async waitForSolidStable(page, config = {}) {
+        const timeout = config.timeout || 10000;
+        const startTime = Date.now();
+        try {
+            await page.waitForFunction(() => {
+                // SolidJS uses _$HY for hydration
+                const solid = window._$HY;
+                if (!solid)
+                    return true; // Not a SolidJS app
+                // Check if Solid has completed hydration
+                return true;
+            }, { timeout });
+            return {
+                success: true,
+                duration: Date.now() - startTime,
+                framework: 'solid',
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                duration: Date.now() - startTime,
+                framework: 'solid',
+                error: e instanceof Error ? e.message : 'SolidJS stability timeout',
+            };
+        }
+    }
+    /**
+     * Auto-detect framework and wait for it to be stable
+     */
+    async waitForFramework(page, config = {}) {
+        const detection = await this.detectFramework(page);
+        switch (detection.framework) {
+            case 'react':
+                return await this.waitForReactHydration(page, config);
+            case 'vue':
+                return await this.waitForVueStable(page, config);
+            case 'angular':
+                return await this.waitForAngularStable(page, config);
+            case 'svelte':
+                return await this.waitForSvelteStable(page, config);
+            case 'solid':
+                return await this.waitForSolidStable(page, config);
+            default:
+                // Unknown framework, just wait for DOM content
+                const startTime = Date.now();
+                try {
+                    await page.waitForLoadState('domcontentloaded', {
+                        timeout: config.timeout || this.defaultTimeout
+                    });
+                    return {
+                        success: true,
+                        duration: Date.now() - startTime,
+                        framework: 'unknown',
+                    };
+                }
+                catch (e) {
+                    return {
+                        success: true,
+                        duration: Date.now() - startTime,
+                        framework: 'unknown',
+                    };
+                }
+        }
+    }
+    /**
+     * Wait for all frameworks to be stable (for micro-frontends)
+     */
+    async waitForAllFrameworks(page, config = {}) {
+        const timeout = config.timeout || this.defaultTimeout;
+        const startTime = Date.now();
+        const results = [];
+        // Detect and wait for React
+        try {
+            const reactResult = await this.waitForReactHydration(page, {
+                timeout: Math.max(5000, timeout / 4)
+            });
+            results.push(reactResult);
+        }
+        catch {
+            // React not present, continue
+        }
+        // Detect and wait for Vue
+        try {
+            const vueResult = await this.waitForVueStable(page, {
+                timeout: Math.max(5000, timeout / 4)
+            });
+            results.push(vueResult);
+        }
+        catch {
+            // Vue not present, continue
+        }
+        // Detect and wait for Angular
+        try {
+            const angularResult = await this.waitForAngularStable(page, {
+                timeout: Math.max(5000, timeout / 4)
+            });
+            results.push(angularResult);
+        }
+        catch {
+            // Angular not present, continue
+        }
+        // Detect and wait for Svelte
+        try {
+            const svelteResult = await this.waitForSvelteStable(page, {
+                timeout: Math.max(3000, timeout / 4)
+            });
+            results.push(svelteResult);
+        }
+        catch {
+            // Svelte not present, continue
+        }
+        const allSuccess = results.every(r => r.success);
+        const frameworks = results.filter(r => r.framework !== 'unknown').map(r => r.framework).join(', ');
+        return {
+            success: allSuccess,
+            duration: Date.now() - startTime,
+            framework: frameworks || 'unknown',
+            error: allSuccess ? undefined : 'Some frameworks did not stabilize',
+        };
+    }
+    /**
+     * Get framework info from the page
+     */
+    async getFrameworkInfo(page) {
+        const detection = await this.detectFramework(page);
+        return {
+            framework: detection.framework || null,
+            version: detection.version,
+            confidence: detection.confidence,
+        };
+    }
+}
+/**
+ * Factory function to create Framework Wait Handler
+ */
+export function createFrameworkWaitHandler(config) {
+    return new FrameworkWaitHandler(config);
+}
+/**
+ * Auto-detect and wait for framework stability (convenience function)
+ */
+export async function waitForFramework(page, config) {
+    const handler = new FrameworkWaitHandler(config);
+    return handler.waitForFramework(page, config);
+}
+export default FrameworkWaitHandler;

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

@@ -0,0 +1,112 @@
+/**
+ * Geo-Location Handler
+ *
+ * P1 - Mock geolocation for testing
+ *
+ * Supports:
+ * - Set custom geolocation
+ * - Common city presets
+ * - Geolocation permission handling
+ * - Coordinate precision control
+ *
+ * @see https://playwright.dev/docs/emulation
+ */
+export interface GeoCoordinates {
+    /** Latitude (-90 to 90) */
+    latitude: number;
+    /** Longitude (-180 to 180) */
+    longitude: number;
+    /** Accuracy in meters (optional) */
+    accuracy?: number;
+    /** Altitude in meters (optional) */
+    altitude?: number;
+    /** Altitude accuracy in meters (optional) */
+    altitudeAccuracy?: number;
+    /** Heading in degrees (0-360, optional) */
+    heading?: number;
+    /** Speed in m/s (optional) */
+    speed?: number;
+}
+export interface GeoLocationConfig {
+    /** Default coordinates */
+    coordinates?: GeoCoordinates;
+    /** Auto-grant permissions */
+    grantPermissions?: boolean;
+}
+/**
+ * Common city presets for testing
+ */
+export declare const CITIES: Record<string, GeoCoordinates>;
+/**
+ * Geo-Location Handler class
+ */
+export declare class GeoLocationHandler {
+    private currentLocation?;
+    private grantPermissions;
+    constructor(config?: GeoLocationConfig);
+    /**
+     * Set geolocation for a context/browser
+     */
+    setGeolocation(context: any, coordinates: GeoCoordinates): Promise<void>;
+    /**
+     * Set geolocation by city preset
+     */
+    setGeolocationByCity(context: any, city: string): Promise<void>;
+    /**
+     * Get current geolocation
+     */
+    getCurrentLocation(): GeoCoordinates | undefined;
+    /**
+     * Grant geolocation permission for a context
+     */
+    grantGeolocationPermission(context: any): Promise<void>;
+    /**
+     * Setup geolocation for a page (includes permission grant)
+     */
+    setup(context: any, coordinates?: GeoCoordinates): Promise<void>;
+    /**
+     * Get geolocation from a page (what the page sees)
+     */
+    getPageGeolocation(page: any): Promise<GeCoordinates | null>;
+    /**
+     * Watch geolocation changes on a page
+     */
+    watchGeolocation(page: any, callback: (pos: GeoCoordinates | null) => void): Promise<void>;
+    /**
+     * Set approximate location (reduced precision for privacy testing)
+     */
+    setApproximateLocation(context: any, coordinates: GeoCoordinates, precision?: number): Promise<void>;
+    /**
+     * Simulate movement along a path
+     */
+    simulateMovement(context: any, from: GeoCoordinates, to: GeoCoordinates, steps?: number, intervalMs?: number): Promise<void>;
+    /**
+     * Animate movement through coordinates
+     */
+    animateMovement(context: any, coordinates: GeoCoordinates[], intervalMs?: number): Promise<void>;
+    /**
+     * Validate coordinates
+     */
+    private validateCoordinates;
+    /**
+     * Get distance between two coordinates (in meters)
+     */
+    getDistance(from: GeoCoordinates, to: GeoCoordinates): number;
+    /**
+     * Get list of available cities
+     */
+    getAvailableCities(): string[];
+    /**
+     * Get coordinates for a city
+     */
+    getCityCoordinates(city: string): GeoCoordinates | undefined;
+}
+/**
+ * Type alias for geolocation coordinates
+ */
+export type GeCoordinates = GeoCoordinates;
+/**
+ * Factory function to create Geo-Location Handler
+ */
+export declare function createGeoLocationHandler(config?: GeoLocationConfig): GeoLocationHandler;
+export default GeoLocationHandler;