@mablhq/mabl-cli 2.72.4 → 2.72.12

package/mablscript/steps/AssertStepOld.js

@@ -1,159 +1,89 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssertStepOld = void 0;
-const ExtractAction_1 = require("../actions/ExtractAction");
-const MablStep_1 = require("../MablStep");
-const FindAction_1 = require("../actions/FindAction");
-const domUtil_1 = require("../../domUtil");
-const importer_1 = require("../importer");
-const GetCurrentLocationDescriptor_1 = require("../types/GetCurrentLocationDescriptor");
-const GetVariableDescriptor_1 = require("../types/GetVariableDescriptor");
-const GetViewportDescriptor_1 = require("../types/GetViewportDescriptor");
-const oldToNewAssertionTypes = {
-    assert_contains: 'AssertContains',
-    assert_does_not_contain: 'AssertDoesNotContain',
-    assert_does_not_equal: 'AssertDoesNotEqual',
-    assert_download: 'AssertDownload',
+exports.AssertStepOldConverter = exports.oldToV2StepNameMap = void 0;
+const AssertStep_1 = require("./AssertStep");
+const ConditionAction_1 = require("../actions/ConditionAction");
+const ConditionDescriptor_1 = require("../types/ConditionDescriptor");
+exports.oldToV2StepNameMap = {
     assert_equals: 'AssertEquals',
-    assert_greater_than: 'AssertGreaterThan',
-    assert_greater_than_or_equals: 'AssertGreaterThanOrEquals',
-    assert_less_than: 'AssertLessThan',
-    assert_less_than_or_equals: 'AssertLessThanOrEquals',
-    assert_not_present: 'AssertNotPresent',
     assert_present: 'AssertPresent',
+    assert_not_present: 'AssertNotPresent',
+    assert_does_not_equal: 'AssertDoesNotEqual',
+    assert_contains: 'AssertContains',
+    assert_does_not_contain: 'AssertDoesNotContain',
     assert_starts_with: 'AssertStartsWith',
     assert_starts_without: 'AssertStartsWithout',
     assert_ends_with: 'AssertEndsWith',
     assert_ends_without: 'AssertEndsWithout',
+    assert_greater_than: 'AssertGreaterThan',
+    assert_less_than: 'AssertLessThan',
+    assert_greater_than_or_equals: 'AssertGreaterThanOrEquals',
+    assert_less_than_or_equals: 'AssertLessThanOrEquals',
+    assert_matches_regex: 'AssertMatchesRegex',
+    assert_ai_prompt: 'AssertAIPrompt',
 };
-class AssertStepOld extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, name);
-        this.assertionType = '';
-        this.assertAttribute = '';
-        this.validate();
-        this.setAssertAttribute();
-        this.assertionType = this.name;
-        this.primaryAction = actions[0];
-        this.extractAction = actions[1];
-        if (args.length === 1) {
-            this.onFailure = args[0].onFailure;
-            this.observationScope = args[0].observationScope;
-        }
-        else if (args.length === 2) {
-            this.onFailure = args[1].onFailure;
-            this.observationScope = args[1].observationScope;
-        }
-    }
-    validate() {
-        if (this.actions.length !== 2 &&
-            !(this.actions[0] instanceof FindAction_1.FindAction) &&
-            !(this.actions[1] instanceof ExtractAction_1.ExtractAction)) {
-            throw new Error('Legacy assert steps should have exactly two sub action:  a find and an extract');
+class AssertStepOldConverter {
+    static convert(name, args, actions) {
+        const v2StepName = exports.oldToV2StepNameMap[name];
+        if (!v2StepName) {
+            throw new Error(`Unknown old assertion type: ${name}`);
         }
-    }
-    setAssertAttribute() {
-        this.assertAttribute = this.getActionArgs()[0];
-    }
-    getStepName() {
-        return oldToNewAssertionTypes[this.getAssertionType()];
-    }
-    getAssertionType() {
-        return this.assertionType;
-    }
-    toStepDescriptor() {
-        const formatted = {};
-        if (this.assertionType !== 'assert_present' &&
-            this.assertionType !== 'assert_not_present') {
-            formatted.assertionValue = this.assertAttribute;
+        const newActions = [];
+        newActions.push(actions[0]);
+        if (actions[1]) {
+            newActions.push(actions[1]);
         }
-        if (this.extractAction) {
-            formatted.extractType =
-                ExtractAction_1.ExtractAction.mablscriptToYamlType[this.extractAction.extractionType];
-            formatted.attribute = this.extractAction.extractionAttribute;
-        }
-        const find = this.primaryAction.toDescriptor();
-        formatted.findOptions = find.selectorFindOption;
-        if ((0, GetCurrentLocationDescriptor_1.isGetCurrentLocationDescriptor)(find) ||
-            (0, GetVariableDescriptor_1.isGetVariableDescriptor)(find) ||
-            (0, GetViewportDescriptor_1.isGetViewportDescriptor)(find)) {
-            formatted.kind = find.kind;
-        }
-        else {
-            switch (find.findType) {
-                case domUtil_1.FindType.FIND_COOKIE:
-                case domUtil_1.FindType.FIND_EMAIL:
-                    formatted.findType = FindAction_1.findTypesToFormattedType[find.findType];
-                    formatted.selector = find.findTarget;
-                    break;
-                case domUtil_1.FindType.FIND_FIRST:
-                case domUtil_1.FindType.FIND_LAST:
-                case domUtil_1.FindType.FIND_ANY:
-                case domUtil_1.FindType.FIND_ALL:
-                    formatted.findType = FindAction_1.findTypesToFormattedType[find.findType];
-                    formatted.selector = find.findTarget;
-                    break;
-                case domUtil_1.FindType.FIND_ONE:
-                    formatted.selector = find.findTarget.selector;
-                    break;
-                default:
-                    throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
+        let assertionValue;
+        let assertionArguments = {};
+        if (args.length > 0) {
+            const firstArg = args[0];
+            if (typeof firstArg === 'object' && firstArg !== undefined) {
+                if ('onFailure' in firstArg || 'observationScope' in firstArg) {
+                    assertionArguments = firstArg;
+                    if (name === 'assert_present' || name === 'assert_not_present') {
+                        assertionValue = undefined;
+                    }
+                    else {
+                        assertionValue = args[1];
+                    }
+                }
+                else {
+                    assertionValue = firstArg;
+                    if (args[1] && typeof args[1] === 'object') {
+                        assertionArguments = args[1];
+                    }
+                }
+            }
+            else {
+                assertionValue = firstArg;
+                if (args[1] && typeof args[1] === 'object') {
+                    assertionArguments = args[1];
+                }
             }
         }
-        formatted.assertArguments = {
-            onFailure: this.onFailure,
-            observationScope: this.observationScope,
-        };
-        return formatted;
-    }
-    getFormattedStep(_fullLocatorsOn) {
-        const result = {};
-        result[this.getStepName()] = { ...this.annotationsAsYml() };
-        const formatted = result[this.getStepName()];
-        if (this.extractAction) {
-            formatted.attribute = this.extractAction.extractionAttribute;
-            formatted.extractType =
-                ExtractAction_1.ExtractAction.mablscriptToYamlType[this.extractAction.extractionType];
-        }
-        if (this.assertionType !== 'assert_present' &&
-            this.assertionType !== 'assert_not_present') {
-            formatted.assertionValue = this.assertAttribute;
+        let conditionAction;
+        if (name === 'assert_present') {
+            conditionAction = new ConditionAction_1.ConditionAction('evaluate_presence', ['present']);
         }
-        const targetDescriptor = this.primaryAction.toDescriptor();
-        if ((0, GetVariableDescriptor_1.isGetVariableDescriptor)(targetDescriptor)) {
-            formatted.target = (0, GetVariableDescriptor_1.convertGetVariableDescriptorToYaml)(targetDescriptor);
+        else if (name === 'assert_not_present') {
+            conditionAction = new ConditionAction_1.ConditionAction('evaluate_presence', [
+                'not_present',
+            ]);
         }
         else {
-            formatted.target = targetDescriptor;
-        }
-        formatted.assertArguments = {
-            onFailure: this.onFailure,
-            observationScope: this.observationScope,
-        };
-        if (this.stepId()) {
-            formatted.id = this.stepId();
-        }
-        return result;
-    }
-    getNewAssertionStep() {
-        const yamlified = (0, importer_1.yamlifyTheLoadedSteps)([this]);
-        const reloadedSteps = (0, importer_1.loadYamlSteps)(yamlified);
-        const result = reloadedSteps[0];
-        if (this.stepSourceIndexInFlow !== undefined) {
-            result.setStepSourceIndexInFlow(this.stepSourceIndexInFlow);
-        }
-        this.actions.forEach((_oldAction, actionIndex) => {
-            result.actions[actionIndex].setActionSourceIndexInStep(actionIndex);
-        });
-        if (this.actionSourceIndexInStep !== undefined) {
-            result.setActionSourceIndexInStep(this.actionSourceIndexInStep);
+            const conditionType = ConditionDescriptor_1.AssertionStepNameToField[v2StepName];
+            if (!conditionType) {
+                throw new Error(`Unknown assertion type: ${v2StepName}`);
+            }
+            conditionAction = new ConditionAction_1.ConditionAction('evaluate_condition', [
+                conditionType,
+                assertionValue || '',
+            ]);
         }
+        newActions.push(conditionAction);
+        const descriptor = (0, AssertStep_1.buildAssertStepDescriptor)(v2StepName, [assertionArguments], newActions);
+        const result = new AssertStep_1.AssertStep(v2StepName, [assertionArguments], newActions, descriptor);
         return result;
     }
-    static fromYaml(stepName, _stepArgs) {
-        return new MablStep_1.MablStep(stepName, [], [], 'assert');
-    }
 }
-exports.AssertStepOld = AssertStepOld;
-AssertStepOld.mablScriptStepNames = Object.keys(oldToNewAssertionTypes);
-AssertStepOld.yamlMablScriptNames = [];
+exports.AssertStepOldConverter = AssertStepOldConverter;

package/mablscript/steps/AwaitTabStep.js

@@ -3,14 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AwaitTabStep = void 0;
 exports.hasCustomFindOptions = hasCustomFindOptions;
 const domUtil_1 = require("../../domUtil");
-const MablStep_1 = require("../MablStep");
-class AwaitTabStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'await_tab');
-        this.tab = this.getActionArgs()[0];
+const MablAction_1 = require("../MablAction");
+const MablStepV2_1 = require("../MablStepV2");
+const mablscriptFind_1 = require("../../mablscriptFind");
+class AwaitTabStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(AwaitTabStep.stepName, descriptor, AwaitTabStep.actionCode);
+        this.tab = descriptor.tab;
     }
     getStepName() {
-        return 'AwaitTab';
+        return AwaitTabStep.stepName;
     }
     toStepDescriptor() {
         return {
@@ -19,13 +21,32 @@ class AwaitTabStep extends MablStep_1.MablStep {
         };
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new AwaitTabStep('await_tab', [stepArgs.tab], []);
+        const stepDescriptor = {
+            actionCode: AwaitTabStep.actionCode,
+            tab: stepArgs.tab,
+        };
+        const step = new AwaitTabStep(stepDescriptor);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(args, actions) {
+        const stepDescriptor = {
+            actionCode: AwaitTabStep.actionCode,
+            tab: args[0],
+        };
+        const step = new AwaitTabStep(stepDescriptor);
+        step.actions = actions;
+        return step;
+    }
     toMablscript() {
         return `await_tab(${AwaitTabStep.getMablscriptSelectorFromTabFindAction(this.tab)})`;
     }
+    getInputVariables() {
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.tab);
+    }
+    stepDescription() {
+        return `Wait for ${(0, mablscriptFind_1.humanizeTabSelector)(this.tab)}`;
+    }
     static hasCustomFindOptions(tab) {
         return Object.keys(tab.configuration?.propertyPreferences ?? {}).length > 0;
     }
@@ -61,8 +82,10 @@ class AwaitTabStep extends MablStep_1.MablStep {
     }
 }
 exports.AwaitTabStep = AwaitTabStep;
-AwaitTabStep.mablScriptStepNames = ['await_tab'];
-AwaitTabStep.yamlMablScriptNames = ['AwaitTab'];
+AwaitTabStep.stepName = 'AwaitTab';
+AwaitTabStep.actionCode = 'await_tab';
+AwaitTabStep.mablScriptStepNames = [AwaitTabStep.actionCode];
+AwaitTabStep.yamlMablScriptNames = [AwaitTabStep.stepName];
 function hasCustomFindOptions(tab) {
     return AwaitTabStep.hasCustomFindOptions(tab);
 }

package/mablscript/steps/AwaitUploadsStep.js

@@ -1,26 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AwaitUploadsStep = void 0;
-const MablStep_1 = require("../MablStep");
-class AwaitUploadsStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'await_uploads');
+const MablStepV2_1 = require("../MablStepV2");
+class AwaitUploadsStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(AwaitUploadsStep.stepName, descriptor, AwaitUploadsStep.actionCode);
     }
     getStepName() {
-        return 'AwaitUploads';
+        return AwaitUploadsStep.stepName;
     }
     toStepDescriptor() {
         return { actionCode: this.actionCode };
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new AwaitUploadsStep('await_uploads', [], []);
+        const stepDescriptor = {
+            actionCode: AwaitUploadsStep.actionCode,
+        };
+        const step = new AwaitUploadsStep(stepDescriptor);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(_args, _actions) {
+        const stepDescriptor = {
+            actionCode: AwaitUploadsStep.actionCode,
+        };
+        const step = new AwaitUploadsStep(stepDescriptor);
+        step.actions = _actions;
+        return step;
+    }
     toMablscript() {
         return `await_uploads()`;
     }
+    stepDescription() {
+        return 'Wait for uploads to complete';
+    }
 }
 exports.AwaitUploadsStep = AwaitUploadsStep;
-AwaitUploadsStep.mablScriptStepNames = ['await_uploads'];
-AwaitUploadsStep.yamlMablScriptNames = ['AwaitUploads'];
+AwaitUploadsStep.stepName = 'AwaitUploads';
+AwaitUploadsStep.actionCode = 'await_uploads';
+AwaitUploadsStep.mablScriptStepNames = [AwaitUploadsStep.actionCode];
+AwaitUploadsStep.yamlMablScriptNames = [AwaitUploadsStep.stepName];

package/mablscript/steps/ClearCookiesStep.js

@@ -1,26 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClearCookiesStep = void 0;
-const MablStep_1 = require("../MablStep");
-class ClearCookiesStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'clear_cookies');
+const MablStepV2_1 = require("../MablStepV2");
+class ClearCookiesStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(ClearCookiesStep.stepName, descriptor, ClearCookiesStep.actionCode);
     }
     getStepName() {
-        return 'ClearCookies';
+        return ClearCookiesStep.stepName;
     }
     toStepDescriptor() {
         return { actionCode: this.actionCode };
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new ClearCookiesStep('clear_cookies', [], []);
+        const stepDescriptor = {
+            actionCode: ClearCookiesStep.actionCode,
+        };
+        const step = new ClearCookiesStep(stepDescriptor);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(_args, _actions) {
+        const stepDescriptor = {
+            actionCode: ClearCookiesStep.actionCode,
+        };
+        const step = new ClearCookiesStep(stepDescriptor);
+        step.actions = _actions;
+        return step;
+    }
     toMablscript() {
         return `clear_cookies()`;
     }
+    stepDescription() {
+        return 'Clear cookies from the current domain';
+    }
 }
 exports.ClearCookiesStep = ClearCookiesStep;
-ClearCookiesStep.mablScriptStepNames = ['clear_cookies'];
-ClearCookiesStep.yamlMablScriptNames = ['ClearCookies'];
+ClearCookiesStep.stepName = 'ClearCookies';
+ClearCookiesStep.actionCode = 'clear_cookies';
+ClearCookiesStep.mablScriptStepNames = [ClearCookiesStep.actionCode];
+ClearCookiesStep.yamlMablScriptNames = [ClearCookiesStep.stepName];

package/mablscript/steps/ClickAndHoldStep.js

@@ -6,70 +6,70 @@ const domUtil_1 = require("../../domUtil");
 const ActionsUtils_1 = require("./ActionsUtils");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class ClickAndHoldStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'click_and_hold');
