@mablhq/playwright-tools 2.49.1

package/mablscriptFind/index.js.LICENSE.txt

@@ -0,0 +1,25 @@
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/**
+ * @license Complex.js v2.1.1 12/05/2020
+ *
+ * Copyright (c) 2020, Robert Eisele (robert@xarg.org)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ **/
+
+/**
+ * @license Fraction.js v4.2.0 05/03/2022
+ * https://www.xarg.org/2014/03/rational-numbers-in-javascript/
+ *
+ * Copyright (c) 2021, Robert Eisele (robert@xarg.org)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ **/

package/middleware.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_MIDDLEWARE = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const versionUtil_1 = require("./commands/commandUtil/versionUtil");
+const logLineMessaging_1 = require("./core/messaging/logLineMessaging");
+const messaging_1 = require("./core/messaging/messaging");
+const loggingProvider_1 = require("./providers/logging/loggingProvider");
+const analytics_1 = require("./util/analytics");
+const pureUtil_1 = require("./util/pureUtil");
+const simple_update_notifier_1 = __importDefault(require("simple-update-notifier"));
+const cliPackage = require('./package.json');
+const UPDATE_CHECK_INTERVAL_MILLISECONDS = 24 * 60 * 60 * 1000;
+const MIN_SUPPORTED_NODE_VERSION = (0, versionUtil_1.extractNodeVersionTuple)((_a = cliPackage === null || cliPackage === void 0 ? void 0 : cliPackage.engines) === null || _a === void 0 ? void 0 : _a.node);
+exports.CLI_MIDDLEWARE = [
+    () => {
+        (0, logLineMessaging_1.registerConsoleLoggerForOutput)(messaging_1.mablEventEmitter);
+    },
+    warnOnUnsupportedNodeVersion,
+    async (argv) => (0, analytics_1.trackCliEvent)(argv._, (0, pureUtil_1.extractKeyCountsFromArgs)(argv)),
+    runUpdateCheck,
+];
+function warnOnUnsupportedNodeVersion() {
+    const nodeVersion = (0, versionUtil_1.extractNodeVersionTuple)(process.version);
+    if ((0, versionUtil_1.compareNodeVersions)(nodeVersion, MIN_SUPPORTED_NODE_VERSION) < 0) {
+        loggingProvider_1.logger.info(chalk_1.default.bgYellow.black(`WARNING: Unsupported Node.js detected (`) +
+            chalk_1.default.bgYellow.bold.white((0, versionUtil_1.nodeVersionToString)(nodeVersion)) +
+            chalk_1.default.bgYellow.black(`). \nmabl-cli functionality may be limited, please update to `) +
+            chalk_1.default.bgYellow.bold.white((0, versionUtil_1.nodeVersionToString)(MIN_SUPPORTED_NODE_VERSION)) +
+            chalk_1.default.bgYellow.black(' or later.\n'));
+    }
+}
+async function runUpdateCheck() {
+    await (0, simple_update_notifier_1.default)({
+        pkg: cliPackage,
+        updateCheckInterval: UPDATE_CHECK_INTERVAL_MILLISECONDS,
+    });
+}

package/mobile/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/mobile/types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileAutomationName = void 0;
+var MobileAutomationName;
+(function (MobileAutomationName) {
+    MobileAutomationName["UiAutomator2"] = "UiAutomator2";
+    MobileAutomationName["XCUITest"] = "XCUITest";
+})(MobileAutomationName || (exports.MobileAutomationName = MobileAutomationName = {}));

package/observers/ObserverBase.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildObserverBaseOptions = exports.OBSERVER_TIMEOUT_MILLIS = void 0;
+exports.OBSERVER_TIMEOUT_MILLIS = 300000;
+function buildObserverBaseOptions(executionContext) {
+    return {
+        executionContext,
+        executionIndex: executionContext.executionIndexTracker.getExecutionIndex(),
+    };
+}
+exports.buildObserverBaseOptions = buildObserverBaseOptions;

