@mablhq/playwright-tools 2.49.1

package/util/TestOutputWriter.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalTestOutputWriter = void 0;
+const fs = __importStar(require("fs"));
+const CloudStorageWriter_1 = __importDefault(require("./CloudStorageWriter"));
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const crypto_1 = __importDefault(require("crypto"));
+const path_1 = __importDefault(require("path"));
+const EXECUTION_OUTPUT_PATH_PREFIX = 'execution-output';
+const MAX_PATH_LENGTH = 1024;
+class LocalTestOutputWriter {
+    constructor(outputDir) {
+        this.outputDir = outputDir;
+    }
+    write(name, _contentType, data) {
+        const localPath = `${this.outputDir}/${name}`;
+        this.maybeCreateDirectory(localPath);
+        fs.writeFileSync(localPath, data);
+        return Promise.resolve(localPath);
+    }
+    writeObjectAsJson(name, data, replacer, reviver) {
+        const localPath = `${this.outputDir}/${name}`;
+        this.maybeCreateDirectory(localPath);
+        if (replacer || reviver) {
+            data = JSON.parse(JSON.stringify(data, replacer), reviver);
+        }
+        fs.writeFileSync(localPath, JSON.stringify(data));
+        return Promise.resolve(localPath);
+    }
+    maybeCreateDirectory(localPath) {
+        const directory = path_1.default.dirname(localPath);
+        if (!fs.existsSync(directory)) {
+            fs.mkdirSync(directory, { recursive: true });
+        }
+    }
+}
+exports.LocalTestOutputWriter = LocalTestOutputWriter;
+class CloudOutputWriter {
+    constructor(projectId, workspaceId, applicationId, planId, planRunId, testRunId) {
+        this.storageWriter = new CloudStorageWriter_1.default(projectId, workspaceId);
+        this.applicationId = applicationId;
+        this.planId = planId;
+        this.planRunId = planRunId;
+        this.testRunId = testRunId;
+    }
+    async writeObjectAsJson(name, data, replacer, reviver) {
+        if (replacer || reviver) {
+            data = JSON.parse(JSON.stringify(data, replacer), reviver);
+        }
+        return this.write(name, 'application/json', Buffer.from(JSON.stringify(data)));
+    }
+    async write(name, contentType, data) {
+        const path = this.nameToFullPath(name);
+        await this.storageWriter.write(path, contentType, data);
+        return `${this.storageWriter.bucketName()}/${path}`;
+    }
+    randomPathComponent() {
+        return (crypto_1.default
+            .randomBytes(3)
+            .toString('base64url')
+            .replace(/-/g, 'm')
+            .replace(/_/g, 'a')
+            .toLowerCase());
+    }
+    nameToFullPath(name) {
+        const directoryPath = `${this.applicationId}/${this.planId}/${this.planRunId}/${this.testRunId}`;
+        const randomComponent = this.randomPathComponent();
+        const fullPath = `${EXECUTION_OUTPUT_PATH_PREFIX}/${randomComponent}/${directoryPath}/${name}`;
+        if (fullPath.length <= MAX_PATH_LENGTH) {
+            return fullPath;
+        }
+        loggingProvider_1.logger.info(`WARNING: Truncating path longer than ${MAX_PATH_LENGTH}: ${fullPath}`);
+        const overage = fullPath.length - MAX_PATH_LENGTH;
+        const truncatedName = name.substring(overage);
+        return `${EXECUTION_OUTPUT_PATH_PREFIX}/${randomComponent}/${directoryPath}/${truncatedName}`;
+    }
+}
+exports.default = CloudOutputWriter;

