@mablhq/mabl-cli 2.72.0 → 2.72.3

package/mablscript/steps/AssertStepOld.js

@@ -1,89 +1,159 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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_present: 'AssertPresent',
-    assert_not_present: 'AssertNotPresent',
-    assert_does_not_equal: 'AssertDoesNotEqual',
+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',
+    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_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 AssertStepOldConverter {
-    static convert(name, args, actions) {
-        const v2StepName = exports.oldToV2StepNameMap[name];
-        if (!v2StepName) {
-            throw new Error(`Unknown old assertion type: ${name}`);
+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;
         }
-        const newActions = [];
-        newActions.push(actions[0]);
-        if (actions[1]) {
-            newActions.push(actions[1]);
+        else if (args.length === 2) {
+            this.onFailure = args[1].onFailure;
+            this.observationScope = args[1].observationScope;
         }
-        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];
-                }
-            }
+    }
+    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');
         }
-        let conditionAction;
-        if (name === 'assert_present') {
-            conditionAction = new ConditionAction_1.ConditionAction('evaluate_presence', ['present']);
+    }
+    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;
         }
-        else if (name === 'assert_not_present') {
-            conditionAction = new ConditionAction_1.ConditionAction('evaluate_presence', [
-                'not_present',
-            ]);
+        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 {
-            const conditionType = ConditionDescriptor_1.AssertionStepNameToField[v2StepName];
-            if (!conditionType) {
-                throw new Error(`Unknown assertion type: ${v2StepName}`);
+            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}`);
             }
-            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);
+        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;
+        }
+        const targetDescriptor = this.primaryAction.toDescriptor();
+        if ((0, GetVariableDescriptor_1.isGetVariableDescriptor)(targetDescriptor)) {
+            formatted.target = (0, GetVariableDescriptor_1.convertGetVariableDescriptorToYaml)(targetDescriptor);
+        }
+        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);
+        }
+        return result;
+    }
+    static fromYaml(stepName, _stepArgs) {
+        return new MablStep_1.MablStep(stepName, [], [], 'assert');
+    }
 }
-exports.AssertStepOldConverter = AssertStepOldConverter;
+exports.AssertStepOld = AssertStepOld;
+AssertStepOld.mablScriptStepNames = Object.keys(oldToNewAssertionTypes);
+AssertStepOld.yamlMablScriptNames = [];

package/mablscript/steps/AwaitTabStep.js

@@ -3,16 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AwaitTabStep = void 0;
 exports.hasCustomFindOptions = hasCustomFindOptions;
 const domUtil_1 = require("../../domUtil");
-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;
+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];
     }
     getStepName() {
-        return AwaitTabStep.stepName;
+        return 'AwaitTab';
     }
     toStepDescriptor() {
         return {
@@ -21,30 +19,13 @@ class AwaitTabStep extends MablStepV2_1.MablStepV2 {
         };
     }
     static fromYaml(_stepName, stepArgs) {
-        const stepDescriptor = {
-            actionCode: AwaitTabStep.actionCode,
-            tab: stepArgs.tab,
-        };
-        const step = new AwaitTabStep(stepDescriptor);
+        const step = new AwaitTabStep('await_tab', [stepArgs.tab], []);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(args, _actions) {
-        const stepDescriptor = {
-            actionCode: AwaitTabStep.actionCode,
-            tab: args[0],
-        };
-        return new AwaitTabStep(stepDescriptor);
-    }
     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;
     }
@@ -80,10 +61,8 @@ class AwaitTabStep extends MablStepV2_1.MablStepV2 {
     }
 }
 exports.AwaitTabStep = AwaitTabStep;
-AwaitTabStep.stepName = 'AwaitTab';
-AwaitTabStep.actionCode = 'await_tab';
-AwaitTabStep.mablScriptStepNames = [AwaitTabStep.actionCode];
-AwaitTabStep.yamlMablScriptNames = [AwaitTabStep.stepName];
+AwaitTabStep.mablScriptStepNames = ['await_tab'];
+AwaitTabStep.yamlMablScriptNames = ['AwaitTab'];
 function hasCustomFindOptions(tab) {
     return AwaitTabStep.hasCustomFindOptions(tab);
 }

package/mablscript/steps/AwaitUploadsStep.js

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

package/mablscript/steps/ClearCookiesStep.js

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

package/mablscript/steps/ClickAndHoldStep.js

@@ -6,68 +6,70 @@ const domUtil_1 = require("../../domUtil");
 const ActionsUtils_1 = require("./ActionsUtils");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class ClickAndHoldStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(descriptor, findAction) {
-        super(ClickAndHoldStep.stepName, descriptor, ClickAndHoldStep.actionCode, findAction);
-        this.clickArgs = { isHtml5: descriptor.isHtml5 };
+    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 };
     }
-    static parseArgs(args) {
+    parseArgs(args) {
         if (args.length === 0) {
             return undefined;
         }
-        return {
-            isHtml5: args[0].isHtml5,
-        };
+        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];
     }
     getStepName() {
-        return ClickAndHoldStep.stepName;
+        return 'ClickAndHold';
     }
     toStepDescriptor() {
-        return buildStepDescriptor(this.findAction, this.clickArgs);
-    }
-    getInputVariables() {
-        return this.findAction.getInputVariables();
+        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}`);
+        }
     }
-    stepDescription() {
-        const elementDescription = this.humanizeFind();
-        return `Click and hold ${elementDescription}`;
+    getFormattedStep(_fullLocatorsOn) {
+        const step = {
+            ClickAndHold: {
+                ...super.annotationsAsYml(),
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step.ClickAndHold.id = this.stepId();
+        }
+        return step;
     }
     static fromYaml(_stepName, stepArgs) {
-        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
-        const clickArgs = { isHtml5: false };
-        const stepDescriptor = buildStepDescriptor(findAction, clickArgs);
-        const step = new ClickAndHoldStep(stepDescriptor, findAction);
+        const step = new ClickAndHoldStep('click_and_hold', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
         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);
-        return new ClickAndHoldStep(stepDescriptor, findAction);
-    }
     toMablscript() {
         return `${this.findAction.toMablscript()}.click_and_hold({isHtml5:${this.clickArgs.isHtml5}})`;
     }
+    getInputVariables() {
+        return this.findAction.getInputVariables();
+    }
 }
 exports.ClickAndHoldStep = ClickAndHoldStep;
-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}`);
-    }
+ClickAndHoldStep.mablScriptStepNames = ['click_and_hold'];
+ClickAndHoldStep.yamlMablScriptNames = ['ClickAndHold'];
+function isClickAndHoldArgs(value) {
+    return value.isHtml5 !== undefined;
 }

package/mablscript/steps/ClickStep.js

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