@azure/playwright 1.1.3-alpha.20260310.1 → 1.1.3

package/dist/commonjs/utils/playwrightReporterStorageManager.js

@@ -1,142 +1,115 @@
-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");
+"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");
 class PlaywrightReporterStorageManager {
-  // 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
-              )
-            };
-          }
+    // 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 };
         }
-        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) {
-    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>
+    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>
 <html>
 <head>
   <meta charset="utf-8">
@@ -234,262 +207,250 @@ class PlaywrightReporterStorageManager {
 </body>
 </html>
 `;
-      (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 {
-      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 {
-          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 };
+            (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;
+        }
     }
-  }
-  // 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 };
+    // 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 };
+        }
     }
-    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 });
+    // 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,
+            };
         }
-      });
-      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,
+        };
     }
-    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));
+    // 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);
     }
-    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;
+    // 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));
         }
-      });
-      const executing = [];
-      for (const promise of batchPromises) {
-        if (executing.length >= concurrency) {
-          await Promise.race(executing);
+        // 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 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}`);
+        return results;
     }
-    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}`
-          );
+    // 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));
+            }
         }
-        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
+    // 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,
+                },
+            });
         }
-      });
-    } 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
-          }
+        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,
+            });
+        }
+        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,
+                },
+            });
         }
-      );
+        logger_js_1.coreLogger.info(`Successfully uploaded: ${fileInfo.relativePath}`);
     }
-    import_logger.coreLogger.info(`Successfully uploaded: ${fileInfo.relativePath}`);
-  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PlaywrightReporterStorageManager
-});
+exports.PlaywrightReporterStorageManager = PlaywrightReporterStorageManager;
+//# sourceMappingURL=playwrightReporterStorageManager.js.map