@mablhq/mabl-cli 2.72.4 → 2.72.12

package/mablscript/steps/OpenEmailStep.js

@@ -4,43 +4,63 @@ exports.OpenEmailStep = void 0;
 const FindAction_1 = require("../actions/FindAction");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class OpenEmailStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(name, args, actions) {
-        super(name, args, actions, OpenEmailStep.stepName);
-        this.tabUuid = this.getActionArgs()[0] || {};
-        this.validate();
-        this.findAction = this.actions[0];
-    }
-    validate() {
-        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
+    constructor(descriptor, findAction) {
+        super(OpenEmailStep.stepName, descriptor, OpenEmailStep.actionCode, findAction);
+        this.tabUuid = descriptor.tab;
+    }
+    static validateActions(actions) {
+        if (actions.length !== 1 || !(actions[0] instanceof FindAction_1.FindAction)) {
             throw new Error('Open email steps should have exactly one sub action and it should be a find');
         }
+        return actions[0];
     }
     getStepName() {
-        return 'OpenEmail';
+        return OpenEmailStep.stepName;
     }
     toStepDescriptor() {
-        const find = this.findAction.toDescriptor();
-        return {
-            tab: this.tabUuid,
-            selector: find.findTarget.selector,
-            findType: 'FindEmail',
-            configuration: find.findTarget.configuration,
-            actionCode: this.actionCode,
-        };
+        return buildStepDescriptor(this.findAction, this.tabUuid);
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new OpenEmailStep(OpenEmailStep.stepName, [stepArgs.tab], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+        const stepDescriptor = buildStepDescriptor(findAction, stepArgs.tab);
+        const step = new OpenEmailStep(stepDescriptor, findAction);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(args, actions) {
+        const tabUuid = args[0] ?? '';
+        if (actions.length !== 1 || !(actions[0] instanceof FindAction_1.FindAction)) {
+            throw new Error('Open email steps should have exactly one sub action and it should be a find');
+        }
+        const findAction = actions[0];
+        const stepDescriptor = buildStepDescriptor(findAction, tabUuid);
+        const step = new OpenEmailStep(stepDescriptor, findAction);
+        step.actions = actions;
+        return step;
+    }
     toMablscript() {
         return `${this.findAction.toMablscript()}.open_email("${this.tabUuid}")`;
     }
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
+    stepDescription() {
+        const emailDescription = this.humanizeFind();
+        return `Open ${emailDescription}`;
+    }
 }
 exports.OpenEmailStep = OpenEmailStep;
-OpenEmailStep.stepName = 'open_email';
-OpenEmailStep.mablScriptStepNames = [OpenEmailStep.stepName];
-OpenEmailStep.yamlMablScriptNames = ['OpenEmail'];
+OpenEmailStep.stepName = 'OpenEmail';
+OpenEmailStep.actionCode = 'open_email';
+OpenEmailStep.mablScriptStepNames = [OpenEmailStep.actionCode];
+OpenEmailStep.yamlMablScriptNames = [OpenEmailStep.stepName];
+function buildStepDescriptor(findAction, tabUuid) {
+    const find = findAction.toDescriptor();
+    return {
+        tab: tabUuid,
+        selector: find.findTarget.selector,
+        findType: 'FindEmail',
+        configuration: find.findTarget.configuration,
+        actionCode: OpenEmailStep.actionCode,
+    };
+}

package/mablscript/steps/ReleaseStep.js

@@ -8,60 +8,44 @@ const ActionsUtils_1 = require("./ActionsUtils");
 const ReleaseStepDescriptor_1 = require("../types/ReleaseStepDescriptor");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class ReleaseStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'release');
-        this.findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(this.actions);
-        this.releaseArgs = this.parseArgs(args) ?? { isHtml5: false };
+    constructor(descriptor, findAction) {
+        super(ReleaseStep.stepName, descriptor, ReleaseStep.actionCode, findAction);
+        this.releaseArgs = descriptor.releaseArgs;
     }
-    parseArgs(args) {
+    static parseArgs(args) {
         if (args.length === 0) {
             return undefined;
         }
         if (args.length !== 1) {
-            throw new Error(`Unexpected number of arguments to ${this.getStepName()} step.`);
+            throw new Error(`Unexpected number of arguments to Release step.`);
         }
         if (!(0, ReleaseStepDescriptor_1.isReleaseArgs)(args[0])) {
-            throw new Error(`Invalid argument passed to ${this.getStepName()} step.`);
+            throw new Error(`Invalid argument passed to Release step.`);
         }
         return args[0];
     }
     getStepName() {
-        return 'Release';
+        return ReleaseStep.stepName;
     }
     toStepDescriptor() {
-        const find = this.findAction.toDescriptor();
-        switch (find.findType) {
-            case domUtil_1.FindType.FIND_FIRST:
-            case domUtil_1.FindType.FIND_LAST:
-            case domUtil_1.FindType.FIND_ANY:
-            case domUtil_1.FindType.FIND_ONE:
-                return {
-                    find,
-                    descriptorToActionMap: new Map().set(find, this.findAction),
-                    actionCode: this.actionCode,
-                    releaseArgs: this.releaseArgs,
-                };
-            default:
-                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
-        }
-    }
-    getFormattedStep(_fullLocatorsOn) {
-        const step = {
-            Release: {
-                ...super.annotationsAsYml(),
-                ...this.findAction.toYaml(),
-            },
-        };
-        if (this.stepId()) {
-            step.Release.id = this.stepId();
-        }
-        return step;
+        return buildStepDescriptor(this.findAction, this.releaseArgs);
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new ReleaseStep('release', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+        const releaseArgs = { isHtml5: false };
+        const stepDescriptor = buildStepDescriptor(findAction, releaseArgs);
+        const step = new ReleaseStep(stepDescriptor, findAction);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(args, actions) {
+        const findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(actions);
+        const releaseArgs = ReleaseStep.parseArgs(args) ?? { isHtml5: false };
+        const stepDescriptor = buildStepDescriptor(findAction, releaseArgs);
+        const step = new ReleaseStep(stepDescriptor, findAction);
+        step.actions = actions;
+        return step;
+    }
     toMablscript() {
         const args = (0, MablAction_1.convertObjectToMablscriptArgs)(this.releaseArgs);
         return `${this.findAction.toMablscript()}.release(${args})`;
@@ -69,7 +53,33 @@ class ReleaseStep extends MablStepWithFindAction_1.MablStepWithFindAction {
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
+    stepDescription() {
+        const actionPrefix = this.releaseArgs.isHtml5
+            ? 'Simulate release'
+            : 'Release';
+        const elementDescription = this.humanizeFind();
+        return `${actionPrefix} on ${elementDescription}`;
+    }
 }
 exports.ReleaseStep = ReleaseStep;
-ReleaseStep.mablScriptStepNames = ['release'];
-ReleaseStep.yamlMablScriptNames = ['Release'];
+ReleaseStep.stepName = 'Release';
+ReleaseStep.actionCode = 'release';
+ReleaseStep.mablScriptStepNames = [ReleaseStep.actionCode];
+ReleaseStep.yamlMablScriptNames = [ReleaseStep.stepName];
+function buildStepDescriptor(findAction, releaseArgs) {
+    const find = findAction.toDescriptor();
+    switch (find.findType) {
+        case domUtil_1.FindType.FIND_FIRST:
+        case domUtil_1.FindType.FIND_LAST:
+        case domUtil_1.FindType.FIND_ANY:
+        case domUtil_1.FindType.FIND_ONE:
+            return {
+                find,
+                descriptorToActionMap: new Map().set(find, findAction),
+                actionCode: 'release',
+                releaseArgs,
+            };
+        default:
+            throw new Error(`Error generating step descriptor for Release: Unexpected find type ${find.findType}`);
+    }
+}

package/mablscript/steps/RemoveCookieStep.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoveCookieStep = void 0;
-const MablStep_1 = require("../MablStep");
+const MablStepV2_1 = require("../MablStepV2");
 const MablAction_1 = require("../MablAction");
 const CookieUtils_1 = require("./CookieUtils");
 const domUtil_1 = require("../../domUtil");
-class RemoveCookieStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'remove_cookie');
-        this.cookieName = CookieUtils_1.CookieUtils.normalizeName(this.getActionArgs()[0].name);
+class RemoveCookieStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(RemoveCookieStep.stepName, descriptor, RemoveCookieStep.actionCode);
+        this.cookieName = descriptor.name;
     }
     getStepName() {
-        return 'RemoveCookie';
+        return RemoveCookieStep.stepName;
     }
     toStepDescriptor() {
         return {
@@ -20,17 +20,35 @@ class RemoveCookieStep extends MablStep_1.MablStep {
         };
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new RemoveCookieStep('remove_cookie', [stepArgs], []);
+        const stepDescriptor = {
+            actionCode: RemoveCookieStep.actionCode,
+            name: CookieUtils_1.CookieUtils.normalizeName(stepArgs.name),
+        };
+        const step = new RemoveCookieStep(stepDescriptor);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(args, _actions) {
+        const stepDescriptor = {
+            actionCode: RemoveCookieStep.actionCode,
+            name: CookieUtils_1.CookieUtils.normalizeName(args[0].name),
+        };
+        const step = new RemoveCookieStep(stepDescriptor);
+        step.actions = _actions;
+        return step;
+    }
     toMablscript() {
         return `remove_cookie({ name : "${(0, domUtil_1.escapeMablscriptString)(this.cookieName)}" })`;
     }
     getInputVariables() {
         return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.cookieName);
     }
+    stepDescription() {
+        return `Remove cookie: "${this.cookieName}"`;
+    }
 }
 exports.RemoveCookieStep = RemoveCookieStep;
-RemoveCookieStep.mablScriptStepNames = ['remove_cookie'];
-RemoveCookieStep.yamlMablScriptNames = ['RemoveCookie'];
+RemoveCookieStep.stepName = 'RemoveCookie';
+RemoveCookieStep.actionCode = 'remove_cookie';
+RemoveCookieStep.mablScriptStepNames = [RemoveCookieStep.actionCode];
+RemoveCookieStep.yamlMablScriptNames = [RemoveCookieStep.stepName];

package/mablscript/steps/RightClickStep.js

@@ -6,53 +6,58 @@ const domUtil_1 = require("../../domUtil");
 const ActionsUtils_1 = require("./ActionsUtils");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class RightClickStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'right_click');
-        this.findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(this.actions);
+    constructor(descriptor, findAction) {
+        super(RightClickStep.stepName, descriptor, RightClickStep.actionCode, findAction);
     }
     getStepName() {
-        return 'RightClick';
+        return RightClickStep.stepName;
     }
     toStepDescriptor() {
-        const find = this.findAction.toDescriptor();
-        switch (find.findType) {
-            case domUtil_1.FindType.FIND_FIRST:
-            case domUtil_1.FindType.FIND_LAST:
-            case domUtil_1.FindType.FIND_ANY:
-            case domUtil_1.FindType.FIND_ONE:
-                return {
-                    find,
-                    descriptorToActionMap: new Map().set(find, this.findAction),
-                    actionCode: this.actionCode,
-                };
-            default:
-                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
-        }
-    }
-    getFormattedStep(_fullLocatorsOn) {
-        const step = {
-            RightClick: {
-                ...super.annotationsAsYml(),
-                ...this.findAction.toYaml(),
-            },
-        };
-        if (this.stepId()) {
-            step.RightClick.id = this.stepId();
-        }
-        return step;
+        return buildStepDescriptor(this.findAction);
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new RightClickStep('right_click', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+        const stepDescriptor = buildStepDescriptor(findAction);
+        const step = new RightClickStep(stepDescriptor, findAction);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(_args, actions) {
+        const findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(actions);
+        const stepDescriptor = buildStepDescriptor(findAction);
+        const step = new RightClickStep(stepDescriptor, findAction);
+        step.actions = actions;
+        return step;
+    }
     toMablscript() {
         return `${this.findAction.toMablscript()}.right_click()`;
     }
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
+    stepDescription() {
+        const elementDescription = this.humanizeFind();
+        return `Right click on ${elementDescription}`;
+    }
 }
 exports.RightClickStep = RightClickStep;
-RightClickStep.mablScriptStepNames = ['right_click'];
-RightClickStep.yamlMablScriptNames = ['RightClick'];
+RightClickStep.stepName = 'Right Click';
+RightClickStep.actionCode = 'right_click';
+RightClickStep.mablScriptStepNames = [RightClickStep.actionCode];
+RightClickStep.yamlMablScriptNames = [RightClickStep.stepName];
+function buildStepDescriptor(findAction) {
+    const find = findAction.toDescriptor();
+    switch (find.findType) {
+        case domUtil_1.FindType.FIND_FIRST:
+        case domUtil_1.FindType.FIND_LAST:
+        case domUtil_1.FindType.FIND_ANY:
+        case domUtil_1.FindType.FIND_ONE:
+            return {
+                find,
+                descriptorToActionMap: new Map().set(find, findAction),
+                actionCode: RightClickStep.actionCode,
+            };
+        default:
+            throw new Error(`Error generating step descriptor for ${RightClickStep.stepName}: Unexpected find type ${find.findType}`);
+    }
+}

package/mablscript/steps/SelectStep.js

@@ -6,37 +6,20 @@ const MablAction_1 = require("../MablAction");
 const domUtil_1 = require("../../domUtil");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class SelectStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'select');
-        this.selectOptions = this.getActionArgs()[0];
-        this.selectOptionType = this.getActionArgs()[1];
-        this.validate();
-        this.findAction = this.actions[0];
+    constructor(descriptor, findAction) {
+        super(SelectStep.stepName, descriptor, SelectStep.actionCode, findAction);
     }
-    validate() {
-        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
-            throw new Error('Select steps should have exactly on sub action and it should be a find');
+    static validateActions(actions) {
+        if (actions.length !== 1 || !(actions[0] instanceof FindAction_1.FindAction)) {
+            throw new Error('Select steps should have exactly one sub action and it should be a find');
         }
+        return actions[0];
     }
     getStepName() {
-        return 'Select';
+        return SelectStep.stepName;
     }
     toStepDescriptor() {
-        const selectOptionsCopy = this.selectOptions;
-        selectOptionsCopy.selectOptionType = this.selectOptionType;
-        const formatted = { ...selectOptionsCopy };
-        const find = this.findAction.toDescriptor();
-        switch (find.findType) {
-            case domUtil_1.FindType.FIND_FIRST:
-            case domUtil_1.FindType.FIND_LAST:
-            case domUtil_1.FindType.FIND_ANY:
-            case domUtil_1.FindType.FIND_ONE:
-                formatted.find = find;
-                formatted.descriptorToActionMap = new Map().set(find, this.findAction);
-                return formatted;
-            default:
-                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
-        }
+        return this.descriptor;
     }
     static fromYaml(_stepName, stepArgs) {
         const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
@@ -45,38 +28,80 @@ class SelectStep extends MablStepWithFindAction_1.MablStepWithFindAction {
         delete stepArgs.selectorAncestors;
         delete stepArgs.selectOptionType;
         const selectOptions = stepArgs;
-        const step = new SelectStep('select', [selectOptions, selectOptionType], [findAction]);
+        const stepDescriptor = buildStepDescriptor(findAction, selectOptions, selectOptionType);
+        const step = new SelectStep(stepDescriptor, findAction);
         step.setStepId(stepArgs.id);
         return step;
     }
-    getFormattedStep(_fullLocatorsOn) {
-        const step = this.selectOptions;
-        const { find, ...ymlStep } = step;
-        const finalStep = {
-            Select: {
-                ...ymlStep,
-                ...super.annotationsAsYml(),
-                ...this.findAction.toYaml(),
-            },
-        };
-        if (this.stepId()) {
-            finalStep.Select.id = this.stepId();
-        }
-        return finalStep;
+    static fromLegacyMablscript(args, actions) {
+        const selectOptions = args[0];
+        const selectOptionType = args[1];
+        const findAction = SelectStep.validateActions(actions);
+        const stepDescriptor = buildStepDescriptor(findAction, selectOptions, selectOptionType);
+        const step = new SelectStep(stepDescriptor, findAction);
+        step.actions = actions;
+        return step;
     }
     toMablscript() {
-        const selectOptionType = this.selectOptionType
-            ? `, "${this.selectOptionType}"`
+        const descriptor = this.descriptor;
+        const selectOptionType = descriptor.selectOptionType;
+        const selectOptions = {
+            index: descriptor.index,
+            position: descriptor.position,
+            selector_type: descriptor.selector_type,
+            text: descriptor.text,
+            uuid: descriptor.uuid,
+            value: descriptor.value,
+        };
+        const mablscriptSelectOptions = (0, MablAction_1.convertObjectToMablscriptArgs)(selectOptions);
+        const mablscriptSelectType = selectOptionType
+            ? `, "${selectOptionType}"`
             : '';
-        return `${this.findAction.toMablscript()}.select(${(0, MablAction_1.convertObjectToMablscriptArgs)(this.selectOptions)}${selectOptionType})`;
+        const mablscriptSelectArgs = mablscriptSelectOptions + mablscriptSelectType;
+        return `${this.findAction.toMablscript()}.select(${mablscriptSelectArgs})`;
     }
     getInputVariables() {
         return (0, MablAction_1.distinctStrings)([
             ...this.findAction.getInputVariables(),
-            ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.selectOptions),
+            ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.descriptor),
         ]);
     }
+    stepDescription() {
+        let selectionDescription = 'option';
+        const descriptor = this.descriptor;
+        if (descriptor.value) {
+            selectionDescription = `"${descriptor.value}"`;
+        }
+        else if (descriptor.text) {
+            selectionDescription = `"${descriptor.text}"`;
+        }
+        else if (descriptor.index !== undefined) {
+            selectionDescription = `option ${descriptor.index}`;
+        }
+        const elementDescription = this.humanizeFind();
+        return `Select ${selectionDescription} from ${elementDescription}`;
+    }
 }
 exports.SelectStep = SelectStep;
-SelectStep.mablScriptStepNames = ['select'];
-SelectStep.yamlMablScriptNames = ['Select'];
+SelectStep.stepName = 'Select';
+SelectStep.actionCode = 'select';
+SelectStep.mablScriptStepNames = [SelectStep.actionCode];
+SelectStep.yamlMablScriptNames = [SelectStep.stepName];
+function buildStepDescriptor(findAction, selectOptions, selectOptionType) {
+    const find = findAction.toDescriptor();
+    switch (find.findType) {
+        case domUtil_1.FindType.FIND_FIRST:
+        case domUtil_1.FindType.FIND_LAST:
+        case domUtil_1.FindType.FIND_ANY:
+        case domUtil_1.FindType.FIND_ONE:
+            const descriptorToActionMap = new Map().set(find, findAction);
+            return {
+                find,
+                descriptorToActionMap,
+                selectOptionType,
+                ...selectOptions,
+            };
+        default:
+            throw new Error(`Error generating step descriptor for ${SelectStep.stepName}: Unexpected find type ${find.findType}`);
+    }
+}

package/mablscript/steps/SendHttpRequestStep.js

@@ -4,8 +4,8 @@ exports.SendHttpRequestVariableSource = exports.SendHttpRequestStep = void 0;
 const ConditionDescriptor_1 = require("../types/ConditionDescriptor");
 const AbstractAssertionsAndVariablesStep_1 = require("./AbstractAssertionsAndVariablesStep");
 class SendHttpRequestStep extends AbstractAssertionsAndVariablesStep_1.AbstractAssertionsAndVariablesStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'send_http_request', SendHttpRequestStep.stepName, args[0]);
+    constructor(descriptor) {
+        super(SendHttpRequestStep.stepName, descriptor, SendHttpRequestStep.actionCode);
     }
     static fromYaml(_stepName, stepArgs) {
         const formatted = stepArgs;
@@ -28,14 +28,21 @@ class SendHttpRequestStep extends AbstractAssertionsAndVariablesStep_1.AbstractA
                 assertion.assertion = comparisonTypeConverter[assertion.assertion];
             }
         });
-        const step = new SendHttpRequestStep(SendHttpRequestStep.stepName, [formatted], []);
+        const step = new SendHttpRequestStep(formatted);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(args, _actions) {
+        if (args.length !== 1) {
+            throw new Error(`SendHttpRequestStep fromLegacyMablscript expects 1 argument, got ${args.length}`);
+        }
+        return new SendHttpRequestStep(args[0]);
+    }
 }
 exports.SendHttpRequestStep = SendHttpRequestStep;
 SendHttpRequestStep.stepName = 'SendHttpRequest';
-SendHttpRequestStep.mablScriptStepNames = ['send_http_request'];
+SendHttpRequestStep.actionCode = 'send_http_request';
+SendHttpRequestStep.mablScriptStepNames = [SendHttpRequestStep.actionCode];
 SendHttpRequestStep.yamlMablScriptNames = [SendHttpRequestStep.stepName];
 var SendHttpRequestVariableSource;
 (function (SendHttpRequestVariableSource) {