-        this.findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(this.actions);
-        this.clickArgs = this.parseArgs(args) ?? { isHtml5: false };
+    constructor(descriptor, findAction) {
+        super(ClickAndHoldStep.stepName, descriptor, ClickAndHoldStep.actionCode, findAction);
+        this.clickArgs = { isHtml5: descriptor.isHtml5 };
     }
-    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.`);
-        }
-        if (!isClickAndHoldArgs(args[0])) {
-            throw new Error(`Invalid argument passed to ${this.getStepName()} step.`);
-        }
-        return args[0];
+        return {
+            isHtml5: args[0].isHtml5,
+        };
     }
     getStepName() {
-        return 'ClickAndHold';
+        return ClickAndHoldStep.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,
-                    isHtml5: this.clickArgs.isHtml5,
-                    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}`);
-        }
+        return buildStepDescriptor(this.findAction, this.clickArgs);
     }
-    getFormattedStep(_fullLocatorsOn) {
-        const step = {
-            ClickAndHold: {
-                ...super.annotationsAsYml(),
-                ...this.findAction.toYaml(),
-            },
-        };
-        if (this.stepId()) {
-            step.ClickAndHold.id = this.stepId();
-        }
-        return step;
+    getInputVariables() {
+        return this.findAction.getInputVariables();
+    }
+    stepDescription() {
+        const elementDescription = this.humanizeFind();
+        return `Click and hold ${elementDescription}`;
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new ClickAndHoldStep('click_and_hold', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+        const clickArgs = { isHtml5: false };
+        const stepDescriptor = buildStepDescriptor(findAction, clickArgs);
+        const step = new ClickAndHoldStep(stepDescriptor, findAction);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(args, actions) {
+        const findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(actions);
+        const clickArgs = ClickAndHoldStep.parseArgs(args) ?? { isHtml5: false };
+        const stepDescriptor = buildStepDescriptor(findAction, clickArgs);
+        const step = new ClickAndHoldStep(stepDescriptor, findAction);
+        step.actions = actions;
+        return step;
+    }
     toMablscript() {
         return `${this.findAction.toMablscript()}.click_and_hold({isHtml5:${this.clickArgs.isHtml5}})`;
     }
-    getInputVariables() {
-        return this.findAction.getInputVariables();
-    }
 }
 exports.ClickAndHoldStep = ClickAndHoldStep;
-ClickAndHoldStep.mablScriptStepNames = ['click_and_hold'];
-ClickAndHoldStep.yamlMablScriptNames = ['ClickAndHold'];
-function isClickAndHoldArgs(value) {
-    return value.isHtml5 !== undefined;
+ClickAndHoldStep.stepName = 'Click and Hold';
+ClickAndHoldStep.actionCode = 'click_and_hold';
+ClickAndHoldStep.mablScriptStepNames = [ClickAndHoldStep.actionCode];
+ClickAndHoldStep.yamlMablScriptNames = [ClickAndHoldStep.stepName];
+function buildStepDescriptor(findAction, clickArgs) {
+    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: ClickAndHoldStep.actionCode,
+                isHtml5: clickArgs.isHtml5,
+            };
+        default:
+            throw new Error(`Error generating step descriptor for ${ClickAndHoldStep.stepName}: Unexpected find type ${find.findType}`);
+    }
 }

package/mablscript/steps/ClickStep.js

@@ -6,53 +6,58 @@ const domUtil_1 = require("../../domUtil");
 const ActionsUtils_1 = require("./ActionsUtils");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class ClickStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'click');