package/util/actionabilityUtil.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeAddPopupLogic = exports.attemptPopupDismissal = exports.checkActionabilityAt = exports.checkPopupDismissalOnAction = void 0;
+const fs = __importStar(require("fs"));
+const resourceUtil_1 = require("./resourceUtil");
+const messaging_1 = require("../core/messaging/messaging");
+const logUtils_1 = require("./logUtils");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const ACTIONABILITY_CHECK_SCRIPT_LOCATION = (0, resourceUtil_1.findResource)('actionabilityCheck.js');
+const EMBEDDED_POPUP_SCRIPT_LOCATION = (0, resourceUtil_1.findResource)('popupDismissal.js');
+const NO_CLICKABLE_POINT_ERROR = 'Unable to find a clickable point for the element';
+const POPUP_ERROR_MESSAGE_HINT = 'intercepts pointer events';
+let embeddedPopupScript;
+let embeddedActionabilityLogic;
+async function checkPopupDismissalOnAction(elementHandle, action, executionContext, recheckOnFail = true) {
+    try {
+        await action();
+    }
+    catch (error) {
+        if (error.message.includes(POPUP_ERROR_MESSAGE_HINT)) {
+            const hasPopup = await isElementWithPopup(elementHandle);
+            if (hasPopup) {
+                return true;
+            }
+            const dismissalResult = await attemptPopupDismissal(elementHandle, executionContext);
+            if (recheckOnFail) {
+                return checkPopupDismissalOnAction(elementHandle, action, executionContext, false);
+            }
+            if (!dismissalResult) {
+                (0, logUtils_1.logWebUIAndCliOutput)(`Found element may not be actionable`, loggingProvider_1.LogLevel.Warn, executionContext, {
+                    executionPhase: messaging_1.ExecutionPhase.DURING_ACTION,
+                });
+                (0, logUtils_1.logInternal)(`Found element might not be actionable. ${error.toString()}`);
+            }
+            return dismissalResult;
+        }
+    }
+    return true;
+}
+exports.checkPopupDismissalOnAction = checkPopupDismissalOnAction;
+async function checkActionabilityAt(elementHandle, executionContext, recheckOnFail = true) {
+    let point = await elementHandle.clickablePoint();
+    if (point === undefined) {
+        throw new Error(NO_CLICKABLE_POINT_ERROR);
+    }
+    const frame = await elementHandle.frame();
+    if (frame === null || frame === void 0 ? void 0 : frame.parentFrame()) {
+        const element = await frame.getFrameOwnerElement();
+        if (element !== undefined) {
+            const box = await element.boundingBox();
+            if (!box) {
+                throw new Error('Element not connected');
+            }
+            point = { x: point.x - box.x, y: point.y - box.y };
+        }
+    }
+    await maybeAddActionabilityLogic(elementHandle);
+    const result = await elementHandle.evaluate((node, point) => mablCheckActionability(node, point), { ...point });
+    if (result !== 'done') {
+        if (typeof result === 'object' && 'actionabilityDescription' in result) {
+            (0, logUtils_1.logInternal)(`${result.actionabilityDescription} intercepts pointer events. Trying to auto-dismiss popups.`);
+            const hasPopup = await isElementWithPopup(elementHandle);
+            if (hasPopup) {
+                return {
+                    result: 'done',
+                    clickablePoint: point,
+                };
+            }
+            await attemptPopupDismissal(elementHandle, executionContext);
+            if (recheckOnFail) {
+                return checkActionabilityAt(elementHandle, executionContext, false);
+            }
+            throw new Error(`Element not clickable at point.`);
+        }
+        throw new Error(`Element not at point. ${result}`);
+    }
+    return { result, clickablePoint: point };
+}
+exports.checkActionabilityAt = checkActionabilityAt;
+async function attemptPopupDismissal(element, executionContext) {
+    const frame = await element.frame();
+    if (frame === undefined) {
+        return false;
+    }
+    await maybeAddPopupLogic(element);
+    const { dismissedStatus, elementsInFront, error } = await element.evaluate((element) => globalThis.popupDismissal.detectAndDismissPopupCandidates(element));
+    if (error) {
+        (0, logUtils_1.logInternal)(`Error while trying to dismiss popups: ${error}`);
+    }
+    if (!dismissedStatus) {
+        if (elementsInFront) {
+            (0, logUtils_1.logInternal)('Failed to auto dismiss and there are still elements in front. Sending escape key to body.');
+            const bodyElement = await frame.$('BODY');
+            if (bodyElement) {
+                await bodyElement.press('Escape');
+            }
+            const elementsInFront = await element.evaluate((element) => globalThis.popupDismissal.elementsInFrontCount(element));
+            if (elementsInFront) {
+                (0, logUtils_1.logInternal)('The popup did not dismiss using the escape key.');
+                return false;
+            }
+        }
+        else {
+            (0, logUtils_1.logInternal)('Failed to auto dismiss. No elements found in front of target element.');
+            return false;
+        }
+    }
+    (0, logUtils_1.logWebUIAndCliOutput)(`A popup was detected and dismissed`, loggingProvider_1.LogLevel.Info, executionContext, {
+        executionPhase: messaging_1.ExecutionPhase.DURING_ACTION,
+    });
+    return true;
+}
+exports.attemptPopupDismissal = attemptPopupDismissal;
+async function maybeAddPopupLogic(element) {
+    const hasPopupDismissalLogic = await isPopupDismissalInTarget(element);
+    if (!hasPopupDismissalLogic) {
+        if (!embeddedPopupScript) {
+            embeddedPopupScript = fs.readFileSync(EMBEDDED_POPUP_SCRIPT_LOCATION, 'utf8');
+        }
+        await element.evaluate(embeddedPopupScript);
+    }
+}
+exports.maybeAddPopupLogic = maybeAddPopupLogic;
+async function maybeAddActionabilityLogic(element) {
+    const hasActionabilityCheckLogic = await isActionabilityLogicInTarget(element);
+    if (!hasActionabilityCheckLogic) {
+        if (!embeddedActionabilityLogic) {
+            embeddedActionabilityLogic = fs.readFileSync(ACTIONABILITY_CHECK_SCRIPT_LOCATION, 'utf8');
+        }
+        await element.evaluate(embeddedActionabilityLogic);
+    }
+}
+function isActionabilityLogicInTarget(element) {
+    return element.evaluate(() => !!globalThis.mablCheckActionability);
+}
+function isPopupDismissalInTarget(element) {
+    return element.evaluate(() => !!globalThis.popupDismissal);
+}
+function isElementWithPopup(element) {
+    return element.evaluate((element) => element.getAttribute('aria-expanded') === 'true' &&
+        element.getAttribute('aria-haspopup') === 'true');
+}

