qa360 2.3.0 → 2.3.1

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

@@ -0,0 +1,276 @@
+/**
+ * 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
+ */
+/**
+ * Common city presets for testing
+ */
+export const CITIES = {
+    'paris': {
+        latitude: 48.8566,
+        longitude: 2.3522,
+        accuracy: 100,
+    },
+    'new-york': {
+        latitude: 40.7128,
+        longitude: -74.0060,
+        accuracy: 100,
+    },
+    'london': {
+        latitude: 51.5074,
+        longitude: -0.1278,
+        accuracy: 100,
+    },
+    'tokyo': {
+        latitude: 35.6762,
+        longitude: 139.6503,
+        accuracy: 100,
+    },
+    'sydney': {
+        latitude: -33.8688,
+        longitude: 151.2093,
+        accuracy: 100,
+    },
+    'berlin': {
+        latitude: 52.5200,
+        longitude: 13.4050,
+        accuracy: 100,
+    },
+    'san-francisco': {
+        latitude: 37.7749,
+        longitude: -122.4194,
+        accuracy: 100,
+    },
+    'singapore': {
+        latitude: 1.3521,
+        longitude: 103.8198,
+        accuracy: 100,
+    },
+    'dubai': {
+        latitude: 25.2048,
+        longitude: 55.2708,
+        accuracy: 100,
+    },
+    'moscow': {
+        latitude: 55.7558,
+        longitude: 37.6173,
+        accuracy: 100,
+    },
+    'sao-paulo': {
+        latitude: -23.5505,
+        longitude: -46.6333,
+        accuracy: 100,
+    },
+    'toronto': {
+        latitude: 43.6532,
+        longitude: -79.3832,
+        accuracy: 100,
+    },
+};
+/**
+ * Geo-Location Handler class
+ */
+export class GeoLocationHandler {
+    currentLocation;
+    grantPermissions;
+    constructor(config = {}) {
+        this.currentLocation = config.coordinates;
+        this.grantPermissions = config.grantPermissions !== false;
+    }
+    /**
+     * Set geolocation for a context/browser
+     */
+    async setGeolocation(context, coordinates) {
+        this.validateCoordinates(coordinates);
+        await context.setGeolocation(coordinates);
+        this.currentLocation = coordinates;
+    }
+    /**
+     * Set geolocation by city preset
+     */
+    async setGeolocationByCity(context, city) {
+        const cityName = city.toLowerCase().replace(/\s+/g, '-');
+        const coordinates = CITIES[cityName];
+        if (!coordinates) {
+            throw new Error(`Unknown city: ${city}. Available: ${Object.keys(CITIES).join(', ')}`);
+        }
+        await this.setGeolocation(context, coordinates);
+    }
+    /**
+     * Get current geolocation
+     */
+    getCurrentLocation() {
+        return this.currentLocation;
+    }
+    /**
+     * Grant geolocation permission for a context
+     */
+    async grantGeolocationPermission(context) {
+        await context.grantPermissions(['geolocation']);
+    }
+    /**
+     * Setup geolocation for a page (includes permission grant)
+     */
+    async setup(context, coordinates) {
+        const coords = coordinates || this.currentLocation;
+        if (!coords) {
+            throw new Error('No coordinates provided. Use setGeolocation() first or pass coordinates.');
+        }
+        if (this.grantPermissions) {
+            await this.grantGeolocationPermission(context);
+        }
+        await this.setGeolocation(context, coords);
+    }
+    /**
+     * Get geolocation from a page (what the page sees)
+     */
+    async getPageGeolocation(page) {
+        return await page.evaluate(() => {
+            return new Promise((resolve) => {
+                if (!navigator.geolocation) {
+                    resolve(null);
+                    return;
+                }
+                navigator.geolocation.getCurrentPosition((position) => {
+                    resolve({
+                        latitude: position.coords.latitude,
+                        longitude: position.coords.longitude,
+                        accuracy: position.coords.accuracy,
+                        altitude: position.coords.altitude || undefined,
+                        altitudeAccuracy: position.coords.altitudeAccuracy || undefined,
+                        heading: position.coords.heading || undefined,
+                        speed: position.coords.speed || undefined,
+                    });
+                }, () => {
+                    resolve(null);
+                });
+            });
+        });
+    }
+    /**
+     * Watch geolocation changes on a page
+     */
+    async watchGeolocation(page, callback) {
+        await page.evaluate((cb) => {
+            if (!navigator.geolocation) {
+                cb(null);
+                return;
+            }
+            const watchId = navigator.geolocation.watchPosition((position) => {
+                cb({
+                    latitude: position.coords.latitude,
+                    longitude: position.coords.longitude,
+                    accuracy: position.coords.accuracy,
+                    altitude: position.coords.altitude || undefined,
+                    altitudeAccuracy: position.coords.altitudeAccuracy || undefined,
+                    heading: position.coords.heading || undefined,
+                    speed: position.coords.speed || undefined,
+                });
+            }, () => {
+                cb(null);
+            });
+            return () => {
+                navigator.geolocation.clearWatch(watchId);
+            };
+        }, callback);
+    }
+    /**
+     * Set approximate location (reduced precision for privacy testing)
+     */
+    async setApproximateLocation(context, coordinates, precision = 1000) {
+        // Add random jitter within precision radius
+        const randomAngle = Math.random() * 2 * Math.PI;
+        const randomDistance = Math.random() * precision;
+        // Approximate conversion: 1 degree ≈ 111km
+        const latOffset = (randomDistance * Math.sin(randomAngle)) / 111000;
+        const lonOffset = (randomDistance * Math.cos(randomAngle)) / (111000 * Math.cos(coordinates.latitude * Math.PI / 180));
+        await this.setGeolocation(context, {
+            ...coordinates,
+            latitude: coordinates.latitude + latOffset,
+            longitude: coordinates.longitude + lonOffset,
+            accuracy: precision,
+        });
+    }
+    /**
+     * Simulate movement along a path
+     */
+    async simulateMovement(context, from, to, steps = 10, intervalMs = 1000) {
+        const coordinates = [];
+        for (let i = 0; i <= steps; i++) {
+            const ratio = i / steps;
+            coordinates.push({
+                latitude: from.latitude + (to.latitude - from.latitude) * ratio,
+                longitude: from.longitude + (to.longitude - from.longitude) * ratio,
+                accuracy: Math.max(from.accuracy || 0, to.accuracy || 0),
+            });
+        }
+        return this.animateMovement(context, coordinates, intervalMs);
+    }
+    /**
+     * Animate movement through coordinates
+     */
+    async animateMovement(context, coordinates, intervalMs = 1000) {
+        for (const coord of coordinates) {
+            await this.setGeolocation(context, coord);
+            await new Promise(resolve => setTimeout(resolve, intervalMs));
+        }
+    }
+    /**
+     * Validate coordinates
+     */
+    validateCoordinates(coordinates) {
+        if (coordinates.latitude < -90 || coordinates.latitude > 90) {
+            throw new Error(`Invalid latitude: ${coordinates.latitude}. Must be between -90 and 90.`);
+        }
+        if (coordinates.longitude < -180 || coordinates.longitude > 180) {
+            throw new Error(`Invalid longitude: ${coordinates.longitude}. Must be between -180 and 180.`);
+        }
+        if (coordinates.accuracy !== undefined && coordinates.accuracy < 0) {
+            throw new Error(`Invalid accuracy: ${coordinates.accuracy}. Must be non-negative.`);
+        }
+    }
+    /**
+     * Get distance between two coordinates (in meters)
+     */
+    getDistance(from, to) {
+        const R = 6371e3; // Earth radius in meters
+        const φ1 = from.latitude * Math.PI / 180;
+        const φ2 = to.latitude * Math.PI / 180;
+        const Δφ = (to.latitude - from.latitude) * Math.PI / 180;
+        const Δλ = (to.longitude - from.longitude) * Math.PI / 180;
+        const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +
+            Math.cos(φ1) * Math.cos(φ2) *
+                Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
+        const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        return R * c;
+    }
+    /**
+     * Get list of available cities
+     */
+    getAvailableCities() {
+        return Object.keys(CITIES);
+    }
+    /**
+     * Get coordinates for a city
+     */
+    getCityCoordinates(city) {
+        const cityName = city.toLowerCase().replace(/\s+/g, '-');
+        return CITIES[cityName];
+    }
+}
+/**
+ * Factory function to create Geo-Location Handler
+ */
+export function createGeoLocationHandler(config) {
+    return new GeoLocationHandler(config);
+}
+export default GeoLocationHandler;

