@mablhq/mabl-cli 2.72.0 → 2.72.3

package/mablscript/steps/OpenEmailStep.js

@@ -4,61 +4,43 @@ exports.OpenEmailStep = void 0;
 const FindAction_1 = require("../actions/FindAction");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class OpenEmailStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    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)) {
+    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)) {
             throw new Error('Open email steps should have exactly one sub action and it should be a find');
         }
-        return actions[0];
     }
     getStepName() {
-        return OpenEmailStep.stepName;
+        return 'OpenEmail';
     }
     toStepDescriptor() {
-        return buildStepDescriptor(this.findAction, this.tabUuid);
+        const find = this.findAction.toDescriptor();
+        return {
+            tab: this.tabUuid,
+            selector: find.findTarget.selector,
+            findType: 'FindEmail',
+            configuration: find.findTarget.configuration,
+            actionCode: this.actionCode,
+        };
     }
     static fromYaml(_stepName, stepArgs) {
-        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
-        const stepDescriptor = buildStepDescriptor(findAction, stepArgs.tab);
-        const step = new OpenEmailStep(stepDescriptor, findAction);
+        const step = new OpenEmailStep(OpenEmailStep.stepName, [stepArgs.tab], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
         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);
-        return new OpenEmailStep(stepDescriptor, findAction);
-    }
     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 = '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,
-    };
-}
+OpenEmailStep.stepName = 'open_email';
+OpenEmailStep.mablScriptStepNames = [OpenEmailStep.stepName];
+OpenEmailStep.yamlMablScriptNames = ['OpenEmail'];

package/mablscript/steps/ReleaseStep.js

@@ -8,42 +8,60 @@ const ActionsUtils_1 = require("./ActionsUtils");
 const ReleaseStepDescriptor_1 = require("../types/ReleaseStepDescriptor");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class ReleaseStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(descriptor, findAction) {
-        super(ReleaseStep.stepName, descriptor, ReleaseStep.actionCode, findAction);
-        this.releaseArgs = descriptor.releaseArgs;
+    constructor(name, args, actions) {
+        super(name, args, actions, 'release');
+        this.findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(this.actions);
+        this.releaseArgs = this.parseArgs(args) ?? { isHtml5: false };
     }
-    static parseArgs(args) {
+    parseArgs(args) {
         if (args.length === 0) {
             return undefined;
         }
         if (args.length !== 1) {
-            throw new Error(`Unexpected number of arguments to Release step.`);
+            throw new Error(`Unexpected number of arguments to ${this.getStepName()} step.`);
         }
         if (!(0, ReleaseStepDescriptor_1.isReleaseArgs)(args[0])) {
-            throw new Error(`Invalid argument passed to Release step.`);
+            throw new Error(`Invalid argument passed to ${this.getStepName()} step.`);
         }
         return args[0];
     }
     getStepName() {
-        return ReleaseStep.stepName;
+        return 'Release';
     }
     toStepDescriptor() {
-        return buildStepDescriptor(this.findAction, this.releaseArgs);
+        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;
     }
     static fromYaml(_stepName, stepArgs) {
-        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
-        const releaseArgs = { isHtml5: false };
-        const stepDescriptor = buildStepDescriptor(findAction, releaseArgs);
-        const step = new ReleaseStep(stepDescriptor, findAction);
+        const step = new ReleaseStep('release', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
         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);
-        return new ReleaseStep(stepDescriptor, findAction);
-    }
     toMablscript() {
         const args = (0, MablAction_1.convertObjectToMablscriptArgs)(this.releaseArgs);
         return `${this.findAction.toMablscript()}.release(${args})`;
@@ -51,33 +69,7 @@ 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.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}`);
-    }
-}
+ReleaseStep.mablScriptStepNames = ['release'];
+ReleaseStep.yamlMablScriptNames = ['Release'];

package/mablscript/steps/RemoveCookieStep.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoveCookieStep = void 0;
-const MablStepV2_1 = require("../MablStepV2");
+const MablStep_1 = require("../MablStep");
 const MablAction_1 = require("../MablAction");
 const CookieUtils_1 = require("./CookieUtils");
 const domUtil_1 = require("../../domUtil");
-class RemoveCookieStep extends MablStepV2_1.MablStepV2 {
-    constructor(descriptor) {
-        super(RemoveCookieStep.stepName, descriptor, RemoveCookieStep.actionCode);
-        this.cookieName = descriptor.name;
+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);
     }
     getStepName() {
-        return RemoveCookieStep.stepName;
+        return 'RemoveCookie';
     }
     toStepDescriptor() {
         return {
@@ -20,33 +20,17 @@ class RemoveCookieStep extends MablStepV2_1.MablStepV2 {
         };
     }
     static fromYaml(_stepName, stepArgs) {
-        const stepDescriptor = {
-            actionCode: RemoveCookieStep.actionCode,
-            name: CookieUtils_1.CookieUtils.normalizeName(stepArgs.name),
-        };
-        const step = new RemoveCookieStep(stepDescriptor);
+        const step = new RemoveCookieStep('remove_cookie', [stepArgs], []);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(args, _actions) {
-        const stepDescriptor = {
-            actionCode: RemoveCookieStep.actionCode,
-            name: CookieUtils_1.CookieUtils.normalizeName(args[0].name),
-        };
-        return new RemoveCookieStep(stepDescriptor);
-    }
     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.stepName = 'RemoveCookie';
-RemoveCookieStep.actionCode = 'remove_cookie';
-RemoveCookieStep.mablScriptStepNames = [RemoveCookieStep.actionCode];
-RemoveCookieStep.yamlMablScriptNames = [RemoveCookieStep.stepName];
+RemoveCookieStep.mablScriptStepNames = ['remove_cookie'];
+RemoveCookieStep.yamlMablScriptNames = ['RemoveCookie'];

package/mablscript/steps/RightClickStep.js

@@ -6,56 +6,53 @@ const domUtil_1 = require("../../domUtil");
 const ActionsUtils_1 = require("./ActionsUtils");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class RightClickStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(descriptor, findAction) {
-        super(RightClickStep.stepName, descriptor, RightClickStep.actionCode, findAction);
+    constructor(name, args, actions) {
+        super(name, args, actions, 'right_click');
+        this.findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(this.actions);
     }
     getStepName() {
-        return RightClickStep.stepName;
+        return 'RightClick';
     }
     toStepDescriptor() {
-        return buildStepDescriptor(this.findAction);
+        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;
     }
     static fromYaml(_stepName, stepArgs) {
-        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
-        const stepDescriptor = buildStepDescriptor(findAction);
-        const step = new RightClickStep(stepDescriptor, findAction);
+        const step = new RightClickStep('right_click', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(_args, actions) {
-        const findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(actions);
-        const stepDescriptor = buildStepDescriptor(findAction);
-        return new RightClickStep(stepDescriptor, findAction);
-    }
     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.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}`);
-    }
-}
+RightClickStep.mablScriptStepNames = ['right_click'];
+RightClickStep.yamlMablScriptNames = ['RightClick'];