package/observers/mockObserver.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeBrowserObserver = exports.noopPageLifecycleCallback = exports.noopObserveAfterFunction = exports.noopObserveDeferredFunction = void 0;
+const noopObserveDeferredFunction = () => Promise.resolve();
+exports.noopObserveDeferredFunction = noopObserveDeferredFunction;
+const noopObserveAfterFunction = () => Promise.resolve();
+exports.noopObserveAfterFunction = noopObserveAfterFunction;
+exports.noopPageLifecycleCallback = {
+    onPageCreated: () => { },
+    onPageDestroyed: () => { },
+};
+class FakeBrowserObserver {
+    constructor() {
+        this.observationType = 'test';
+        this._hitCount = 0;
+        this._sendObservationMessageHitCount = 0;
+    }
+    get sendObservationMessageHitCount() {
+        return this._sendObservationMessageHitCount;
+    }
+    get hitCount() {
+        return this._hitCount;
+    }
+    observeDeferred() {
+        this._hitCount += 1;
+        return Promise.resolve();
+    }
+    observeAfter() {
+        return Promise.resolve();
+    }
+    observeFlow() {
+        return Promise.resolve();
+    }
+    observeTest() {
+        return Promise.resolve();
+    }
+    onPageCreated(_page, _pageId) {
+        return Promise.resolve();
+    }
+    onPageDestroyed(_page, _pageId) {
+        return Promise.resolve();
+    }
+    sendObservationMessage() {
+        this._sendObservationMessageHitCount += 1;
+    }
+}
+exports.FakeBrowserObserver = FakeBrowserObserver;

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@mablhq/playwright-tools",
+  "version": "2.49.1",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "description": "The official mabl command line interface tool",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "bin": {},
+  "keywords": [
+    "mabl",
+    "cli"
+  ],
+  "author": "mabl",
+  "bugs": {
+    "email": "support@mabl.com"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@aws-crypto/crc32c": "5.1.0",
+    "@google-cloud/storage": "7.9.0",
+    "@mablhq/newman-reporter-mabl-console": "0.1.0",
+    "@plist/common": "1.1.0",
+    "@plist/parse": "1.1.0",
+    "@types/adm-zip": "0.5.5",
+    "@types/estree": "1.0.5",
+    "@types/lodash": "4.14.202",
+    "@xmldom/xmldom": "0.8.10",
+    "adm-zip": "0.5.10",
+    "agent-base": "6.0.2",
+    "analytics-node": "6.2.0",
+    "appium": "2.11.3",
+    "async-mutex": "0.3.1",
+    "async-retry": "1.3.3",
+    "axe-core": "4.8.3",
+    "axios": "0.27.2",
+    "axios-cookiejar-support": "1.0.1",
+    "cachedir": "2.4.0",
+    "cd": "0.3.3",
+    "chalk": "2.4.2",
+    "change-case": "4.1.1",
+    "chrome-launcher": "0.14.2",
+    "cli-table3": "0.6.1",
+    "conf": "10.2.0",
+    "csv-parser": "3.0.0",
+    "csv-stringify": "6.2.3",
+    "encodeurl": "1.0.2",
+    "env-paths": "2.2.0",
+    "escodegen": "2.0.0",
+    "esprima": "4.0.1",
+    "estraverse": "4.3.0",
+    "fast-json-stable-stringify": "2.1.0",
+    "fastest-levenshtein": "1.0.12",
+    "fs-extra": "8.1.0",
+    "git-repo-info": "2.1.1",
+    "glob": "7.1.6",
+    "hpagent": "1.2.0",
+    "http-mitm-proxy": "1.1.0",
+    "humanize-duration": "3.23.0",
+    "inquirer": "8.2.5",
+    "js-yaml": "4.1.0",
+    "jsesc": "3.0.2",
+    "jwt-decode": "2.2.0",
+    "lodash.get": "4.4.2",
+    "lodash.groupby": "4.6.0",
+    "markdown-table": "2.0.0",
+    "mime-types": "2.1.27",
+    "minimist": "1.2.8",
+    "mjpeg-consumer": "2.0.0",
+    "mochawesome-report-generator": "6.2.0",
+    "moment": "2.30.1",
+    "murmurhash": "1.0.0",
+    "newman": "6.0.0",
+    "open": "6.4.0",
+    "ora": "4.0.4",
+    "pixelmatch": "5.3.0",
+    "playwright": "^1.43.1",
+    "playwright-core": "^1.43.1",
+    "pluralize": "8.0.0",
+    "pngjs": "6.0.0",
+    "portfinder": "1.0.28",
+    "postman-collection": "4.1.4",
+    "query-string": "6.14.1",
+    "range_check": "2.0.4",
+    "retry": "0.13.1",
+    "sanitize-html": "2.3.3",
+    "serve-handler": "6.1.5",
+    "set-cookie-parser": "2.5.1",
+    "simple-update-notifier": "1.1.0",
+    "socks-proxy-agent": "6.1.1",
+    "stoppable": "1.1.0",
+    "strip-ansi": "6.0.0",
+    "tldts": "6.0.12",
+    "tmp-promise": "3.0.2",
+    "tough-cookie": "4.0.0",
+    "triple-beam": "1.3.0",
+    "uuid": "9.0.0",
+    "webdriverio": "8.39.1",
+    "winston": "3.13.0",
+    "winston-transport": "4.7.0",
+    "xpath": "0.0.32",
+    "y18n": "4.0.1",
+    "yargonaut": "1.1.4",
+    "yargs": "14.2.3"
+  }
+}