package/dist/core/crawler/index.d.ts

@@ -0,0 +1,78 @@
+/**
+ * QA360 Web Crawler
+ *
+ * Automatically discovers and analyzes web applications for E2E test generation
+ */
+import type { CrawlOptions, CrawlResult, PageDefinition, CrawlProgress, CrawlEventHandler } from './types.js';
+/**
+ * Web Crawler class
+ */
+export declare class WebCrawler {
+    private options;
+    private eventHandler?;
+    private analyzer;
+    private visited;
+    private queue;
+    private pages;
+    private errors;
+    private warnings;
+    private startTime;
+    private readonly defaultOptions;
+    constructor(options: CrawlOptions);
+    /**
+     * Set event handler for progress updates
+     */
+    on(event: CrawlEventHandler): void;
+    /**
+     * Emit event to handler
+     */
+    private emit;
+    /**
+     * Normalize URL for comparison
+     */
+    private normalizeUrl;
+    /**
+     * Check if URL should be excluded
+     */
+    private isExcluded;
+    /**
+     * Start crawling
+     */
+    crawl(): Promise<CrawlResult>;
+    /**
+     * Build site map from crawled pages
+     */
+    private buildSiteMap;
+}
+/**
+ * Crawl a web application and return results
+ */
+export declare function crawlWebsite(options: CrawlOptions): Promise<CrawlResult>;
+/**
+ * Crawl a website with progress callback
+ */
+export declare function crawlWebsiteWithProgress(options: CrawlOptions, onProgress: (progress: CrawlProgress, page?: PageDefinition) => void): Promise<CrawlResult>;
+export * from './types.js';
+export { generateSelector, generateSelectorFromElement, generateIntelligentSelector, generateSelectorWithMetadata, initializeSelectorGenerator, getSiteProfile, getSelectorStrategy, SiteProfiler, analyzeSite, determineSiteProfile, isGeneratedId, isSemanticId, isUtilityClass, SELECTOR_STRATEGIES, } from './selector-generator.js';
+export { generateJourneys } from './journey-generator.js';
+export { AdvancedInteractionsHandler, createAdvancedInteractionsHandler, type ElementLocation, type FileUploadResult, type FileDownloadResult, type AdvancedInteractionsOptions, } from './advanced-interactions.js';
+export { FormHandler, createFormHandler, type FormField, type FormData, type FormConfig, type FormFillData, type FormResult, } from './form-handler.js';
+export { DownloadHandler, createDownloadHandler, type DownloadConfig, type DownloadInfo, type DownloadActionOptions, type DownloadVerification, type DownloadResult, } from './download-handler.js';
+export { GeoLocationHandler, createGeoLocationHandler, type GeoCoordinates, type GeoLocationConfig, CITIES, } from './geolocation-handler.js';
+export { PermissionsHandler, createPermissionsHandler, type PermissionType, type PermissionState, type PermissionConfig, type PermissionChange, PERMISSION_PRESETS, } from './permissions-handler.js';
+export { WaitStrategies, createWaitStrategies, type WaitConfig, type NetworkIdleConfig, type StabilityConfig, type WaitResult, } from './wait-strategies.js';
+export { CookieManager, createCookieManager, type CookieOptions, type CookieValidationResult, type CookieFilterOptions, } from './cookie-manager.js';
+export { CSPHandler, createCSPHandler, type CSPDirective, type CPSPolicy, type CSPValidationResult, type CSPViolation, } from './csp-handler.js';
+export { COOPCOEPHandler, createCOOPCOEPHandler, type COOPValue, type COEPValue, type COOPConfig, type COEPConfig, type CrossOriginIsolationStatus, } from './coop-coep-handler.js';
+export { PermissionsPolicyHandler, createPermissionsPolicyHandler, type PermissionsPolicyFeature, type PermissionsPolicyDirective, type PermissionsPolicyResult, type PermissionsPolicyReport, } from './permissions-policy-handler.js';
+export { TrustedTypesHandler, createTrustedTypesHandler, type TrustedTypesConfig, type TrustedTypePolicy, type XSSSink, type TrustedTypesReport, } from './trusted-types-handler.js';
+export { SourceMapsHandler, createSourceMapsHandler, type SourceMapLocation, type SourceMapInfo, type MappedError, type SourceMapResult, } from './sourcemaps-handler.js';
+export { ErrorTrackingHandler, createErrorTrackingHandler, type ErrorInfo, type ErrorGroup, type ResourceError, type ErrorReport, } from './error-tracking-handler.js';
+export { ReportingAPIHandler, createReportingAPIHandler, type Report, type ReportType, type CSPViolationReport, type PermissionsPolicyViolationReport, type InterventionReport, type DeprecationReport, type ReportingEndpoint, type ReportingAPIConfig, type ReportingSummary, } from './reporting-api-handler.js';
+export { FrameworkWaitHandler, createFrameworkWaitHandler, waitForFramework, type FrameworkWaitConfig, type FrameworkDetectionResult, type FrameworkWaitResult, } from './framework-wait-handler.js';
+export { BlobURLDownloadHandler, createBlobURLDownloadHandler, type BlobDownloadConfig, type BlobDownloadInfo, type BlobDownloadResult, } from './blob-url-download-handler.js';
+export { EmailTestingHandler, createEmailTestingHandler, waitForEmail, type EmailConfig, type EmailMessage, type EmailAttachment, type EmailSearchOptions, } from './email-testing-handler.js';
+export { REPLDebugHandler, createREPLDebugHandler, startREPL, type REPLConfig, type REPLCommand, type REPLContext, } from './repl-debug-handler.js';
+export { StackedModalsHandler, createStackedModalsHandler, type ModalInfo, type ModalHierarchy, type ModalActionOptions, } from './stacked-modals-handler.js';
+export { detectPresetFromUrl, getAllPresets, getPreset, getPresetList, PRESETS, } from './presets.js';
+export type { CrawlerPreset } from './presets.js';