package/util/analytics-events.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalToolsEvents = void 0;
+var ExternalToolsEvents;
+(function (ExternalToolsEvents) {
+    ExternalToolsEvents["CreateMailboxAddress"] = "MablToolset: create mailbox address";
+    ExternalToolsEvents["EvaluateGenAiAssertion"] = "MablToolset: evaluate AI assertion";
+    ExternalToolsEvents["ExecuteDatabaseQuery"] = "MablToolset: execute database query";
+    ExternalToolsEvents["GetCredentials"] = "MablToolset: get credentials";
+    ExternalToolsEvents["GetMFACode"] = "MablTooset: get MFA code";
+    ExternalToolsEvents["InitializeContext"] = "MablToolset: content initialization";
+    ExternalToolsEvents["OpenPdfFileInPage"] = "MablToolset: open PDF file in page";
+    ExternalToolsEvents["WaitForEmail"] = "MablToolset: wait for email";
+})(ExternalToolsEvents || (exports.ExternalToolsEvents = ExternalToolsEvents = {}));

package/util/analytics.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackMablTestsRunnerEvent = exports.trackExternalToolEvent = exports.trackCliEvent = void 0;
+const env_1 = require("../env/env");
+const cliConfigProvider_1 = require("../providers/cliConfigProvider");
+const axiosProxyConfig_1 = require("../http/axiosProxyConfig");
+const pureUtil_1 = require("./pureUtil");
+const os = __importStar(require("os"));
+const types_1 = require("../api/types");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const configKeys_1 = require("../commands/config/config_cmds/configKeys");
+const Analytics = require('analytics-node');
+function getCliUserId(workspaceId) {
+    return `cliKey-${workspaceId !== null && workspaceId !== void 0 ? workspaceId : 'unknown'}`;
+}
+async function getTrackingInfo() {
+    var _a, _b, _c, _d, _e;
+    const config = await cliConfigProvider_1.CliConfigProvider.getCliConfig();
+    if (config.authentication.authType === undefined) {
+        return {};
+    }
+    let userId;
+    if (config.authentication.authType === types_1.AuthType.ApiKey) {
+        userId = `cliKey-${(_b = (_a = config.workspace) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 'unknown'}`;
+        userId = getCliUserId((_c = config.workspace) === null || _c === void 0 ? void 0 : _c.id);
+    }
+    else {
+        userId = config.userId;
+    }
+    const scmDetectionEnabled = (_d = (await cliConfigProvider_1.CliConfigProvider.getConfigProperty(configKeys_1.configKeys.enableSourceControlMetadataCollection))) !== null && _d !== void 0 ? _d : false;
+    return {
+        userId,
+        workspaceId: (_e = config.workspace) === null || _e === void 0 ? void 0 : _e.id,
+        features: {
+            scm_metadata: scmDetectionEnabled,
+        },
+    };
+}
+async function trackCliEvent(commands, argumentCountMap) {
+    try {
+        const trackingInfo = await getTrackingInfo();
+        if (!trackingInfo.userId) {
+            return;
+        }
+        const event = `mablCli - ${commands.join(' ')}`;
+        const properties = {
+            workspaceId: trackingInfo.workspaceId,
+            environment: env_1.ENV,
+            argumentCountMap,
+            features: trackingInfo.features,
+        };
+        await trackEvent(event, trackingInfo.userId, properties);
+    }
+    catch (error) {
+        if (env_1.ENV === 'local' || env_1.ENV === 'dev') {
+            loggingProvider_1.logger.error('Error with Segment event', error);
+        }
+    }
+}
+exports.trackCliEvent = trackCliEvent;
+async function trackExternalToolEvent(event, properties) {
+    try {
+        (await getAnalytics()).track({
+            userId: getCliUserId(properties.workspaceId),
+            event,
+            context: {
+                app: {
+                    build: env_1.ENV,
+                    name: (0, pureUtil_1.getCliName)(),
+                    version: (0, pureUtil_1.getCliVersion)(),
+                },
+                os: {
+                    name: os.platform(),
+                    version: os.release(),
+                },
+                groupId: properties.workspaceId,
+                userAgent: getUserAgent(),
+            },
+            properties,
+        });
+    }
+    catch (error) {
+        loggingProvider_1.logger.error('Error with analytics data', error);
+    }
+}
+exports.trackExternalToolEvent = trackExternalToolEvent;
+async function trackMablTestsRunnerEvent(eventName, resultsMap) {
+    try {
+        const trackingInfo = await getTrackingInfo();
+        if (!trackingInfo.userId) {
+            return;
+        }
+        const properties = {
+            workspaceId: trackingInfo.workspaceId,
+            environment: env_1.ENV,
+            resultsMap,
+        };
+        await trackEvent(eventName, trackingInfo.userId, properties);
+    }
+    catch (error) {
+        if (env_1.ENV === 'local' || env_1.ENV === 'dev') {
+            loggingProvider_1.logger.error('Error with Segment event', error);
+        }
+    }
+}
+exports.trackMablTestsRunnerEvent = trackMablTestsRunnerEvent;
+async function trackEvent(event, userId, properties) {
+    var _a, _b, _c;
+    const cpuInfo = (_a = os.cpus()) !== null && _a !== void 0 ? _a : [];
+    (await getAnalytics()).track({
+        userId,
+        event,
+        context: {
+            app: {
+                build: env_1.ENV,
+                name: (0, pureUtil_1.getCliName)(),
+                version: (0, pureUtil_1.getCliVersion)(),
+            },
+            os: {
+                name: os.platform(),
+                version: os.release(),
+            },
+            groupId: properties.workspaceId,
+            userAgent: getUserAgent(),
+            userAgentData: {
+                cpuCount: cpuInfo.length,
+                cpuType: (_b = cpuInfo === null || cpuInfo === void 0 ? void 0 : cpuInfo[0]) === null || _b === void 0 ? void 0 : _b.model,
+                cpuSpeed: (_c = cpuInfo === null || cpuInfo === void 0 ? void 0 : cpuInfo[0]) === null || _c === void 0 ? void 0 : _c.speed,
+                osArch: os.arch(),
+                memFree: os.freemem(),
+                memTotal: os.totalmem(),
+            },
+        },
+        properties,
+    });
+}
+async function getAnalytics() {
+    return new Analytics('ghbAXZbk8fqWROgMscPdkQMoqEjwsKRa', {
+        axiosConfig: await (0, axiosProxyConfig_1.currentProxyConfig)(),
+        errorHandler: (error) => {
+            if (env_1.ENV === 'local' || env_1.ENV === 'dev') {
+                loggingProvider_1.logger.error('Error with Segment event', error);
+            }
+        },
+        flushAt: 1,
+        flushInterval: 1,
+    });
+}
+function getUserAgent() {
+    var _a, _b;
+    const nodeName = (_b = (_a = process === null || process === void 0 ? void 0 : process.release) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'node';
+    return `${nodeName}_${process.arch}@${process.version}`;
+}

package/util/asyncUtil.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterAsync = exports.TimeoutError = exports.promiseWithTimeout = void 0;
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const pureUtil_1 = require("./pureUtil");
+const logUtils_1 = require("./logUtils");
+async function promiseWithTimeout(promise, timeoutMillis, description, timeoutType = 'mabl timeout', printToConsole = true) {
+    const startTimeMillis = new Date().getTime();
+    const { timer, cancelTimer, errorMessage } = startTimer(timeoutMillis, description, timeoutType);
+    try {
+        const result = await Promise.race([timer, promise]);
+        if (loggingProvider_1.logger.isDebugEnabled() && printToConsole) {
+            loggingProvider_1.logger.debug(`"${description}" completed in ${new Date().getTime() - startTimeMillis}ms`);
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof TimeoutError &&
+            printToConsole &&
+            error.message === errorMessage) {
+            loggingProvider_1.logger.warn(error.message);
+        }
+        throw error;
+    }
+    finally {
+        cancelTimer();
+    }
+}
+exports.promiseWithTimeout = promiseWithTimeout;
+class TimeoutError extends Error {
+    constructor(timeoutMillis, description, timeoutType) {
+        super(`[${timeoutType}] "${description}" timed out after ${timeoutMillis}ms`);
+        this.timeoutMillis = timeoutMillis;
+        this.description = description;
+        this.timeoutType = timeoutType;
+        Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+}
+exports.TimeoutError = TimeoutError;
+const startTimer = (timeoutMillis, description, timeoutType) => {
+    let timeout;
+    const timeoutError = new TimeoutError(timeoutMillis, description, timeoutType);
+    const promise = new Promise((_resolve, reject) => {
+        timeout = global.setTimeout(() => reject(timeoutError), timeoutMillis);
+        timeout.unref();
+    });
+    return {
+        timer: promise,
+        cancelTimer: () => global.clearTimeout(timeout),
+        errorMessage: timeoutError.message,
+    };
+};
+async function filterAsync(array, callback) {
+    const results = await Promise.allSettled(array.map(callback));
+    (0, logUtils_1.logPromiseSettledRejections)(results);
+    return array.filter((_, index) => {
+        const result = results[index];
+        return (0, pureUtil_1.isFulfilledPromise)(result) && result.value;
+    });
+}
+exports.filterAsync = filterAsync;

package/util/browserTestUtils.js

@@ -0,0 +1,17 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_TEST_BROWSER_WEBKIT = exports.IS_TEST_BROWSER_FIREFOX = exports.IS_TEST_BROWSER_CHROMIUM = exports.TEST_BROWSER_ENGINE = exports.TEST_BROWSER_TYPE = void 0;
+const browserEngines_1 = require("../browserEngines/browserEngines");
+const browserTypes_1 = require("../commands/browserTypes");
+const VALID_TEST_BROWSER_TYPES = ['chrome', 'firefox', 'webkit'];
+const browserTypeEnvironmentVariable = (_b = (_a = process.env.TEST_BROWSER_TYPE) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : 'chrome';
+if (browserTypeEnvironmentVariable &&
+    !VALID_TEST_BROWSER_TYPES.includes(browserTypeEnvironmentVariable)) {
+    throw Error(`Test browser type cannot be ${browserTypeEnvironmentVariable}, it must be one of ${VALID_TEST_BROWSER_TYPES}`);
+}
+exports.TEST_BROWSER_TYPE = browserTypeEnvironmentVariable;
+exports.TEST_BROWSER_ENGINE = browserEngines_1.BrowserTypeToBrowserEngine[exports.TEST_BROWSER_TYPE];
+exports.IS_TEST_BROWSER_CHROMIUM = exports.TEST_BROWSER_ENGINE === browserEngines_1.BrowserTypeToBrowserEngine[browserTypes_1.BrowserType.Chrome];
+exports.IS_TEST_BROWSER_FIREFOX = exports.TEST_BROWSER_ENGINE === browserEngines_1.BrowserTypeToBrowserEngine[browserTypes_1.BrowserType.Firefox];
+exports.IS_TEST_BROWSER_WEBKIT = exports.TEST_BROWSER_ENGINE === browserEngines_1.BrowserTypeToBrowserEngine[browserTypes_1.BrowserType.Webkit];

package/util/clickUtil.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickOnElement = exports.CLICK_TYPE_TO_HUMAN_TEXT = exports.ClickType = void 0;
+const messaging_1 = require("../core/messaging/messaging");
+const ExecutorUtils_1 = require("../execution/actions/ExecutorUtils");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const actionabilityUtil_1 = require("./actionabilityUtil");
+const logUtils_1 = require("./logUtils");
+var ClickType;
+(function (ClickType) {
+    ClickType["DoubleClick"] = "double_click";
+    ClickType["LeftClick"] = "click";
+    ClickType["RightClick"] = "right_click";
+})(ClickType || (exports.ClickType = ClickType = {}));
+const CLICK_TYPE_TO_JS_FIRER = {
+    [ClickType.DoubleClick]: (element) => globalThis.popupDismissal.fireDoubleClickEvent(element),
+    [ClickType.LeftClick]: (element) => globalThis.popupDismissal.fireClickEvent(element),
+    [ClickType.RightClick]: (element) => globalThis.popupDismissal.fireRightClickEvent(element),
+};
+exports.CLICK_TYPE_TO_HUMAN_TEXT = {
+    [ClickType.DoubleClick]: 'double click',
+    [ClickType.LeftClick]: 'click',
+    [ClickType.RightClick]: 'right click',
+};
+async function clickOnElement(elementHandle, executionContext, clickType = ClickType.LeftClick) {
+    const trialClickOptions = {
+        button: clickType === ClickType.RightClick ? 'right' : 'left',
+        trial: true,
+        minimizeScrollIntoView: executionContext.browserConfig.minimizeScrollIntoView,
+    };
+    const elementHandleTrialClickAction = clickType === ClickType.DoubleClick
+        ? () => elementHandle.doubleClick(trialClickOptions)
+        : () => elementHandle.click(trialClickOptions);
+    const noOverlappingElement = await (0, actionabilityUtil_1.checkPopupDismissalOnAction)(elementHandle, elementHandleTrialClickAction, executionContext);
+    const elementBoundingBox = await elementHandle.boundingBox();
+    const elementHasSurfaceArea = elementBoundingBox
+        ? elementBoundingBox.height > 0 && elementBoundingBox.width > 0
+        : false;
+    if (!noOverlappingElement || !elementHasSurfaceArea) {
+        const isAttached = await elementHandle.evaluate((el) => el.isConnected);
+        if (!isAttached) {
+            throw new Error(ExecutorUtils_1.ELEMENT_NOT_ATTACHED_ERROR);
+        }
+        const jsClickReasons = [
+            !noOverlappingElement && "there is a popup we couldn't dismiss",
+            !elementHasSurfaceArea && 'the element is not visible',
+        ]
+            .filter((reason) => reason !== false)
+            .join(' and ');
+        (0, logUtils_1.logWebUIAndCliOutput)(`Attempting ${exports.CLICK_TYPE_TO_HUMAN_TEXT[clickType]} with javascript because ${jsClickReasons}`, loggingProvider_1.LogLevel.Warn, executionContext, {
+            executionPhase: messaging_1.ExecutionPhase.DURING_ACTION,
+        });
+        if (noOverlappingElement) {
+            await (0, actionabilityUtil_1.maybeAddPopupLogic)(elementHandle);
+        }
+        const jsClickEventFirer = CLICK_TYPE_TO_JS_FIRER[clickType];
+        return elementHandle.evaluate(jsClickEventFirer);
+    }
+    const finalClickOptions = {
+        button: clickType === ClickType.RightClick ? 'right' : 'left',
+        timeout: 0,
+        minimizeScrollIntoView: executionContext.browserConfig.minimizeScrollIntoView,
+    };
+    return clickType === ClickType.DoubleClick
+        ? elementHandle.doubleClick(finalClickOptions)
+        : elementHandle.click(finalClickOptions);
+}
+exports.clickOnElement = clickOnElement;