package/mablscript/steps/SelectStep.js

@@ -6,20 +6,37 @@ const MablAction_1 = require("../MablAction");
 const domUtil_1 = require("../../domUtil");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class SelectStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(descriptor, findAction) {
-        super(SelectStep.stepName, descriptor, SelectStep.actionCode, findAction);
+    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];
     }
-    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');
+    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');
         }
-        return actions[0];
     }
     getStepName() {
-        return SelectStep.stepName;
+        return 'Select';
     }
     toStepDescriptor() {
-        return this.descriptor;
+        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}`);
+        }
     }
     static fromYaml(_stepName, stepArgs) {
         const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
@@ -28,78 +45,38 @@ class SelectStep extends MablStepWithFindAction_1.MablStepWithFindAction {
         delete stepArgs.selectorAncestors;
         delete stepArgs.selectOptionType;
         const selectOptions = stepArgs;
-        const stepDescriptor = buildStepDescriptor(findAction, selectOptions, selectOptionType);
-        const step = new SelectStep(stepDescriptor, findAction);
+        const step = new SelectStep('select', [selectOptions, selectOptionType], [findAction]);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(args, actions) {
-        const selectOptions = args[0];
-        const selectOptionType = args[1];
-        const findAction = SelectStep.validateActions(actions);
-        const stepDescriptor = buildStepDescriptor(findAction, selectOptions, selectOptionType);
-        return new SelectStep(stepDescriptor, findAction);
+    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;
     }
     toMablscript() {
-        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}"`
+        const selectOptionType = this.selectOptionType
+            ? `, "${this.selectOptionType}"`
             : '';
-        const mablscriptSelectArgs = mablscriptSelectOptions + mablscriptSelectType;
-        return `${this.findAction.toMablscript()}.select(${mablscriptSelectArgs})`;
+        return `${this.findAction.toMablscript()}.select(${(0, MablAction_1.convertObjectToMablscriptArgs)(this.selectOptions)}${selectOptionType})`;
     }
     getInputVariables() {
         return (0, MablAction_1.distinctStrings)([
             ...this.findAction.getInputVariables(),
-            ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.descriptor),
+            ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.selectOptions),
         ]);
     }
-    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.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}`);
-    }
-}
+SelectStep.mablScriptStepNames = ['select'];
+SelectStep.yamlMablScriptNames = ['Select'];

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(descriptor) {
-        super(SendHttpRequestStep.stepName, descriptor, SendHttpRequestStep.actionCode);
+    constructor(name, args, actions) {
+        super(name, args, actions, 'send_http_request', SendHttpRequestStep.stepName, args[0]);
     }
     static fromYaml(_stepName, stepArgs) {
         const formatted = stepArgs;
@@ -28,23 +28,14 @@ class SendHttpRequestStep extends AbstractAssertionsAndVariablesStep_1.AbstractA
                 assertion.assertion = comparisonTypeConverter[assertion.assertion];
             }
         });
-        const step = new SendHttpRequestStep(formatted);
+        const step = new SendHttpRequestStep(SendHttpRequestStep.stepName, [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}`);
-        }
-        const step = new SendHttpRequestStep(args[0]);
-        step.setStepId(args[0].id);
-        return step;
-    }
 }
 exports.SendHttpRequestStep = SendHttpRequestStep;
 SendHttpRequestStep.stepName = 'SendHttpRequest';
-SendHttpRequestStep.actionCode = 'send_http_request';
-SendHttpRequestStep.mablScriptStepNames = [SendHttpRequestStep.actionCode];
+SendHttpRequestStep.mablScriptStepNames = ['send_http_request'];
 SendHttpRequestStep.yamlMablScriptNames = [SendHttpRequestStep.stepName];
 var SendHttpRequestVariableSource;
 (function (SendHttpRequestVariableSource) {