package/popupDismissal/candidate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/popupDismissal/index.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.elementsInFrontCount = exports.detectAndDismissPopupCandidates = exports.getAllElementsAbove = exports.getOverlappingElements = exports.fireRightClickEvent = exports.fireClickEvent = exports.fireDoubleClickEvent = exports.elementsByHigherZIndex = void 0;
+const DISMISSAL_WAIT_TIME_MS = 750;
+const ZINDEX_AUTO = 'auto';
+const MINIMUM_POPUP_DISPLAY_COVERAGE_PX = 0.95;
+const CLOSE_VALUES = [
+    'close',
+    'dismiss',
+    'exit',
+    'not at this time',
+    'no thanks',
+    'no, thanks',
+    'i, agree',
+    'i agree',
+];
+const ATTRIBUTES_TO_CHECK = [
+    { attributeName: 'className', matchFunction: matchOnAnyAppearance },
+    { attributeName: 'name', matchFunction: matchOnAnyAppearance },
+    { attributeName: 'id', matchFunction: matchOnAnyAppearance },
+    { attributeName: 'href', matchFunction: matchOnAnyAppearance },
+    { attributeName: 'innerText', matchFunction: matchWithWordBoundary },
+];
+function elementsByHigherZIndex(aboveIndex) {
+    return Array.from(document.querySelectorAll('body *')).reduce((obj, element) => {
+        const zIndex = parseFloat(globalThis.getComputedStyle(element).zIndex);
+        const aboveIndexNumber = typeof aboveIndex === 'number' ? aboveIndex : parseFloat(aboveIndex);
+        if (!Number.isNaN(zIndex) && zIndex >= aboveIndexNumber) {
+            if (obj.has(zIndex)) {
+                obj.get(zIndex).push(element);
+            }
+            else {
+                obj.set(zIndex, [element]);
+            }
+        }
+        return obj;
+    }, new Map());
+}
+exports.elementsByHigherZIndex = elementsByHigherZIndex;
+function getEffectiveZIndex(element) {
+    const isRootElement = (element) => element === undefined || element.tagName.toLowerCase() === 'html';
+    let current = element;
+    while (!isRootElement(current)) {
+        const zIndex = globalThis.getComputedStyle(current).zIndex;
+        if (zIndex && zIndex !== ZINDEX_AUTO) {
+            return parseInt(zIndex, 10);
+        }
+        current = (current === null || current === void 0 ? void 0 : current.parentElement) ? current.parentElement : undefined;
+    }
+    return 0;
+}
+function getDescendantElements(childElement) {
+    let children = [childElement];
+    const childNodes = Array.from(childElement.children);
+    childNodes.forEach((el) => {
+        children = children.concat(getDescendantElements(el));
+    });
+    return children;
+}
+function matchOnAnyAppearance(attribute, matchVal) {
+    return attribute.toLowerCase().includes(matchVal);
+}
+function matchWithWordBoundary(attribute, matchVal) {
+    const regExp = new RegExp(`\\b${matchVal}\\b`);
+    return !!attribute.toLowerCase().match(regExp);
+}
+function checkElementAttributes(element) {
+    let matches = 0;
+    ATTRIBUTES_TO_CHECK.forEach((attr) => {
+        CLOSE_VALUES.forEach((closeVal) => {
+            if (element.getAttribute(attr.attributeName) &&
+                attr.matchFunction(element.getAttribute(attr.attributeName), closeVal)) {
+                matches += 1;
+            }
+        });
+    });
+    return matches;
+}
+function checkElementDomCoverage(element) {
+    if (element.getBoundingClientRect) {
+        const bBox = element.getBoundingClientRect();
+        const yCoverage = bBox.width / globalThis.innerWidth;
+        const xCoverage = bBox.height / globalThis.innerHeight;
+        return (yCoverage > MINIMUM_POPUP_DISPLAY_COVERAGE_PX &&
+            xCoverage > MINIMUM_POPUP_DISPLAY_COVERAGE_PX);
+    }
+    return false;
+}
+function developCloseCandidates(candidates) {
+    const candidatesByZIndex = [];
+    candidates.forEach((candidate) => {
+        const domCovering = [];
+        const actionableElements = [];
+        candidate.elements.forEach((element) => {
+            var _a;
+            if (element === null || element === void 0 ? void 0 : element.offsetParent) {
+                if (['BUTTON', 'A', 'DIV'].includes((_a = element.tagName) === null || _a === void 0 ? void 0 : _a.toUpperCase()) &&
+                    checkElementAttributes(element) &&
+                    !actionableElements.includes(element)) {
+                    actionableElements.push(element);
+                }
+                else if (checkElementDomCoverage(element)) {
+                    domCovering.push(element);
+                }
+            }
+        });
+        candidatesByZIndex.push({
+            zIndex: candidate.zIndex,
+            actionableElements,
+            domCovering,
+            dismissedStatus: false,
+            elementsInFront: 0,
+        });
+    });
+    return candidatesByZIndex;
+}
+function dispatchMouseEvent(targetElement, eventType, leftEdgeClick = false) {
+    const boundingBox = targetElement.getBoundingClientRect();
+    const halfHeight = boundingBox.height / 2;
+    const xDistance = leftEdgeClick ? 1 : boundingBox.width / 2;
+    const button = eventType === 'contextmenu' ? 2 : 0;
+    const mouseEvent = new MouseEvent(eventType, {
+        bubbles: true,
+        cancelable: true,
+        view: window,
+        detail: 0,
+        screenX: boundingBox.left + xDistance,
+        screenY: boundingBox.top + halfHeight,
+        clientX: targetElement.clientLeft + xDistance,
+        clientY: targetElement.clientTop + halfHeight,
+        ctrlKey: false,
+        altKey: false,
+        shiftKey: false,
+        metaKey: false,
+        button,
+        relatedTarget: undefined,
+    });
+    targetElement.dispatchEvent(mouseEvent);
+}
+function fireDoubleClickEvent(targetElement) {
+    fireClickEvent(targetElement, false);
+    fireClickEvent(targetElement, false);
+    dispatchMouseEvent(targetElement, 'dblclick');
+}
+exports.fireDoubleClickEvent = fireDoubleClickEvent;
+function fireClickEvent(targetElement, leftEdgeClick = false) {
+    dispatchMouseEvent(targetElement, 'click', leftEdgeClick);
+}
+exports.fireClickEvent = fireClickEvent;
+function fireRightClickEvent(targetElement, leftEdgeClick = false) {
+    dispatchMouseEvent(targetElement, 'contextmenu', leftEdgeClick);
+}
+exports.fireRightClickEvent = fireRightClickEvent;
+function getCenterCoordinates(rect) {
+    return {
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2,
+    };
+}
+function getOverlappingElements(element) {
+    const { x, y } = getCenterCoordinates(element.getBoundingClientRect());
+    const elementsAtPoint = document.elementsFromPoint(x, y);
+    const targetIndex = elementsAtPoint.findIndex((iterElement) => iterElement === element);
+    return targetIndex ? elementsAtPoint.slice(0, targetIndex) : [];
+}
+exports.getOverlappingElements = getOverlappingElements;
+function sleep(time) {
+    return new Promise((resolve) => setTimeout(resolve, time));
+}
+function getAllElementsAbove(targetElement, elements) {
+    if (elements.length === 0) {
+        return [];
+    }
+    const targetZindex = getEffectiveZIndex(targetElement);
+    const zIndexAboveTarget = Math.min(...elements === null || elements === void 0 ? void 0 : elements.map((el) => getEffectiveZIndex(el)));
+    if (zIndexAboveTarget <= targetZindex) {
+        return [];
+    }
+    const higherElementsByZIndex = elementsByHigherZIndex(zIndexAboveTarget);
+    const allElementsByZIndex = Array.from(higherElementsByZIndex).map(([item, higherElements]) => {
+        const allElements = higherElements
+            .flatMap(getDescendantElements)
+            .reverse();
+        return { zIndex: item, elements: allElements };
+    });
+    allElementsByZIndex.sort((a, b) => b.zIndex - a.zIndex);
+    return allElementsByZIndex;
+}
+exports.getAllElementsAbove = getAllElementsAbove;
+async function detectAndDismissPopupCandidates(element) {
+    try {
+        let higherElements = getOverlappingElements(element);
+        const elementsInFrontCount = higherElements.length;
+        if (elementsInFrontCount === 0) {
+            return {
+                elementsInFront: 0,
+                dismissedStatus: false,
+            };
+        }
+        const clickCandidates = async function (candidates, leftEdgeClick) {
+            for (const candidate of candidates) {
+                fireClickEvent(candidate, leftEdgeClick);
+                await sleep(DISMISSAL_WAIT_TIME_MS);
+                if (getOverlappingElements(element).length < elementsInFrontCount) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        let allElements = getAllElementsAbove(element, higherElements);
+        const candidatesByZIndex = developCloseCandidates(allElements);
+        for (const candidate of candidatesByZIndex) {
+            let matched = await clickCandidates(candidate.domCovering, true);
+            if (!matched) {
+                matched = await clickCandidates(candidate.actionableElements, false);
+            }
+            if (matched) {
+                return {
+                    dismissedStatus: true,
+                    elementsInFront: 0,
+                };
+            }
+        }
+        higherElements = getOverlappingElements(element);
+        allElements = getAllElementsAbove(element, higherElements);
+        const candidates = developCloseCandidates(allElements);
+        const result = candidates.length
+            ? candidates[0]
+            : {
+                zIndex: 0,
+                elementsInFront: 0,
+                dismissedStatus: false,
+                domCovering: [],
+                actionableElements: [],
+            };
+        result.elementsInFront = higherElements.length;
+        result.dismissedStatus = false;
+        return {
+            dismissedStatus: result.dismissedStatus,
+            elementsInFront: result.elementsInFront,
+        };
+    }
+    catch (error) {
+        return {
+            elementsInFront: 0,
+            dismissedStatus: false,
+            error: error.toString(),
+        };
+    }
+}
+exports.detectAndDismissPopupCandidates = detectAndDismissPopupCandidates;
+function elementsInFrontCount(element) {
+    return getOverlappingElements(element).length;
+}
+exports.elementsInFrontCount = elementsInFrontCount;