@azure/playwright 1.1.2 → 1.1.3-alpha.20260310.1

package/dist/commonjs/utils/playwrightReporterStorageManager.js

@@ -1,115 +1,142 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlaywrightReporterStorageManager = void 0;
-const storage_blob_1 = require("@azure/storage-blob");
-const logger_js_1 = require("../common/logger.js");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const constants_js_1 = require("../common/constants.js");
-const messages_js_1 = require("../common/messages.js");
-const utils_js_1 = require("./utils.js");
-const playwrightServiceConfig_js_1 = require("../common/playwrightServiceConfig.js");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var playwrightReporterStorageManager_exports = {};
+__export(playwrightReporterStorageManager_exports, {
+  PlaywrightReporterStorageManager: () => PlaywrightReporterStorageManager
+});
+module.exports = __toCommonJS(playwrightReporterStorageManager_exports);
+var import_storage_blob = require("@azure/storage-blob");
+var import_logger = require("../common/logger.js");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_constants = require("../common/constants.js");
+var import_messages = require("../common/messages.js");
+var import_utils = require("./utils.js");
+var import_playwrightServiceConfig = require("../common/playwrightServiceConfig.js");
 class PlaywrightReporterStorageManager {
-    // Uploads the HTML report folder to Azure Storage
-    async uploadHtmlReportFolder(credential, runId, outputFolder, workspaceDetails) {
-        logger_js_1.coreLogger.info(`Starting HTML report upload for runId: ${runId}, outputFolder: ${outputFolder}`);
-        const storageAccountName = (0, utils_js_1.getStorageAccountNameFromUri)(workspaceDetails?.storageUri || "") || "unknown";
-        try {
-            if (!workspaceDetails.storageUri) {
-                logger_js_1.coreLogger.error("Storage URI not found in workspace details");
-                return {
-                    success: false,
-                    errorMessage: messages_js_1.ServiceErrorMessageConstants.STORAGE_URI_NOT_FOUND.message,
-                };
-            }
-            const blobServiceClient = new storage_blob_1.BlobServiceClient(workspaceDetails?.storageUri, credential);
-            logger_js_1.coreLogger.info("blobServiceClient created successfully.");
-            const serviceUrlInfo = (0, utils_js_1.populateValuesFromServiceUrl)();
-            if (!serviceUrlInfo?.accountId) {
-                logger_js_1.coreLogger.error("Unable to extract workspace ID from service URL");
-                return {
-                    success: false,
-                    errorMessage: messages_js_1.ServiceErrorMessageConstants.UNABLE_TO_EXTRACT_WORKSPACE_ID.message,
-                };
-            }
-            const containerName = serviceUrlInfo.accountId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
-            const containerClient = blobServiceClient.getContainerClient(containerName);
-            const containerExists = await containerClient.exists();
-            if (!containerExists) {
-                logger_js_1.coreLogger.info(`Container ${containerName} does not exist. Creating new container.`);
-                await containerClient.create();
-            }
-            else {
-                logger_js_1.coreLogger.info(`Container ${containerName} already exists.`);
-            }
-            const folderName = runId;
-            console.log(messages_js_1.ServiceErrorMessageConstants.UPLOADING_ARTIFACTS.formatWithDetails(storageAccountName, containerName, folderName));
-            await this.modifyTraceIndexHtml(outputFolder);
-            const uploadResults = await this.uploadFolderInParallel(containerClient, outputFolder, outputFolder, folderName);
-            if (uploadResults.totalFiles === 0) {
-                return { success: false, errorMessage: "No files found to upload" };
-            }
-            const failedFiles = uploadResults.totalFiles - uploadResults.uploadedFiles.length;
-            if (failedFiles > 0) {
-                if (uploadResults.failedFileDetails) {
-                    const hasAuthorizationError = uploadResults.failedFileDetails.some((fileDetail) => fileDetail.error.includes("not authorized to perform this operation") ||
-                        fileDetail.error.includes("AuthorizationFailure"));
-                    if (hasAuthorizationError) {
-                        return {
-                            success: false,
-                            errorMessage: messages_js_1.ServiceErrorMessageConstants.STORAGE_AUTHORIZATION_FAILED.formatWithStorageAccount(storageAccountName),
-                        };
-                    }
-                }
-                // Get list of failed file names by comparing total files with uploaded files
-                const uploadedSet = new Set(uploadResults.uploadedFiles);
-                const allFiles = (0, utils_js_1.collectAllFiles)(outputFolder, outputFolder, folderName);
-                const failedFileNames = allFiles
-                    .filter((file) => !uploadedSet.has(file.relativePath))
-                    .map((file) => file.relativePath);
-                return {
-                    success: false,
-                    partialSuccess: true,
-                    failedFileCount: failedFiles,
-                    totalFiles: uploadResults.totalFiles,
-                    failedFiles: failedFileNames,
-                    failedFileDetails: uploadResults.failedFileDetails,
-                };
-            }
-            return { success: true };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const hasStorageAccountDeletedError = errorMessage.includes("ENOTFOUND") ||
-                errorMessage.includes("getaddrinfo") ||
-                errorMessage.includes("not found") ||
-                errorMessage.includes("404");
-            if (hasStorageAccountDeletedError) {
-                return {
-                    success: false,
-                    errorMessage: messages_js_1.ServiceErrorMessageConstants.STORAGE_ACCOUNT_DELETED.formatWithStorageAccount(storageAccountName),
-                };
-            }
-            logger_js_1.coreLogger.error(`Failed to upload HTML report: ${error}`);
-            return { success: false, errorMessage };
+  // Uploads the HTML report folder to Azure Storage
+  async uploadHtmlReportFolder(credential, runId, outputFolder, workspaceDetails) {
+    import_logger.coreLogger.info(
+      `Starting HTML report upload for runId: ${runId}, outputFolder: ${outputFolder}`
+    );
+    const storageAccountName = (0, import_utils.getStorageAccountNameFromUri)(workspaceDetails?.storageUri || "") || "unknown";
+    try {
+      if (!workspaceDetails.storageUri) {
+        import_logger.coreLogger.error("Storage URI not found in workspace details");
+        return {
+          success: false,
+          errorMessage: import_messages.ServiceErrorMessageConstants.STORAGE_URI_NOT_FOUND.message
+        };
+      }
+      const blobServiceClient = new import_storage_blob.BlobServiceClient(workspaceDetails?.storageUri, credential);
+      import_logger.coreLogger.info("blobServiceClient created successfully.");
+      const serviceUrlInfo = (0, import_utils.populateValuesFromServiceUrl)();
+      if (!serviceUrlInfo?.accountId) {
+        import_logger.coreLogger.error("Unable to extract workspace ID from service URL");
+        return {
+          success: false,
+          errorMessage: import_messages.ServiceErrorMessageConstants.UNABLE_TO_EXTRACT_WORKSPACE_ID.message
+        };
+      }
+      const containerName = serviceUrlInfo.accountId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+      const containerClient = blobServiceClient.getContainerClient(containerName);
+      const containerExists = await containerClient.exists();
+      if (!containerExists) {
+        import_logger.coreLogger.info(`Container ${containerName} does not exist. Creating new container.`);
+        await containerClient.create();
+      } else {
+        import_logger.coreLogger.info(`Container ${containerName} already exists.`);
+      }
+      const folderName = runId;
+      console.log(
+        import_messages.ServiceErrorMessageConstants.UPLOADING_ARTIFACTS.formatWithDetails(
+          storageAccountName,
+          containerName,
+          folderName
+        )
+      );
+      await this.modifyTraceIndexHtml(outputFolder);
+      const uploadResults = await this.uploadFolderInParallel(
+        containerClient,
+        outputFolder,
+        outputFolder,
+        folderName
+      );
+      if (uploadResults.totalFiles === 0) {
+        return { success: false, errorMessage: "No files found to upload" };
+      }
+      const failedFiles = uploadResults.totalFiles - uploadResults.uploadedFiles.length;
+      if (failedFiles > 0) {
+        if (uploadResults.failedFileDetails) {
+          const hasAuthorizationError = uploadResults.failedFileDetails.some(
+            (fileDetail) => fileDetail.error.includes("not authorized to perform this operation") || fileDetail.error.includes("AuthorizationFailure")
+          );
+          if (hasAuthorizationError) {
+            return {
+              success: false,
+              errorMessage: import_messages.ServiceErrorMessageConstants.STORAGE_AUTHORIZATION_FAILED.formatWithStorageAccount(
+                storageAccountName
+              )
+            };
+          }
         }
+        const uploadedSet = new Set(uploadResults.uploadedFiles);
+        const allFiles = (0, import_utils.collectAllFiles)(outputFolder, outputFolder, folderName);
+        const failedFileNames = allFiles.filter((file) => !uploadedSet.has(file.relativePath)).map((file) => file.relativePath);
+        return {
+          success: false,
+          partialSuccess: true,
+          failedFileCount: failedFiles,
+          totalFiles: uploadResults.totalFiles,
+          failedFiles: failedFileNames,
+          failedFileDetails: uploadResults.failedFileDetails
+        };
+      }
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const hasStorageAccountDeletedError = errorMessage.includes("ENOTFOUND") || errorMessage.includes("getaddrinfo") || errorMessage.includes("not found") || errorMessage.includes("404");
+      if (hasStorageAccountDeletedError) {
+        return {
+          success: false,
+          errorMessage: import_messages.ServiceErrorMessageConstants.STORAGE_ACCOUNT_DELETED.formatWithStorageAccount(
+            storageAccountName
+          )
+        };
+      }
+      import_logger.coreLogger.error(`Failed to upload HTML report: ${error}`);
+      return { success: false, errorMessage };
     }
-    async modifyTraceIndexHtml(outputFolder) {
-        logger_js_1.coreLogger.info(`Starting trace modification for folder: ${outputFolder}`);
-        const indexPath = (0, path_1.join)(outputFolder, "trace/index.html");
-        const localIndexPath = (0, path_1.join)(outputFolder, "trace/index.local.html");
-        if (!(0, fs_1.existsSync)(indexPath)) {
-            logger_js_1.coreLogger.error(`trace/index.html not found at path: ${indexPath}`);
-            return;
-        }
-        logger_js_1.coreLogger.info(`Found trace/index.html at: ${indexPath}`);
-        try {
-            const originalHtml = (0, fs_1.readFileSync)(indexPath, "utf-8");
-            (0, fs_1.writeFileSync)(localIndexPath, originalHtml, "utf-8");
-            logger_js_1.coreLogger.info(`Backed up original trace viewer to: ${localIndexPath}`);
-            const redirectTraceviewerScript = `<!DOCTYPE html>
+  }
+  async modifyTraceIndexHtml(outputFolder) {
+    import_logger.coreLogger.info(`Starting trace modification for folder: ${outputFolder}`);
+    const indexPath = (0, import_path.join)(outputFolder, "trace/index.html");
+    const localIndexPath = (0, import_path.join)(outputFolder, "trace/index.local.html");
+    if (!(0, import_fs.existsSync)(indexPath)) {
+      import_logger.coreLogger.error(`trace/index.html not found at path: ${indexPath}`);
+      return;
+    }
+    import_logger.coreLogger.info(`Found trace/index.html at: ${indexPath}`);
+    try {
+      const originalHtml = (0, import_fs.readFileSync)(indexPath, "utf-8");
+      (0, import_fs.writeFileSync)(localIndexPath, originalHtml, "utf-8");
+      import_logger.coreLogger.info(`Backed up original trace viewer to: ${localIndexPath}`);
+      const redirectTraceviewerScript = `<!DOCTYPE html>
 <html>
 <head>
   <meta charset="utf-8">
@@ -207,250 +234,262 @@ class PlaywrightReporterStorageManager {
 </body>
 </html>
 `;
-            (0, fs_1.writeFileSync)(indexPath, redirectTraceviewerScript, "utf-8");
-            logger_js_1.coreLogger.info("Successfully updated TraceViewer index file");
-        }
-        catch (error) {
-            logger_js_1.coreLogger.error(`Error modifying trace/index.html: ${error instanceof Error ? error.message : String(error)}`);
-            return;
-        }
+      (0, import_fs.writeFileSync)(indexPath, redirectTraceviewerScript, "utf-8");
+      import_logger.coreLogger.info("Successfully updated TraceViewer index file");
+    } catch (error) {
+      import_logger.coreLogger.error(
+        `Error modifying trace/index.html: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
     }
-    // Uploads the entire Playwright HTML report folder after tests complete.
-    async uploadPlaywrightHtmlReportAfterTests(outputFolderName, workspaceMetadata) {
-        try {
-            logger_js_1.coreLogger.info(`Starting post-test HTML report upload, folder name: ${outputFolderName || "default (playwright-report)"}`);
-            const cred = playwrightServiceConfig_js_1.PlaywrightServiceConfig.instance.credential;
-            if (!cred) {
-                logger_js_1.coreLogger.error("No credential found for authentication");
-                return {
-                    success: false,
-                    errorMessage: messages_js_1.ServiceErrorMessageConstants.NO_CRED_ENTRA_AUTH_ERROR.message,
-                };
-            }
-            logger_js_1.coreLogger.info("Credential found for authentication");
-            const folderName = outputFolderName || "playwright-report";
-            const outputFolderPath = (0, path_1.join)(process.cwd(), folderName);
-            if (!(0, fs_1.existsSync)(outputFolderPath)) {
-                logger_js_1.coreLogger.error(`HTML report folder not found: ${outputFolderPath}`);
-                return {
-                    success: false,
-                    errorMessage: messages_js_1.ServiceErrorMessageConstants.PLAYWRIGHT_TEST_REPORT_NOT_FOUND.formatWithFolder(folderName),
-                };
-            }
-            logger_js_1.coreLogger.info(`HTML report folder found: ${outputFolderPath}`);
-            const testRunId = playwrightServiceConfig_js_1.PlaywrightServiceConfig.instance.runId;
-            logger_js_1.coreLogger.info(`Starting upload for test run ID: ${testRunId}`);
-            const result = await this.uploadHtmlReportFolder(cred, testRunId, outputFolderPath, workspaceMetadata);
-            logger_js_1.coreLogger.info(`Completed upload for test run ID: ${testRunId}`);
-            return result;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger_js_1.coreLogger.error(`Upload failed: ${errorMessage}`);
-            return { success: false, errorMessage };
-        }
-    }
-    // Parallel Upload Engine - Core upload orchestration with performance optimization
-    async uploadFolderInParallel(containerClient, folderPath, basePath, runIdFolderPrefix) {
-        // Sort by size descending - upload large files first for better parallelization
-        const filesToUpload = (0, utils_js_1.collectAllFiles)(folderPath, basePath, runIdFolderPrefix).sort((a, b) => b.size - a.size);
-        if (filesToUpload.length === 0) {
-            return { uploadedFiles: [], failedFiles: [], totalFiles: 0, totalSize: 0, uploadTime: 0 };
-        }
-        const totalSize = filesToUpload.reduce((sum, file) => sum + file.size, 0);
-        const concurrency = (0, utils_js_1.calculateOptimalConcurrency)(filesToUpload);
-        logger_js_1.coreLogger.info(`Calculated optimal concurrency: ${concurrency} for ${filesToUpload.length} files (total size: ${(totalSize / 1024 / 1024).toFixed(2)} MB)`);
-        const uploadStartTime = Date.now();
-        logger_js_1.coreLogger.info(`Starting parallel upload with ${concurrency} concurrent operations`);
-        const results = await this.uploadWithConcurrencyControl(containerClient, filesToUpload, concurrency);
-        const uploadEndTime = Date.now();
-        const uploadTime = uploadEndTime - uploadStartTime;
-        logger_js_1.coreLogger.info(`Upload completed in ${uploadTime}ms (${(uploadTime / 1000).toFixed(2)}s)`);
-        const failed = results.filter((r) => r.status === "rejected").length;
-        const successful = results.filter((r) => r.status === "fulfilled").length;
-        logger_js_1.coreLogger.info(`Upload results: ${successful} successful, ${failed} failed out of ${results.length} total files`);
-        if (failed > 0) {
-            const errors = results
-                .filter((r) => r.status === "rejected")
-                .map((r) => r.reason.message)
-                .slice(0, 5); // Show first 5 errors
-            errors.forEach((error, index) => {
-                logger_js_1.coreLogger.error(`   ${index + 1}. ${error}`);
-            });
-            // Get failed file names and their error messages
-            const uploadedSet = new Set(results
-                .filter((r) => r.status === "fulfilled")
-                .map((r) => r.value));
-            const failedFileNames = filesToUpload
-                .filter((file) => !uploadedSet.has(file.relativePath))
-                .map((file) => file.relativePath);
-            // Create detailed error mapping
-            const failedFileDetails = [];
-            results.forEach((result, index) => {
-                if (result.status === "rejected") {
-                    const fileName = filesToUpload[index]?.relativePath || `File at index ${index}`;
-                    const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason);
-                    failedFileDetails.push({ fileName, error: errorMessage });
-                }
-            });
-            // Log error but don't throw to prevent breaking HTML reporter
-            logger_js_1.coreLogger.error(`Upload failed: ${failed} files could not be uploaded. Sample errors: ${errors.join(", ")}`);
-            return {
-                uploadedFiles: results
-                    .filter((r) => r.status === "fulfilled")
-                    .map((r) => r.value),
-                failedFiles: failedFileNames,
-                failedFileDetails,
-                totalFiles: filesToUpload.length,
-                totalSize,
-                uploadTime,
-            };
-        }
-        const uploadedFiles = results
-            .filter((r) => r.status === "fulfilled")
-            .map((r) => r.value);
+  }
+  // Uploads the entire Playwright HTML report folder after tests complete.
+  async uploadPlaywrightHtmlReportAfterTests(outputFolderName, workspaceMetadata) {
+    try {
+      import_logger.coreLogger.info(
+        `Starting post-test HTML report upload, folder name: ${outputFolderName || "default (playwright-report)"}`
+      );
+      const cred = import_playwrightServiceConfig.PlaywrightServiceConfig.instance.credential;
+      if (!cred) {
+        import_logger.coreLogger.error("No credential found for authentication");
+        return {
+          success: false,
+          errorMessage: import_messages.ServiceErrorMessageConstants.NO_CRED_ENTRA_AUTH_ERROR.message
+        };
+      }
+      import_logger.coreLogger.info("Credential found for authentication");
+      const folderName = outputFolderName || "playwright-report";
+      const outputFolderPath = (0, import_path.join)(process.cwd(), folderName);
+      if (!(0, import_fs.existsSync)(outputFolderPath)) {
+        import_logger.coreLogger.error(`HTML report folder not found: ${outputFolderPath}`);
         return {
-            uploadedFiles,
-            failedFiles: [],
-            totalFiles: filesToUpload.length,
-            totalSize,
-            uploadTime,
+          success: false,
+          errorMessage: import_messages.ServiceErrorMessageConstants.PLAYWRIGHT_TEST_REPORT_NOT_FOUND.formatWithFolder(
+            folderName
+          )
         };
+      }
+      import_logger.coreLogger.info(`HTML report folder found: ${outputFolderPath}`);
+      const testRunId = import_playwrightServiceConfig.PlaywrightServiceConfig.instance.runId;
+      import_logger.coreLogger.info(`Starting upload for test run ID: ${testRunId}`);
+      const result = await this.uploadHtmlReportFolder(
+        cred,
+        testRunId,
+        outputFolderPath,
+        workspaceMetadata
+      );
+      import_logger.coreLogger.info(`Completed upload for test run ID: ${testRunId}`);
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      import_logger.coreLogger.error(`Upload failed: ${errorMessage}`);
+      return { success: false, errorMessage };
     }
-    // Concurrency Control System - Manages parallel execution with controlled resource usage
-    async uploadWithConcurrencyControl(containerClient, files, concurrency) {
-        const uploadTasks = files.map((fileInfo) => async () => {
-            try {
-                await this.uploadSingleFileOptimized(containerClient, fileInfo);
-                return fileInfo.relativePath;
-            }
-            catch (error) {
-                logger_js_1.coreLogger.error(`Failed to upload file: ${fileInfo.relativePath} - ${error instanceof Error ? error.message : "Unknown error"}`);
-                throw error;
-            }
-        });
-        return this.executeWithOptimizedBatching(uploadTasks, concurrency);
+  }
+  // Parallel Upload Engine - Core upload orchestration with performance optimization
+  async uploadFolderInParallel(containerClient, folderPath, basePath, runIdFolderPrefix) {
+    const filesToUpload = (0, import_utils.collectAllFiles)(folderPath, basePath, runIdFolderPrefix).sort(
+      (a, b) => b.size - a.size
+    );
+    if (filesToUpload.length === 0) {
+      return { uploadedFiles: [], failedFiles: [], totalFiles: 0, totalSize: 0, uploadTime: 0 };
     }
-    // Optimized Batch Execution Engine - High-performance task processing system
-    async executeWithOptimizedBatching(tasks, concurrency) {
-        const results = new Array(tasks.length);
-        let completedTasks = 0;
-        // Splits tasks into optimal batches to balance memory usage vs. throughput
-        const batchSize = Math.min(constants_js_1.UploadConstants.BATCH_SIZE, concurrency * 2);
-        const batches = [];
-        // Each batch will be processed with full concurrency before moving to next batch
-        for (let i = 0; i < tasks.length; i += batchSize) {
-            batches.push(tasks.slice(i, i + batchSize));
-        }
-        // Process each batch sequentially to maintain memory efficiency
-        logger_js_1.coreLogger.info(`Processing ${batches.length} batches with ${batchSize} tasks per batch`);
-        for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
-            const batch = batches[batchIndex];
-            const batchStartIndex = batchIndex * batchSize;
-            logger_js_1.coreLogger.info(`Starting batch ${batchIndex + 1}/${batches.length} with ${batch.length} tasks`);
-            // Transform each task into a promise that captures results at correct index
-            const batchPromises = batch.map(async (task, taskIndex) => {
-                const globalIndex = batchStartIndex + taskIndex;
-                try {
-                    const result = await task();
-                    results[globalIndex] = { status: "fulfilled", value: result };
-                    return result;
-                }
-                catch (error) {
-                    results[globalIndex] = { status: "rejected", reason: error };
-                    logger_js_1.coreLogger.error(`Task failed at index ${globalIndex}: ${error instanceof Error ? error.message : "Unknown error"}`);
-                    return;
-                }
-            });
-            const executing = [];
-            for (const promise of batchPromises) {
-                if (executing.length >= concurrency) {
-                    await Promise.race(executing);
-                }
-                const wrappedPromise = promise
-                    .then((result) => {
-                    completedTasks++;
-                    return result;
-                })
-                    .catch(() => {
-                    completedTasks++;
-                })
-                    .finally(() => {
-                    // Cleanup: remove completed promise from executing array
-                    const index = executing.indexOf(wrappedPromise);
-                    if (index > -1)
-                        executing.splice(index, 1);
-                });
-                executing.push(wrappedPromise);
-            }
-            // Wait for all promises in current batch to complete before moving to next batch
-            await Promise.allSettled(executing);
-            logger_js_1.coreLogger.info(`Completed batch ${batchIndex + 1}/${batches.length}`);
+    const totalSize = filesToUpload.reduce((sum, file) => sum + file.size, 0);
+    const concurrency = (0, import_utils.calculateOptimalConcurrency)(filesToUpload);
+    import_logger.coreLogger.info(
+      `Calculated optimal concurrency: ${concurrency} for ${filesToUpload.length} files (total size: ${(totalSize / 1024 / 1024).toFixed(2)} MB)`
+    );
+    const uploadStartTime = Date.now();
+    import_logger.coreLogger.info(`Starting parallel upload with ${concurrency} concurrent operations`);
+    const results = await this.uploadWithConcurrencyControl(
+      containerClient,
+      filesToUpload,
+      concurrency
+    );
+    const uploadEndTime = Date.now();
+    const uploadTime = uploadEndTime - uploadStartTime;
+    import_logger.coreLogger.info(`Upload completed in ${uploadTime}ms (${(uploadTime / 1e3).toFixed(2)}s)`);
+    const failed = results.filter((r) => r.status === "rejected").length;
+    const successful = results.filter((r) => r.status === "fulfilled").length;
+    import_logger.coreLogger.info(
+      `Upload results: ${successful} successful, ${failed} failed out of ${results.length} total files`
+    );
+    if (failed > 0) {
+      const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason.message).slice(0, 5);
+      errors.forEach((error, index) => {
+        import_logger.coreLogger.error(`   ${index + 1}. ${error}`);
+      });
+      const uploadedSet = new Set(
+        results.filter((r) => r.status === "fulfilled").map((r) => r.value)
+      );
+      const failedFileNames = filesToUpload.filter((file) => !uploadedSet.has(file.relativePath)).map((file) => file.relativePath);
+      const failedFileDetails = [];
+      results.forEach((result, index) => {
+        if (result.status === "rejected") {
+          const fileName = filesToUpload[index]?.relativePath || `File at index ${index}`;
+          const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason);
+          failedFileDetails.push({ fileName, error: errorMessage });
         }
-        return results;
+      });
+      import_logger.coreLogger.error(
+        `Upload failed: ${failed} files could not be uploaded. Sample errors: ${errors.join(", ")}`
+      );
+      return {
+        uploadedFiles: results.filter((r) => r.status === "fulfilled").map((r) => r.value),
+        failedFiles: failedFileNames,
+        failedFileDetails,
+        totalFiles: filesToUpload.length,
+        totalSize,
+        uploadTime
+      };
+    }
+    const uploadedFiles = results.filter((r) => r.status === "fulfilled").map((r) => r.value);
+    return {
+      uploadedFiles,
+      failedFiles: [],
+      totalFiles: filesToUpload.length,
+      totalSize,
+      uploadTime
+    };
+  }
+  // Concurrency Control System - Manages parallel execution with controlled resource usage
+  async uploadWithConcurrencyControl(containerClient, files, concurrency) {
+    const uploadTasks = files.map((fileInfo) => async () => {
+      try {
+        await this.uploadSingleFileOptimized(containerClient, fileInfo);
+        return fileInfo.relativePath;
+      } catch (error) {
+        import_logger.coreLogger.error(
+          `Failed to upload file: ${fileInfo.relativePath} - ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+        throw error;
+      }
+    });
+    return this.executeWithOptimizedBatching(uploadTasks, concurrency);
+  }
+  // Optimized Batch Execution Engine - High-performance task processing system
+  async executeWithOptimizedBatching(tasks, concurrency) {
+    const results = new Array(tasks.length);
+    let completedTasks = 0;
+    const batchSize = Math.min(import_constants.UploadConstants.BATCH_SIZE, concurrency * 2);
+    const batches = [];
+    for (let i = 0; i < tasks.length; i += batchSize) {
+      batches.push(tasks.slice(i, i + batchSize));
     }
-    // Individual File Upload with Retry Logic
-    async uploadSingleFileOptimized(containerClient, fileInfo) {
-        logger_js_1.coreLogger.info(`Uploading file: ${fileInfo.relativePath} (${(fileInfo.size / 1024).toFixed(2)} KB, ${fileInfo.contentType})`);
-        const blockBlobClient = containerClient.getBlockBlobClient(fileInfo.relativePath);
-        const maxRetries = constants_js_1.UploadConstants.MAX_RETRY_ATTEMPTS;
-        const baseDelay = constants_js_1.UploadConstants.RETRY_BASE_DELAY;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                await this.performOptimizedUpload(blockBlobClient, fileInfo);
-                return;
-            }
-            catch (error) {
-                const isLastAttempt = attempt === maxRetries;
-                const errorMessage = error instanceof Error ? error.message : "Unknown error";
-                logger_js_1.coreLogger.info(`Upload attempt ${attempt} failed for ${fileInfo.relativePath}: ${errorMessage}`);
-                if (isLastAttempt) {
-                    logger_js_1.coreLogger.error(`All retry attempts exhausted for ${fileInfo.relativePath}: ${errorMessage}`);
-                    if (error instanceof Error) {
-                        throw error;
-                    }
-                    throw new Error(`Upload failed for ${fileInfo.relativePath} after ${maxRetries} attempts: ${errorMessage}`);
-                }
-                // Exponential backoff with jitter (Azure SDK pattern)
-                const delay = baseDelay * Math.pow(2, attempt - 1) + Math.random() * 500;
-                logger_js_1.coreLogger.info(`Retrying upload for ${fileInfo.relativePath} in ${delay.toFixed(0)}ms (attempt ${attempt + 1}/${maxRetries})`);
-                await new Promise((_resolve) => setTimeout(_resolve, delay));
-            }
+    import_logger.coreLogger.info(`Processing ${batches.length} batches with ${batchSize} tasks per batch`);
+    for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
+      const batch = batches[batchIndex];
+      const batchStartIndex = batchIndex * batchSize;
+      import_logger.coreLogger.info(
+        `Starting batch ${batchIndex + 1}/${batches.length} with ${batch.length} tasks`
+      );
+      const batchPromises = batch.map(async (task, taskIndex) => {
+        const globalIndex = batchStartIndex + taskIndex;
+        try {
+          const result = await task();
+          results[globalIndex] = { status: "fulfilled", value: result };
+          return result;
+        } catch (error) {
+          results[globalIndex] = { status: "rejected", reason: error };
+          import_logger.coreLogger.error(
+            `Task failed at index ${globalIndex}: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+          return;
+        }
+      });
+      const executing = [];
+      for (const promise of batchPromises) {
+        if (executing.length >= concurrency) {
+          await Promise.race(executing);
         }
+        const wrappedPromise = promise.then((result) => {
+          completedTasks++;
+          return result;
+        }).catch(() => {
+          completedTasks++;
+        }).finally(() => {
+          const index = executing.indexOf(wrappedPromise);
+          if (index > -1) executing.splice(index, 1);
+        });
+        executing.push(wrappedPromise);
+      }
+      await Promise.allSettled(executing);
+      import_logger.coreLogger.info(`Completed batch ${batchIndex + 1}/${batches.length}`);
     }
-    // Multi-Strategy Upload Engine - Optimized upload based on file characteristics
-    async performOptimizedUpload(blockBlobClient, fileInfo) {
-        if (fileInfo.size <= constants_js_1.UploadConstants.SMALL_FILE_THRESHOLD) {
-            // DIRECT UPLOAD: Optimal for small files (≤1MB)
-            const fileContent = (0, fs_1.readFileSync)(fileInfo.fullPath);
-            await blockBlobClient.upload(fileContent, fileContent.length, {
-                blobHTTPHeaders: {
-                    blobContentType: fileInfo.contentType,
-                },
-            });
+    return results;
+  }
+  // Individual File Upload with Retry Logic
+  async uploadSingleFileOptimized(containerClient, fileInfo) {
+    import_logger.coreLogger.info(
+      `Uploading file: ${fileInfo.relativePath} (${(fileInfo.size / 1024).toFixed(2)} KB, ${fileInfo.contentType})`
+    );
+    const blockBlobClient = containerClient.getBlockBlobClient(fileInfo.relativePath);
+    const maxRetries = import_constants.UploadConstants.MAX_RETRY_ATTEMPTS;
+    const baseDelay = import_constants.UploadConstants.RETRY_BASE_DELAY;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        await this.performOptimizedUpload(blockBlobClient, fileInfo);
+        return;
+      } catch (error) {
+        const isLastAttempt = attempt === maxRetries;
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        import_logger.coreLogger.info(
+          `Upload attempt ${attempt} failed for ${fileInfo.relativePath}: ${errorMessage}`
+        );
+        if (isLastAttempt) {
+          import_logger.coreLogger.error(
+            `All retry attempts exhausted for ${fileInfo.relativePath}: ${errorMessage}`
+          );
+          if (error instanceof Error) {
+            throw error;
+          }
+          throw new Error(
+            `Upload failed for ${fileInfo.relativePath} after ${maxRetries} attempts: ${errorMessage}`
+          );
         }
-        else if (fileInfo.size <= constants_js_1.UploadConstants.LARGE_FILE_THRESHOLD) {
-            // BLOCK UPLOAD: Optimal for medium files (1MB - 100MB)
-            const fileContent = (0, fs_1.readFileSync)(fileInfo.fullPath);
-            await blockBlobClient.uploadData(fileContent, {
-                blobHTTPHeaders: {
-                    blobContentType: fileInfo.contentType,
-                },
-                blockSize: constants_js_1.UploadConstants.OPTIMIZED_BLOCK_SIZE,
-                concurrency: constants_js_1.UploadConstants.PER_FILE_CONCURRENCY,
-            });
+        const delay = baseDelay * Math.pow(2, attempt - 1) + Math.random() * 500;
+        import_logger.coreLogger.info(
+          `Retrying upload for ${fileInfo.relativePath} in ${delay.toFixed(0)}ms (attempt ${attempt + 1}/${maxRetries})`
+        );
+        await new Promise((_resolve) => setTimeout(_resolve, delay));
+      }
+    }
+  }
+  // Multi-Strategy Upload Engine - Optimized upload based on file characteristics
+  async performOptimizedUpload(blockBlobClient, fileInfo) {
+    if (fileInfo.size <= import_constants.UploadConstants.SMALL_FILE_THRESHOLD) {
+      const fileContent = (0, import_fs.readFileSync)(fileInfo.fullPath);
+      await blockBlobClient.upload(fileContent, fileContent.length, {
+        blobHTTPHeaders: {
+          blobContentType: fileInfo.contentType
         }
-        else {
-            // STREAMING UPLOAD: Optimal for large files (>100MB)
-            const stream = (0, fs_1.createReadStream)(fileInfo.fullPath);
-            await blockBlobClient.uploadStream(stream, constants_js_1.UploadConstants.STREAM_BUFFER_SIZE, constants_js_1.UploadConstants.LARGE_FILE_CONCURRENCY, {
-                blobHTTPHeaders: {
-                    blobContentType: fileInfo.contentType,
-                },
-            });
+      });
+    } else if (fileInfo.size <= import_constants.UploadConstants.LARGE_FILE_THRESHOLD) {
+      const fileContent = (0, import_fs.readFileSync)(fileInfo.fullPath);
+      await blockBlobClient.uploadData(fileContent, {
+        blobHTTPHeaders: {
+          blobContentType: fileInfo.contentType
+        },
+        blockSize: import_constants.UploadConstants.OPTIMIZED_BLOCK_SIZE,
+        concurrency: import_constants.UploadConstants.PER_FILE_CONCURRENCY
+      });
+    } else {
+      const stream = (0, import_fs.createReadStream)(fileInfo.fullPath);
+      await blockBlobClient.uploadStream(
+        stream,
+        import_constants.UploadConstants.STREAM_BUFFER_SIZE,
+        import_constants.UploadConstants.LARGE_FILE_CONCURRENCY,
+        {
+          blobHTTPHeaders: {
+            blobContentType: fileInfo.contentType
+          }
         }
-        logger_js_1.coreLogger.info(`Successfully uploaded: ${fileInfo.relativePath}`);
+      );
     }
+    import_logger.coreLogger.info(`Successfully uploaded: ${fileInfo.relativePath}`);
+  }
 }
-exports.PlaywrightReporterStorageManager = PlaywrightReporterStorageManager;
-//# sourceMappingURL=playwrightReporterStorageManager.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlaywrightReporterStorageManager
+});