package/{cli/dist → dist}/core/crawler/index.js

@@ -67,6 +67,26 @@ export class WebCrawler {
      */
     isExcluded(url) {
         const normalized = this.normalizeUrl(url);
+        // Check onlyPatterns (Phase 1: if specified, only include URLs matching these patterns)
+        if (this.options.onlyPatterns && this.options.onlyPatterns.length > 0) {
+            let matchesOnlyPattern = false;
+            for (const pattern of this.options.onlyPatterns) {
+                try {
+                    const regex = new RegExp(pattern);
+                    if (regex.test(normalized) || regex.test(url)) {
+                        matchesOnlyPattern = true;
+                        break;
+                    }
+                }
+                catch {
+                    // Invalid regex, skip
+                }
+            }
+            // If onlyPatterns is set but URL doesn't match any, exclude it
+            if (!matchesOnlyPattern) {
+                return true;
+            }
+        }
         // Check exclude patterns
         for (const pattern of this.options.excludePatterns || []) {
             try {
@@ -84,11 +104,23 @@ export class WebCrawler {
             /\.pdf$/,
             /\.zip$/,
             /\.jpg$/,
+            /\.jpeg$/,
             /\.png$/,
             /\.gif$/,
             /\.svg$/,
+            /\.css$/, // Stylesheets
+            /\.js$/, // JavaScript files
+            /\.ico$/, // Favicons
+            /\.woff/,
+            /\.woff2$/,
+            /\.ttf$/,
+            /\.eot$/,
             /\/api\//,
             /\/graphql/,
+            /\/assets\//, // Asset directories
+            /\/static\//, // Static file directories
+            /\/_next\//, // Next.js internal
+            /\/_nuxt\//, // Nuxt.js internal
             /mailto:/,
             /tel:/,
             'javascript:',
@@ -277,5 +309,46 @@ export async function crawlWebsiteWithProgress(options, onProgress) {
 }
 // Re-export types
 export * from './types.js';
-export { generateSelector, generateSelectorFromElement } from './selector-generator.js';
+// Re-export selector generator (legacy + intelligent)
+export { generateSelector, generateSelectorFromElement, generateIntelligentSelector, generateSelectorWithMetadata, initializeSelectorGenerator, getSiteProfile, getSelectorStrategy, SiteProfiler, analyzeSite, determineSiteProfile, isGeneratedId, isSemanticId, isUtilityClass, SELECTOR_STRATEGIES, } from './selector-generator.js';
 export { generateJourneys } from './journey-generator.js';
+// P0 Features: Advanced Interactions (Shadow DOM, Iframes, Files)
+export { AdvancedInteractionsHandler, createAdvancedInteractionsHandler, } from './advanced-interactions.js';
+// P1 Features: Form Handler
+export { FormHandler, createFormHandler, } from './form-handler.js';
+// P1 Features: Download Handler
+export { DownloadHandler, createDownloadHandler, } from './download-handler.js';
+// P1 Features: Geo-Location Handler
+export { GeoLocationHandler, createGeoLocationHandler, CITIES, } from './geolocation-handler.js';
+// P1 Features: Permissions Handler
+export { PermissionsHandler, createPermissionsHandler, PERMISSION_PRESETS, } from './permissions-handler.js';
+// P1 Features: Wait Strategies
+export { WaitStrategies, createWaitStrategies, } from './wait-strategies.js';
+// P1 Features: Cookie Manager
+export { CookieManager, createCookieManager, } from './cookie-manager.js';
+// P1 Features: CSP Handler
+export { CSPHandler, createCSPHandler, } from './csp-handler.js';
+// P1 Features: COOP/COEP Handler
+export { COOPCOEPHandler, createCOOPCOEPHandler, } from './coop-coep-handler.js';
+// P1 Features: Permissions Policy Handler
+export { PermissionsPolicyHandler, createPermissionsPolicyHandler, } from './permissions-policy-handler.js';
+// P1 Features: Trusted Types Handler
+export { TrustedTypesHandler, createTrustedTypesHandler, } from './trusted-types-handler.js';
+// P1 Features: Source Maps Handler
+export { SourceMapsHandler, createSourceMapsHandler, } from './sourcemaps-handler.js';
+// P1 Features: Error Tracking Handler
+export { ErrorTrackingHandler, createErrorTrackingHandler, } from './error-tracking-handler.js';
+// P1 Features: Reporting API Handler
+export { ReportingAPIHandler, createReportingAPIHandler, } from './reporting-api-handler.js';
+// P1 Features: Framework Wait Handler (React/Vue/Angular/Svelte/SolidJS)
+export { FrameworkWaitHandler, createFrameworkWaitHandler, waitForFramework, } from './framework-wait-handler.js';
+// P1 Features: Blob URL Download Handler
+export { BlobURLDownloadHandler, createBlobURLDownloadHandler, } from './blob-url-download-handler.js';
+// P1 Features: Email Testing Handler (Mailhog/Mailtrap/Mailgun/SendGrid)
+export { EmailTestingHandler, createEmailTestingHandler, waitForEmail, } from './email-testing-handler.js';
+// P1 Features: REPL Debug Handler
+export { REPLDebugHandler, createREPLDebugHandler, startREPL, } from './repl-debug-handler.js';
+// P1 Features: Stacked Modals Handler
+export { StackedModalsHandler, createStackedModalsHandler, } from './stacked-modals-handler.js';
+// Crawler Presets
+export { detectPresetFromUrl, getAllPresets, getPreset, getPresetList, PRESETS, } from './presets.js';

package/dist/core/crawler/intelligent-selector-generator.d.ts

@@ -0,0 +1,164 @@
+/**
+ * QA360 Intelligent Selector Generator
+ *
+ * Generates optimal CSS selectors by adapting to the detected site profile.
+ * Follows Testing Library best practices with configurable strategies.
+ *
+ * Philosophy: "The more your tests resemble the way your software is used,
+ *              the more confidence they can give you." - Kent C. Dodds
+ */
+import type { SiteAnalysis, SiteProfile } from './site-profiler.js';
+/**
+ * Selector strategy tier definition
+ */
+export interface SelectorTier {
+    tier: number;
+    name: string;
+    fn: string;
+    weight: number;
+}
+/**
+ * Selector generation result with metadata
+ */
+export interface SelectorResult {
+    selector: string;
+    tier: number;
+    type: string;
+    weight: number;
+}
+/**
+ * Element information for selector generation
+ */
+export interface ElementInfo {
+    tagName?: string;
+    id?: string;
+    className?: string;
+    attributes?: Record<string, string>;
+    textContent?: string;
+    role?: string;
+    name?: string;
+    value?: string;
+    type?: string;
+}
+/**
+ * Selector strategies by site profile
+ *
+ * Each profile has a different priority order (tiers) for selector generation.
+ * Higher tier = higher priority = checked first.
+ */
+declare const SELECTOR_STRATEGIES: Record<SiteProfile, SelectorTier[]>;
+/**
+ * Check if ID is auto-generated (NOT stable)
+ */
+export declare function isGeneratedId(id: string): boolean;
+/**
+ * Check if ID is semantic (describes the PURPOSE)
+ */
+export declare function isSemanticId(id: string): boolean;
+/**
+ * Check if class is a utility class (should be filtered out)
+ */
+export declare function isUtilityClass(cls: string): boolean;
+/**
+ * Intelligent Selector Generator
+ *
+ * Adapts selector generation strategy based on detected site profile.
+ */
+export declare class IntelligentSelectorGenerator {
+    private siteProfile;
+    private siteAnalysis;
+    strategy: SelectorTier[] | null;
+    /**
+     * Initialize the generator with site analysis
+     */
+    initialize(analysis: SiteAnalysis): void;
+    /**
+     * Get the current site profile
+     */
+    getProfile(): SiteProfile | null;
+    /**
+     * Get the current strategy
+     */
+    getStrategy(): SelectorTier[] | null;
+    /**
+     * Determine site profile from analysis
+     */
+    private determineProfile;
+    /**
+     * Log the detected profile to console
+     */
+    private logProfile;
+    /**
+     * Generate optimal selector for an element
+     */
+    generateSelector(element: ElementInfo): SelectorResult;
+    /**
+     * Try to generate a selector for a specific type
+     */
+    private trySelector;
+    /**
+     * TIER 1/7 - Get test ID selector
+     */
+    private getTestIdSelector;
+    /**
+     * TIER 2/6 - Get role + name selector (ARIA)
+     */
+    private getRoleNameSelector;
+    /**
+     * TIER 3 - Get label selector
+     */
+    private getLabelSelector;
+    /**
+     * TIER 4 - Get placeholder selector
+     */
+    private getPlaceholderSelector;
+    /**
+     * TIER 5/1 - Get text selector
+     */
+    private getTextSelector;
+    /**
+     * TIER 6/4 - Get alt text selector (images)
+     */
+    private getAltTextSelector;
+    /**
+     * TIER 7 - Get title selector
+     */
+    private getTitleSelector;
+    /**
+     * TIER 8/1 - Get ID selector (semantic only)
+     */
+    private getIdSelector;
+    /**
+     * TIER 2 - Get name selector (for forms)
+     */
+    private getNameSelector;
+    /**
+     * TIER 4 - Get value selector (submit buttons, etc.)
+     */
+    private getValueSelector;
+    /**
+     * TIER 9/7 - Get CSS selector (MAX 2 semantic classes)
+     */
+    private getCssSelector;
+}
+/**
+ * Initialize the global generator with site analysis
+ */
+export declare function initializeSelectorGenerator(analysis: SiteAnalysis): void;
+/**
+ * Generate optimal selector for an element (uses global instance)
+ */
+export declare function generateSelector(element: ElementInfo): string;
+/**
+ * Generate selector with metadata (tier, type, weight)
+ */
+export declare function generateSelectorWithMetadata(element: ElementInfo): SelectorResult;
+/**
+ * Get the current site profile
+ */
+export declare function getSiteProfile(): SiteProfile | null;
+/**
+ * Get the current strategy
+ */
+export declare function getSelectorStrategy(): SelectorTier[] | null;
+export { SELECTOR_STRATEGIES };