-        this.findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(this.actions);
+    constructor(descriptor, findAction) {
+        super(ClickStep.stepName, descriptor, ClickStep.actionCode, findAction);
     }
     getStepName() {
-        return 'Click';
+        return ClickStep.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 = {
-            Click: {
-                ...super.annotationsAsYml(),
-                ...this.findAction.toYaml(),
-            },
-        };
-        if (this.stepId()) {
-            step.Click.id = this.stepId();
-        }
-        return step;
+        return buildStepDescriptor(this.findAction);
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new ClickStep('click', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+        const stepDescriptor = buildStepDescriptor(findAction);
+        const step = new ClickStep(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 ClickStep(stepDescriptor, findAction);
+        step.actions = actions;
+        return step;
+    }
     toMablscript() {
         return `${this.findAction.toMablscript()}.click()`;
     }
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
+    stepDescription() {
+        const elementDescription = this.humanizeFind();
+        return `Click on ${elementDescription}`;
+    }
 }
 exports.ClickStep = ClickStep;
-ClickStep.mablScriptStepNames = ['click'];
-ClickStep.yamlMablScriptNames = ['Click'];
+ClickStep.stepName = 'Click';
+ClickStep.actionCode = 'click';
+ClickStep.mablScriptStepNames = [ClickStep.actionCode];
+ClickStep.yamlMablScriptNames = [ClickStep.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: ClickStep.actionCode,
+            };
+        default:
+            throw new Error(`Error generating step descriptor for ${ClickStep.stepName}: Unexpected find type ${find.findType}`);
+    }
+}