@mablhq/mabl-cli 1.43.7 → 1.43.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mablhq/mabl-cli",
-  "version": "1.43.7",
+  "version": "1.43.10",
   "license": "SEE LICENSE IN LICENSE.txt",
   "description": "The official mabl command line interface tool",
   "main": "index.js",
@@ -42,6 +42,7 @@
     "decompress-zip": "0.2.2",
     "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",

package/util/clickUtil.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickOnElement = exports.ClickType = void 0;
+const messaging_1 = require("../core/messaging/messaging");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const actionabilityUtil_1 = require("./actionabilityUtil");
+const logUtils_1 = require("./logUtils");
+var ClickType;
+(function (ClickType) {
+    ClickType[ClickType["LeftClick"] = 0] = "LeftClick";
+    ClickType[ClickType["DoubleClick"] = 1] = "DoubleClick";
+})(ClickType = exports.ClickType || (exports.ClickType = {}));
+async function clickOnElement(elementHandle, executionContext, clickType) {
+    const trialClickOptions = {
+        trial: true,
+        minimizeScrollIntoView: executionContext.browserConfig.minimizeScrollIntoView,
+    };
+    const elementHandleTrialClickAction = clickType === ClickType.LeftClick
+        ? () => elementHandle.click(trialClickOptions)
+        : () => elementHandle.doubleClick(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 jsClickReasons = [
+            !noOverlappingElement && "there is a popup we couldn't dismiss",
+            !elementHasSurfaceArea && 'the element is not visible',
+        ]
+            .filter((reason) => reason !== false)
+            .join(' and ');
+        const clickText = clickType === ClickType.LeftClick ? 'click' : 'double click';
+        (0, logUtils_1.logWebUIAndCliOutput)(`Attempting ${clickText} 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 = clickType === ClickType.LeftClick
+            ? (element) => window.popupDismissal.fireClickEvent(element)
+            : (element) => window.popupDismissal.fireDoubleClickEvent(element);
+        return elementHandle.evaluate(jsClickEventFirer);
+    }
+    const finalClickOptions = {
+        timeout: 0,
+        minimizeScrollIntoView: executionContext.browserConfig.minimizeScrollIntoView,
+    };
+    return clickType === ClickType.LeftClick
+        ? elementHandle.click(finalClickOptions)
+        : elementHandle.doubleClick(finalClickOptions);
+}
+exports.clickOnElement = clickOnElement;

package/util/javaScriptStepMigration.js

@@ -0,0 +1,114 @@
+"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.normalizeScript = exports.hasVariableReferences = exports.attemptReusableSnippetParameterization = exports.attemptMigrationToParameterizedStep = void 0;
+const typescript_api_client_nodejs_1 = require("@mablhq/typescript-api-client-nodejs");
+const encodingUtil_1 = require("./encodingUtil");
+const esprima = __importStar(require("esprima"));
+const escodegen = __importStar(require("escodegen"));
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+function attemptMigrationToParameterizedStep(descriptor) {
+    let hasVariables;
+    let migrationDisabled;
+    try {
+        const decodedJS = (0, encodingUtil_1.b64DecodeUnicodeInNode)(descriptor.encodedJS);
+        migrationDisabled = isMigrationDisabled(decodedJS);
+        hasVariables = hasVariableReferences(decodedJS);
+    }
+    catch (error) {
+        loggingProvider_1.logger.warn(`Failed to determine if the inline snippet uses variables: ${error}`);
+        return descriptor;
+    }
+    if (migrationDisabled) {
+        return descriptor;
+    }
+    if (hasVariables) {
+        return descriptor;
+    }
+    loggingProvider_1.logger.info('Converting legacy inline JavaScript step to parameterized step.');
+    return migrateInlineDescriptor(descriptor);
+}
+exports.attemptMigrationToParameterizedStep = attemptMigrationToParameterizedStep;
+function migrateInlineDescriptor(descriptor) {
+    return {
+        inlineSnippet: {
+            body: descriptor.encodedJS,
+            description: '',
+            name: 'Unnamed snippet',
+            parameters: [],
+            snippet_type: typescript_api_client_nodejs_1.Snippet.SnippetTypeEnum.Javascript,
+        },
+        parameterOverrides: [],
+    };
+}
+function attemptReusableSnippetParameterization(snippet) {
+    if (Array.isArray(snippet.parameters)) {
+        return;
+    }
+    if (!snippet.body) {
+        return;
+    }
+    let hasVariables;
+    let migrationDisabled;
+    try {
+        const decodedJS = (0, encodingUtil_1.b64DecodeUnicodeInNode)(snippet.body);
+        migrationDisabled = isMigrationDisabled(decodedJS);
+        hasVariables = hasVariableReferences(decodedJS);
+    }
+    catch (error) {
+        loggingProvider_1.logger.warn(`Failed to determine if the reusable snippet uses variables: ${error}`);
+        return;
+    }
+    if (migrationDisabled) {
+        return;
+    }
+    if (hasVariables) {
+        loggingProvider_1.logger.info(`Skipping snippet parameter conversion due to variable usage. Snippet ID: ${snippet.id}`);
+        return;
+    }
+    loggingProvider_1.logger.info(`Migrating legacy snippet to parameterized snippet. Snippet ID: ${snippet.id}`);
+    snippet.parameters = [];
+}
+exports.attemptReusableSnippetParameterization = attemptReusableSnippetParameterization;
+function isMigrationDisabled(decodedScript) {
+    return decodedScript.indexOf('@mabl-disable-parameterization') >= 0;
+}
+function hasVariableReferences(decodedScript) {
+    const normalizedCode = normalizeScript(decodedScript);
+    const hasSignature = normalizedCode.indexOf('function mablJavaScriptStep(mablInputs') >= 0;
+    if (!hasSignature) {
+        throw new Error('Did not find expected mabl JavaScript function signature.');
+    }
+    const rex = /mablInputs/gi;
+    const match = normalizedCode.match(rex);
+    const matchCount = match ? match.length : 0;
+    return matchCount > 1;
+}
+exports.hasVariableReferences = hasVariableReferences;
+function normalizeScript(decodedScript) {
+    const tree = esprima.parseScript(decodedScript, { tolerant: true });
+    return escodegen.generate(tree);
+}
+exports.normalizeScript = normalizeScript;