qa360 2.3.0 → 2.3.1

package/{cli/dist → dist}/core/types/pack-v1.d.ts

@@ -10,9 +10,22 @@ export interface ApiTarget {
     baseUrl: string;
     smoke?: string[];
 }
+/** Page action for UI tests */
+export interface PageAction {
+    type: 'goto' | 'navigate' | 'click' | 'fill' | 'select' | 'check' | 'uncheck' | 'wait' | 'waitFor' | 'screenshot' | 'assert';
+    selector?: string;
+    value?: string;
+    options?: Record<string, unknown>;
+}
+/** Page with optional actions */
+export interface PageWithActions {
+    url: string;
+    actions?: PageAction[];
+}
 export interface WebTarget {
     baseUrl: string;
-    pages?: string[];
+    /** Pages can be strings or objects with actions */
+    pages?: (string | PageWithActions)[];
     /** Browser mode: true for headed (visible), false for headless (default) */
     headless?: boolean;
     /** Slow motion delay in ms between actions (for debugging) */
@@ -36,7 +49,7 @@ export interface WebTarget {
     uiTests?: UiTestDefinition[];
 }
 /** UI Test Step Action */
-export type UiAction = 'navigate' | 'click' | 'dblClick' | 'rightClick' | 'hover' | 'focus' | 'fill' | 'type' | 'clear' | 'select' | 'check' | 'uncheck' | 'upload' | 'press' | 'waitFor' | 'waitForSelector' | 'waitForNavigation' | 'waitForTimeout' | 'scroll' | 'dragAndDrop' | 'tap';
+export type UiAction = 'navigate' | 'click' | 'dblClick' | 'rightClick' | 'hover' | 'focus' | 'fill' | 'type' | 'clear' | 'select' | 'check' | 'uncheck' | 'upload' | 'press' | 'waitFor' | 'waitForSelector' | 'waitForNavigation' | 'waitForTimeout' | 'scroll' | 'dragAndDrop' | 'tap' | 'expectDialog' | 'clickAndWaitForPopup' | 'switchToTab' | 'closeTab' | 'waitForNewTab' | 'switchToFrame' | 'switchToMainFrame' | 'waitForFrame' | 'clickInFrame' | 'fillInFrame' | 'clickShadow' | 'fillShadow' | 'waitForShadow' | 'clickAndDownload' | 'waitForDownload' | 'mockRoute' | 'unmockRoute' | 'waitForResponse' | 'setLocalStorage' | 'getLocalStorage' | 'clearLocalStorage' | 'setSessionStorage' | 'getSessionStorage' | 'clearSessionStorage' | 'setCookie' | 'getCookie' | 'clearCookies' | 'grantPermissions' | 'setGeolocation' | 'clearGeolocation' | 'setViewport' | 'emulateDevice' | 'touchAction' | 'retry' | 'waitForFunction' | 'evaluate' | 'waitForURL' | 'reload' | 'goBack' | 'goForward' | 'analyzeSite' | 'handleConsent' | 'generateSelector' | 'assertVisible' | 'assertHidden' | 'assertAttached' | 'assertText' | 'assertContains' | 'assertValue' | 'assertAttribute' | 'assertClass' | 'assertCount' | 'assertURL' | 'assertTitle' | 'assertEnabled' | 'assertDisabled' | 'assertChecked' | 'assertUnchecked' | 'assertFocused' | 'assertEmpty' | 'assertNotEmpty' | 'assertReadOnly' | 'assertEditable' | 'assertSelected' | 'assertHref' | 'assertSrc' | 'assertPlaceholder' | 'assertID' | 'assertTagName' | 'assertCSS' | 'assertInViewport' | 'assertHasAttribute' | 'screenshot' | 'hoverScreenshot' | 'fullPageScreenshot' | 'waitForLoadState' | 'waitForSelectorState' | 'selectOption' | 'deselectOption' | 'focus' | 'blur' | 'highlight' | 'getHTML' | 'getText' | 'getAttribute' | 'getBoundingBox' | 'getElementCount' | 'getAllText' | 'getTableData' | 'waitForText' | 'waitForValue' | 'waitForClass' | 'waitForAttribute' | 'waitForEnabled' | 'waitForDisabled';
 /** UI Test Step */
 export interface UiTestStep {
     /** Step order */

package/{cli/dist → dist}/core/types/pack-v2.d.ts

@@ -415,7 +415,7 @@ export interface WebPage {
  * Page action for UI tests
  */
 export interface PageAction {
-    type: 'goto' | 'click' | 'fill' | 'select' | 'wait' | 'screenshot' | 'assert';
+    type: 'goto' | 'navigate' | 'click' | 'fill' | 'select' | 'check' | 'uncheck' | 'wait' | 'waitFor' | 'screenshot' | 'assert';
     selector?: string;
     value?: string;
     options?: Record<string, unknown>;

package/dist/core/upload/chunked-uploader.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Chunked File Uploader
+ *
+ * Handles large file uploads by splitting them into chunks.
+ * Supports:
+ * - Configurable chunk size
+ * - Progress tracking
+ * - Retry failed chunks
+ * - Parallel chunk upload
+ * - Pause/resume functionality
+ */
+export interface ChunkUploadConfig {
+    /** Size of each chunk in bytes (default: 5MB) */
+    chunkSize?: number;
+    /** Number of parallel uploads (default: 3) */
+    parallelUploads?: number;
+    /** Max retries per chunk (default: 3) */
+    maxRetries?: number;
+    /** Delay between retries in ms (default: 1000) */
+    retryDelay?: number;
+    /** Upload endpoint */
+    endpoint: string;
+    /** Headers to include with each chunk request */
+    headers?: Record<string, string>;
+    /** Query params for the upload request */
+    params?: Record<string, string>;
+    /** Additional form data fields */
+    fields?: Record<string, string>;
+    /** File field name (default: 'file') */
+    fileField?: string;
+    /** Chunk index field name (default: 'chunkIndex') */
+    chunkIndexField?: string;
+    /** Total chunks field name (default: 'totalChunks') */
+    totalChunksField?: string;
+    /** File ID field name (for resume, default: 'fileId') */
+    fileIdField?: string;
+    /** Progress callback */
+    onProgress?: (progress: UploadProgress) => void;
+}
+export interface UploadProgress {
+    /** Bytes uploaded */
+    uploaded: number;
+    /** Total bytes */
+    total: number;
+    /** Percentage (0-100) */
+    percentage: number;
+    /** Current chunk index */
+    chunkIndex: number;
+    /** Total chunks */
+    totalChunks: number;
+    /** Upload speed in bytes/second */
+    speed?: number;
+    /** Estimated remaining time in seconds */
+    remaining?: number;
+}
+export interface ChunkUploadResult {
+    /** Upload success status */
+    success: boolean;
+    /** File ID from server (for resume/combine) */
+    fileId?: string;
+    /** Server response */
+    response?: any;
+    /** Error if failed */
+    error?: string;
+    /** Upload progress */
+    progress: UploadProgress;
+}
+export interface ChunkInfo {
+    index: number;
+    start: number;
+    end: number;
+    size: number;
+    data: Blob;
+    retries: number;
+}
+/**
+ * Chunked file uploader class
+ */
+export declare class ChunkedUploader {
+    private config;
+    private aborted;
+    private paused;
+    private uploadStartTime;
+    private lastProgressUpdate;
+    private fileId?;
+    private uploadedChunks;
+    constructor(config: ChunkUploadConfig);
+    /**
+     * Upload a file in chunks
+     */
+    upload(file: File | Blob, fileId?: string): Promise<ChunkUploadResult>;
+    /**
+     * Create file chunks
+     */
+    private createChunks;
+    /**
+     * Upload chunks with parallel processing
+     */
+    private uploadChunks;
+    /**
+     * Upload a single chunk
+     */
+    private uploadChunk;
+    /**
+     * Finalize upload (combine chunks on server)
+     */
+    private finalizeUpload;
+    /**
+     * Get current progress
+     */
+    private getProgress;
+    /**
+     * Report progress (throttled to avoid excessive updates)
+     */
+    private reportProgress;
+    /**
+     * Pause the upload
+     */
+    pause(): void;
+    /**
+     * Resume the upload
+     */
+    resume(): void;
+    /**
+     * Abort the upload
+     */
+    abort(): void;
+    /**
+     * Check if upload is paused
+     */
+    isPaused(): boolean;
+    /**
+     * Check if upload is aborted
+     */
+    isAborted(): boolean;
+    /**
+     * Generate a unique file ID
+     */
+    private generateFileId;
+    private sleep;
+}
+/**
+ * Create a chunked uploader instance
+ */
+export declare function createChunkedUploader(config: ChunkUploadConfig): ChunkedUploader;
+/**
+ * Upload a file in chunks (convenience function)
+ */
+export declare function uploadFileInChunks(file: File | Blob, config: ChunkUploadConfig): Promise<ChunkUploadResult>;
+export default ChunkedUploader;

package/dist/core/upload/chunked-uploader.js

@@ -0,0 +1,289 @@
+/**
+ * Chunked File Uploader
+ *
+ * Handles large file uploads by splitting them into chunks.
+ * Supports:
+ * - Configurable chunk size
+ * - Progress tracking
+ * - Retry failed chunks
+ * - Parallel chunk upload
+ * - Pause/resume functionality
+ */
+/**
+ * Chunked file uploader class
+ */
+export class ChunkedUploader {
+    config;
+    aborted = false;
+    paused = false;
+    uploadStartTime = 0;
+    lastProgressUpdate = 0;
+    fileId;
+    uploadedChunks = new Set();
+    constructor(config) {
+        this.config = {
+            chunkSize: config.chunkSize || 5 * 1024 * 1024, // 5MB default
+            parallelUploads: config.parallelUploads || 3,
+            maxRetries: config.maxRetries || 3,
+            retryDelay: config.retryDelay || 1000,
+            endpoint: config.endpoint,
+            headers: config.headers || {},
+            params: config.params || {},
+            fields: config.fields || {},
+            fileField: config.fileField || 'file',
+            chunkIndexField: config.chunkIndexField || 'chunkIndex',
+            totalChunksField: config.totalChunksField || 'totalChunks',
+            fileIdField: config.fileIdField || 'fileId',
+            onProgress: config.onProgress || (() => { }),
+        };
+    }
+    /**
+     * Upload a file in chunks
+     */
+    async upload(file, fileId) {
+        this.aborted = false;
+        this.paused = false;
+        this.uploadStartTime = Date.now();
+        this.fileId = fileId;
+        this.uploadedChunks.clear();
+        const fileSize = file.size;
+        const totalChunks = Math.ceil(fileSize / this.config.chunkSize);
+        // Create chunks
+        const chunks = this.createChunks(file, totalChunks);
+        // Upload chunks
+        try {
+            await this.uploadChunks(chunks, fileSize, totalChunks);
+            if (this.aborted) {
+                return {
+                    success: false,
+                    error: 'Upload aborted',
+                    progress: this.getProgress(fileSize, totalChunks, 0),
+                };
+            }
+            // Combine chunks on server (if needed)
+            const result = await this.finalizeUpload(fileId || this.generateFileId(), totalChunks, file);
+            return {
+                success: true,
+                fileId: result.fileId,
+                response: result.response,
+                progress: this.getProgress(fileSize, totalChunks, totalChunks),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Upload failed',
+                progress: this.getProgress(fileSize, totalChunks, this.uploadedChunks.size),
+            };
+        }
+    }
+    /**
+     * Create file chunks
+     */
+    createChunks(file, totalChunks) {
+        const chunks = [];
+        for (let i = 0; i < totalChunks; i++) {
+            const start = i * this.config.chunkSize;
+            const end = Math.min(start + this.config.chunkSize, file.size);
+            const size = end - start;
+            chunks.push({
+                index: i,
+                start,
+                end,
+                size,
+                data: file.slice(start, end),
+                retries: 0,
+            });
+        }
+        return chunks;
+    }
+    /**
+     * Upload chunks with parallel processing
+     */
+    async uploadChunks(chunks, fileSize, totalChunks) {
+        const queue = [...chunks];
+        const activeUploads = [];
+        while (queue.length > 0 && !this.aborted) {
+            while (this.paused) {
+                await this.sleep(100);
+            }
+            while (activeUploads.length < this.config.parallelUploads && queue.length > 0) {
+                const chunk = queue.shift();
+                const uploadPromise = this.uploadChunk(chunk, fileSize, totalChunks)
+                    .then(() => {
+                    activeUploads.splice(activeUploads.indexOf(uploadPromise), 1);
+                })
+                    .catch(async (error) => {
+                    activeUploads.splice(activeUploads.indexOf(uploadPromise), 1);
+                    if (chunk.retries < this.config.maxRetries) {
+                        chunk.retries++;
+                        queue.push(chunk);
+                        await this.sleep(this.config.retryDelay);
+                    }
+                    else {
+                        throw error;
+                    }
+                });
+                activeUploads.push(uploadPromise);
+            }
+            await Promise.race(activeUploads);
+        }
+        await Promise.all(activeUploads);
+    }
+    /**
+     * Upload a single chunk
+     */
+    async uploadChunk(chunk, fileSize, totalChunks) {
+        const formData = new FormData();
+        // Add chunk data
+        formData.append(this.config.fileField, chunk.data);
+        // Add chunk metadata
+        formData.append(this.config.chunkIndexField, chunk.index.toString());
+        formData.append(this.config.totalChunksField, totalChunks.toString());
+        // Add file ID if resuming
+        if (this.fileId) {
+            formData.append(this.config.fileIdField, this.fileId);
+        }
+        // Add additional fields
+        Object.entries(this.config.fields).forEach(([key, value]) => {
+            formData.append(key, value);
+        });
+        // Build URL with params
+        let url = this.config.endpoint;
+        const queryParams = new URLSearchParams(this.config.params).toString();
+        if (queryParams) {
+            url += (url.includes('?') ? '&' : '?') + queryParams;
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this.config.headers,
+            body: formData,
+        });
+        if (!response.ok) {
+            throw new Error(`Chunk ${chunk.index} upload failed: ${response.statusText}`);
+        }
+        const result = await response.json().catch(() => ({}));
+        // Store file ID from first chunk if provided
+        if (chunk.index === 0 && result.fileId) {
+            this.fileId = result.fileId;
+        }
+        this.uploadedChunks.add(chunk.index);
+        // Report progress
+        this.reportProgress(fileSize, totalChunks, chunk.index + 1);
+    }
+    /**
+     * Finalize upload (combine chunks on server)
+     */
+    async finalizeUpload(fileId, totalChunks, file) {
+        // Some servers auto-combine, others need explicit finalize call
+        const formData = new FormData();
+        formData.append(this.config.fileIdField, fileId);
+        formData.append(this.config.totalChunksField, totalChunks.toString());
+        formData.append('fileName', file.name || 'upload');
+        formData.append('fileSize', file.size.toString());
+        let url = this.config.endpoint.replace(/\/chunk$/, '/finalize');
+        const queryParams = new URLSearchParams(this.config.params).toString();
+        if (queryParams) {
+            url += (url.includes('?') ? '&' : '?') + queryParams;
+        }
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: this.config.headers,
+                body: formData,
+            });
+            if (response.ok) {
+                const result = await response.json().catch(() => ({}));
+                return { fileId, response: result };
+            }
+        }
+        catch {
+            // Finalize endpoint might not exist, server may auto-combine
+        }
+        return { fileId };
+    }
+    /**
+     * Get current progress
+     */
+    getProgress(fileSize, totalChunks, completedChunks) {
+        const uploaded = completedChunks * this.config.chunkSize;
+        const total = fileSize;
+        const percentage = Math.min(100, (uploaded / total) * 100);
+        const elapsed = (Date.now() - this.uploadStartTime) / 1000;
+        const speed = elapsed > 0 ? uploaded / elapsed : 0;
+        const remaining = speed > 0 ? (total - uploaded) / speed : 0;
+        return {
+            uploaded: Math.min(uploaded, fileSize),
+            total,
+            percentage,
+            chunkIndex: completedChunks,
+            totalChunks,
+            speed,
+            remaining,
+        };
+    }
+    /**
+     * Report progress (throttled to avoid excessive updates)
+     */
+    reportProgress(fileSize, totalChunks, completedChunks) {
+        const now = Date.now();
+        if (now - this.lastProgressUpdate < 100)
+            return; // Throttle to 100ms
+        this.lastProgressUpdate = now;
+        const progress = this.getProgress(fileSize, totalChunks, completedChunks);
+        this.config.onProgress(progress);
+    }
+    /**
+     * Pause the upload
+     */
+    pause() {
+        this.paused = true;
+    }
+    /**
+     * Resume the upload
+     */
+    resume() {
+        this.paused = false;
+    }
+    /**
+     * Abort the upload
+     */
+    abort() {
+        this.aborted = true;
+    }
+    /**
+     * Check if upload is paused
+     */
+    isPaused() {
+        return this.paused;
+    }
+    /**
+     * Check if upload is aborted
+     */
+    isAborted() {
+        return this.aborted;
+    }
+    /**
+     * Generate a unique file ID
+     */
+    generateFileId() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+/**
+ * Create a chunked uploader instance
+ */
+export function createChunkedUploader(config) {
+    return new ChunkedUploader(config);
+}
+/**
+ * Upload a file in chunks (convenience function)
+ */
+export async function uploadFileInChunks(file, config) {
+    const uploader = new ChunkedUploader(config);
+    return uploader.upload(file);
+}
+export default ChunkedUploader;

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

@@ -0,0 +1,11 @@
+/**
+ * Upload Module
+ *
+ * File upload utilities for QA360
+ */
+export { ChunkedUploader, createChunkedUploader, uploadFileInChunks } from './chunked-uploader.js';
+export type { ChunkUploadConfig, UploadProgress, ChunkUploadResult } from './chunked-uploader.js';
+export { PresignedUploader, createPresignedUploader, uploadWithPresignedUrl, S3PresignedUploader, AzurePresignedUploader, } from './presigned-uploader.js';
+export type { PresignedUrlConfig, PresignedUrlResponse, PresignedUploadResult } from './presigned-uploader.js';
+export { MimeValidator, createMimeValidator, validateMimeType, getMimeTypeFromExtension, getExtensionFromMimeType, } from './mime-validator.js';
+export type { MimeTypeConfig, MimeTypeValidationResult } from './mime-validator.js';

package/dist/core/upload/index.js

@@ -0,0 +1,8 @@
+/**
+ * Upload Module
+ *
+ * File upload utilities for QA360
+ */
+export { ChunkedUploader, createChunkedUploader, uploadFileInChunks } from './chunked-uploader.js';
+export { PresignedUploader, createPresignedUploader, uploadWithPresignedUrl, S3PresignedUploader, AzurePresignedUploader, } from './presigned-uploader.js';
+export { MimeValidator, createMimeValidator, validateMimeType, getMimeTypeFromExtension, getExtensionFromMimeType, } from './mime-validator.js';

package/dist/core/upload/mime-validator.d.ts

@@ -0,0 +1,119 @@
+/**
+ * MIME Type Validator
+ *
+ * Validates file types using:
+ * - File extension (quick check)
+ * - Magic bytes (file signature)
+ * - Server-side MIME type validation
+ *
+ * Supports comprehensive file type detection for:
+ * - Images: JPEG, PNG, GIF, WebP, SVG, ICO, AVIF, HEIC
+ * - Documents: PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX
+ * - Audio: MP3, WAV, OGG, FLAC, M4A
+ * - Video: MP4, WEBM, AVI, MOV, MKV
+ * - Archives: ZIP, RAR, 7Z, TAR, GZIP
+ * - And more...
+ */
+export interface MimeTypeConfig {
+    /** Allowed MIME types */
+    allowedTypes?: string[];
+    /** Allowed file extensions */
+    allowedExtensions?: string[];
+    /** Maximum file size in bytes */
+    maxSize?: number;
+    /** Use magic bytes validation (default: true) */
+    useMagicBytes?: boolean;
+    /** Custom MIME type mappings */
+    customMappings?: Record<string, string>;
+}
+export interface MimeTypeValidationResult {
+    /** Validation success */
+    valid: boolean;
+    /** Detected MIME type */
+    mimeType?: string;
+    /** Detected extension */
+    extension?: string;
+    /** File size in bytes */
+    size?: number;
+    /** Validation errors */
+    errors?: string[];
+    /** Warnings (non-blocking) */
+    warnings?: string[];
+}
+/**
+ * MIME type validator class
+ */
+export declare class MimeValidator {
+    private config;
+    private customMappings;
+    constructor(config?: MimeTypeConfig);
+    /**
+     * Validate a file
+     */
+    validate(file: File | Blob): Promise<MimeTypeValidationResult>;
+    /**
+     * Detect MIME type using magic bytes
+     */
+    detectMimeType(file: File | Blob): Promise<string | undefined>;
+    /**
+     * Detect MIME type from magic bytes (file signature)
+     */
+    private detectFromMagicBytes;
+    /**
+     * Check if bytes match signature at offset
+     */
+    private matchesMagicBytes;
+    /**
+     * Check if MIME type is allowed
+     */
+    isAllowedType(mimeType: string): boolean;
+    /**
+     * Check if extension is allowed
+     */
+    isAllowedExtension(extension: string): boolean;
+    /**
+     * Check if a string is a valid MIME type
+     */
+    isValidMimeType(mimeType: string): boolean;
+    /**
+     * Get file extension from filename
+     */
+    getExtension(fileName: string): string;
+    /**
+     * Get MIME type from extension
+     */
+    getMimeTypeFromExtension(extension: string): string | undefined;
+    /**
+     * Get extension from MIME type
+     */
+    getExtensionFromMimeType(mimeType: string): string | undefined;
+    /**
+     * Update allowed types
+     */
+    setAllowedTypes(types: string[]): void;
+    /**
+     * Update allowed extensions
+     */
+    setAllowedExtensions(extensions: string[]): void;
+    /**
+     * Update max size
+     */
+    setMaxSize(size: number): void;
+}
+/**
+ * Create a MIME validator instance
+ */
+export declare function createMimeValidator(config?: MimeTypeConfig): MimeValidator;
+/**
+ * Validate a file (convenience function)
+ */
+export declare function validateMimeType(file: File | Blob, config?: MimeTypeConfig): Promise<MimeTypeValidationResult>;
+/**
+ * Get MIME type from extension
+ */
+export declare function getMimeTypeFromExtension(extension: string): string | undefined;
+/**
+ * Get extension from MIME type
+ */
+export declare function getExtensionFromMimeType(mimeType: string): string | undefined;
+export default MimeValidator;