@mablhq/mabl-cli 2.72.0 → 2.72.3

package/mablscript/steps/EvaluateFlowStep.js

@@ -3,46 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvaluateFlowStep = exports.EVALUATE_FLOW_STEP_NAME = void 0;
 exports.isEvaluateFlowStep = isEvaluateFlowStep;
 const domUtil_1 = require("../../domUtil");
-const MablAction_1 = require("../MablAction");
-const MablStepV2_1 = require("../MablStepV2");
+const MablStep_1 = require("../MablStep");
 exports.EVALUATE_FLOW_STEP_NAME = 'EvaluateFlow';
-class EvaluateFlowStep extends MablStepV2_1.MablStepV2 {
-    constructor(descriptor) {
-        super(EvaluateFlowStep.stepName, descriptor, EvaluateFlowStep.actionCode);
-        this.flowDescriptor = descriptor.flow;
-        this.config = descriptor.config;
+class EvaluateFlowStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'evaluate_flow');
+        if (args.length < 1 || args.length > 2) {
+            throw new Error('EvaluateFlowStep expects 1 or 2 arguments');
+        }
+        this.flowDescriptor = this.getActionArgs()[0];
+        if (args.length === 2) {
+            this.config = this.getActionArgs()[1];
+        }
     }
     getStepName() {
-        return EvaluateFlowStep.stepName;
+        return exports.EVALUATE_FLOW_STEP_NAME;
     }
     toStepDescriptor() {
         return {
-            actionCode: EvaluateFlowStep.actionCode,
-            flow: { invariant_id: this.flowDescriptor.invariant_id },
+            descriptor: this.flowDescriptor,
             config: this.config,
+            actionCode: this.actionCode,
         };
     }
-    stepDescription() {
-        return `Evaluate Flow "${this.flowDescriptor.invariant_id}"`;
-    }
     static fromYaml(_stepName, stepArgs) {
-        const { flow, config } = stepArgs;
-        const step = new EvaluateFlowStep({ flow, config });
+        const { descriptor, config } = stepArgs;
+        const step = new EvaluateFlowStep(EvaluateFlowStep.mablScriptStepNames[0], [descriptor, config], []);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(args, _actions) {
-        if (args.length < 1 || args.length > 2) {
-            throw new Error(`EvaluateFlowStep.fromLegacyMablscript expects 1 or 2 arguments but received ${args.length}`);
-        }
-        const flowDescriptor = args[0];
-        const config = args.length === 2 ? args[1] : undefined;
-        const stepDescriptor = {
-            flow: flowDescriptor,
-            config,
-        };
-        return new EvaluateFlowStep(stepDescriptor);
-    }
     toMablscript() {
         const flowReference = (0, domUtil_1.buildStepArgumentString)({
             params: { ...this.flowDescriptor },
@@ -53,20 +42,10 @@ class EvaluateFlowStep extends MablStepV2_1.MablStepV2 {
             : '';
         return `${EvaluateFlowStep.mablScriptStepNames[0]}(${flowReference}${flowConfig})`;
     }
-    getInputVariables() {
-        return (0, MablAction_1.distinctStrings)([
-            ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.flowDescriptor),
-            ...(this.config
-                ? MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.config)
-                : []),
-        ]);
-    }
 }
 exports.EvaluateFlowStep = EvaluateFlowStep;
-EvaluateFlowStep.stepName = exports.EVALUATE_FLOW_STEP_NAME;
-EvaluateFlowStep.actionCode = 'evaluate_flow';
-EvaluateFlowStep.mablScriptStepNames = [EvaluateFlowStep.actionCode];
-EvaluateFlowStep.yamlMablScriptNames = [EvaluateFlowStep.stepName];
+EvaluateFlowStep.mablScriptStepNames = ['evaluate_flow'];
+EvaluateFlowStep.yamlMablScriptNames = [exports.EVALUATE_FLOW_STEP_NAME];
 function isEvaluateFlowStep(step) {
     return step?.getStepName() === exports.EVALUATE_FLOW_STEP_NAME;
 }

package/mablscript/steps/EvaluateJavaScriptStep.js

@@ -2,45 +2,47 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvaluateJavaScriptStep = void 0;
 exports.isEvaluateJavaScriptStep = isEvaluateJavaScriptStep;
-const MablStepV2_1 = require("../MablStepV2");
+const MablStep_1 = require("../MablStep");
 const JavaScriptAction_1 = require("../actions/JavaScriptAction");
 const STEP_NAME = 'EvaluateJavaScript';
-class EvaluateJavaScriptStep extends MablStepV2_1.MablStepV2 {
-    constructor(descriptor) {
-        super(EvaluateJavaScriptStep.stepName, descriptor, EvaluateJavaScriptStep.actionCode);
-        this.evaluateJsAction = JavaScriptAction_1.JavaScriptAction.fromDescriptor(descriptor);
+class EvaluateJavaScriptStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions || [], 'evaluate_js');
+        this.evaluateJsAction = new JavaScriptAction_1.JavaScriptAction(JavaScriptAction_1.JavaScriptAction.mablscriptName, args);
     }
     getStepName() {
-        return EvaluateJavaScriptStep.stepName;
+        return STEP_NAME;
     }
     toStepDescriptor() {
         return this.evaluateJsAction.toDescriptor();
     }
+    getFormattedStep() {
+        const step = {
+            [STEP_NAME]: {
+                ...super.annotationsAsYml(),
+                ...this.evaluateJsAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step[STEP_NAME].id = this.stepId();
+        }
+        return step;
+    }
     static fromYaml(_stepName, stepArgs) {
         const evaluateJsAction = JavaScriptAction_1.JavaScriptAction.fromYaml(stepArgs);
-        const stepDescriptor = evaluateJsAction.toDescriptor();
-        const step = new EvaluateJavaScriptStep(stepDescriptor);
+        const step = new EvaluateJavaScriptStep(evaluateJsAction.name, evaluateJsAction.args);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(args, _actions) {
-        const evaluateJsAction = new JavaScriptAction_1.JavaScriptAction(JavaScriptAction_1.JavaScriptAction.mablscriptName, args);
-        const stepDescriptor = evaluateJsAction.toDescriptor();
-        return new EvaluateJavaScriptStep(stepDescriptor);
-    }
     toMablscript() {
         return this.evaluateJsAction.toMablscript();
     }
     getInputVariables() {
         return this.evaluateJsAction.getInputVariables();
     }
-    stepDescription() {
-        return 'Evaluate JavaScript';
-    }
 }
 exports.EvaluateJavaScriptStep = EvaluateJavaScriptStep;
 EvaluateJavaScriptStep.stepName = STEP_NAME;
-EvaluateJavaScriptStep.actionCode = 'evaluate_js';
 EvaluateJavaScriptStep.mablScriptStepNames = [JavaScriptAction_1.JavaScriptAction.mablscriptName];
 EvaluateJavaScriptStep.yamlMablScriptNames = [STEP_NAME];
 function isEvaluateJavaScriptStep(value) {

package/mablscript/steps/HoverStep.js

@@ -4,58 +4,60 @@ exports.HoverStep = void 0;
 const FindAction_1 = require("../actions/FindAction");
 const domUtil_1 = require("../../domUtil");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
-const ActionsUtils_1 = require("./ActionsUtils");
 class HoverStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(descriptor, findAction) {
-        super(HoverStep.stepName, descriptor, HoverStep.actionCode, findAction);
+    constructor(name, args, actions) {
+        super(name, args, actions, 'hover');
+        this.validate();
+        this.findAction = this.actions[0];
+    }
+    validate() {
+        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
+            throw new Error('Hover steps should have exactly on sub action and it should be a find');
+        }
     }
     getStepName() {
-        return HoverStep.stepName;
+        return 'Hover';
     }
     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 = {
+            Hover: {
+                ...super.annotationsAsYml(),
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step.Hover.id = this.stepId();
+        }
+        return step;
     }
     static fromYaml(_stepName, stepArgs) {
-        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
-        const stepDescriptor = buildStepDescriptor(findAction);
-        const step = new HoverStep(stepDescriptor, findAction);
+        const step = new HoverStep('hover', [], [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 HoverStep(stepDescriptor, findAction);
-    }
     toMablscript() {
         return `${this.findAction.toMablscript()}.hover()`;
     }
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
-    stepDescription() {
-        const elementDescription = this.humanizeFind();
-        return `Hover over ${elementDescription}`;
-    }
 }
 exports.HoverStep = HoverStep;
-HoverStep.stepName = 'Hover';
-HoverStep.actionCode = 'hover';
-HoverStep.mablScriptStepNames = [HoverStep.actionCode];
-HoverStep.yamlMablScriptNames = [HoverStep.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: HoverStep.actionCode,
-            };
-        default:
-            throw new Error(`Error generating step descriptor for ${HoverStep.stepName}: Unexpected find type ${find.findType}`);
-    }
-}
+HoverStep.mablScriptStepNames = ['hover'];
+HoverStep.yamlMablScriptNames = ['Hover'];

package/mablscript/steps/IfConditionStep.js

@@ -7,7 +7,7 @@ const GetVariableValue_1 = require("../actions/GetVariableValue");
 const AssertStep_1 = require("./AssertStep");
 const FindAction_1 = require("../actions/FindAction");
 const MablAction_1 = require("../MablAction");
-const MablStepV2_1 = require("../MablStepV2");
+const MablStep_1 = require("../MablStep");
 const ExtractAction_1 = require("../actions/ExtractAction");
 const domUtil_1 = require("../../domUtil");
 const JavaScriptAction_1 = require("../actions/JavaScriptAction");
@@ -15,21 +15,9 @@ const GetUrlAction_1 = require("../actions/GetUrlAction");
 const ConditionDescriptor_1 = require("../types/ConditionDescriptor");
 const GetViewportAction_1 = require("../actions/GetViewportAction");
 const MobileFindAction_1 = require("../mobile/steps/actions/MobileFindAction");
-const CountAction_1 = require("../actions/CountAction");
-class IfConditionStep extends MablStepV2_1.MablStepV2 {
-    constructor(stepName, actionCode, descriptor, stepActions) {
-        super(stepName, descriptor, actionCode);
-        this.primaryAction = stepActions.primaryAction;
-        this.conditionAction = stepActions.conditionAction;
-        this.extractAction = stepActions.extractAction;
-        this.countAction = stepActions.countAction;
-    }
-    static fromLegacyMablscript(_args, actions) {
-        const validatedActions = IfConditionStep.validateAndParseActions(actions);
-        const stepDescriptor = IfConditionStep.buildDescriptor(validatedActions);
-        return new IfConditionStep(IfConditionStep.stepName, IfConditionStep.actionCode, stepDescriptor, validatedActions);
-    }
-    static validateAndParseActions(actions) {
+class IfConditionStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'conditional_if');
         const candidatePrimaryActions = actions.filter((action) => action instanceof FindAction_1.FindAction ||
             action instanceof MobileFindAction_1.MobileFindAction ||
             action instanceof GetVariableValue_1.GetVariableValue ||
@@ -38,127 +26,106 @@ class IfConditionStep extends MablStepV2_1.MablStepV2 {
         if (candidatePrimaryActions.length > 1) {
             throw new Error(`Too many primary actions. Only one primary action is allowed of: Find, Get Url, Get Variable, or Javascript actions`);
         }
-        const conditionAction = actions.find((action) => action instanceof ConditionAction_1.ConditionAction);
-        const extractAction = actions.find((action) => action instanceof ExtractAction_1.ExtractAction);
-        const countAction = actions.find((action) => action instanceof CountAction_1.CountAction);
-        let primaryAction;
+        this.conditionAction = actions.find((action) => action instanceof ConditionAction_1.ConditionAction);
+        this.extractAction = actions.find((action) => action instanceof ExtractAction_1.ExtractAction);
         if (candidatePrimaryActions[0] === undefined) {
-            if (conditionAction !== undefined &&
-                (0, ConditionDescriptor_1.isAIPromptCondition)(conditionAction.conditionDescriptor)) {
-                primaryAction = new GetViewportAction_1.GetViewportAction();
+            if (this.conditionAction !== undefined &&
+                (0, ConditionDescriptor_1.isAIPromptCondition)(this.conditionAction.conditionDescriptor)) {
+                this.primaryAction = new GetViewportAction_1.GetViewportAction();
             }
             else {
                 throw new Error(`At least one primary action is required: Find, Get Url, Get Variable, or Javascript action.`);
             }
         }
         else {
-            primaryAction = candidatePrimaryActions[0];
+            this.primaryAction = candidatePrimaryActions[0];
         }
-        return { primaryAction, conditionAction, extractAction, countAction };
     }
-    static buildDescriptor(validatedActions) {
-        const conditionDescriptor = validatedActions.conditionAction !== undefined
-            ? validatedActions.conditionAction?.conditionDescriptor
+    getStepName() {
+        return 'If';
+    }
+    toStepDescriptor() {
+        const conditionDescriptor = this.conditionAction !== undefined
+            ? this.conditionAction?.conditionDescriptor
             : { conditionType: ConditionDescriptor_1.ConditionType.Truthy };
-        const target = validatedActions.primaryAction.toDescriptor();
-        const count = validatedActions.countAction?.countDescriptor;
-        const extract = validatedActions.extractAction?.toDescriptor();
+        const find = this.primaryAction.toDescriptor();
         return {
-            target,
-            extract,
-            condition: conditionDescriptor,
-            count,
+            find,
+            extractDescriptor: this.extractAction?.extractDescriptor,
+            conditionDescriptor,
             onFailure: AssertStep_1.OnFailure.FailImmediately,
-            descriptorToActionMap: new Map().set(target, validatedActions.primaryAction),
-            actionCode: IfConditionStep.actionCode,
+            descriptorToActionMap: new Map().set(find, this.primaryAction),
+            actionCode: this.actionCode,
         };
     }
-    getStepName() {
-        return IfConditionStep.stepName;
-    }
-    toStepDescriptor() {
-        return IfConditionStep.buildDescriptor({
-            primaryAction: this.primaryAction,
-            conditionAction: this.conditionAction,
-            extractAction: this.extractAction,
-        });
+    getFormattedStep(_fullLocatorsOn) {
+        const result = {};
+        result[this.getStepName()] = this.toYamlConditionDetails();
+        if (this.stepId()) {
+            result[this.getStepName()].id = this.stepId();
+        }
+        return result;
     }
-    static getActionsFromYamlForCondition(stepArgs) {
-        const actions = [];
-        const isNewFormat = stepArgs.target && typeof stepArgs.condition === 'object';
-        if (isNewFormat) {
-            if (stepArgs.target) {
-                if (stepArgs.target.findType) {
-                    if ((0, domUtil_1.isMobileFindDescriptor)(stepArgs.target)) {
-                        actions.push(MobileFindAction_1.MobileFindAction.fromDescriptor(stepArgs.target));
-                    }
-                    else {
-                        if (stepArgs.target.findType === domUtil_1.FindType.FIND_ONE) {
-                            actions.push(FindAction_1.FindAction.findActionFromStepArgs({
-                                selector: stepArgs.target.findTarget.selector,
-                                findOptions: stepArgs.target.findOptions,
-                            }));
-                        }
-                        else {
-                            actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs.target.findTarget));
-                        }
-                    }
-                }
-                else if (stepArgs.target.kind === 'GetVariable') {
-                    actions.push(GetVariableValue_1.GetVariableValue.buildAction(stepArgs.target.variable));
-                }
-                else if (stepArgs.target.javaScript) {
-                    actions.push(JavaScriptAction_1.JavaScriptAction.fromDescriptor(stepArgs.target));
-                }
+    toYamlConditionDetails() {
+        const details = {
+            ...super.annotationsAsYml(),
+        };
+        if (this.conditionAction) {
+            details.condition =
+                ConditionDescriptor_1.AssertionConditionFieldToStepName[(0, ConditionDescriptor_1.getAssertionConditionFieldFromDescriptor)(this.conditionAction.conditionDescriptor)];
+            details.conditionValue = (0, ConditionDescriptor_1.getOptionalComparatorValue)(this.conditionAction.conditionDescriptor);
+            const optionalConditionOptions = (0, ConditionDescriptor_1.getOptionalConditionOptions)(this.conditionAction.conditionDescriptor);
+            details.conditionOptions = this.conditionAction.hasOptionsAtInstantiation
+                ? optionalConditionOptions
+                : undefined;
+            if (this.conditionAction.conditionDescriptor.conditionType ===
+                ConditionDescriptor_1.ConditionType.AIPrompt) {
+                details.aiPrompt = {
+                    userPrompt: this.conditionAction.conditionDescriptor.userPrompt,
+                    metaPrompt: this.conditionAction.conditionDescriptor.metaPrompt,
+                    criteria: this.conditionAction.conditionDescriptor.criteria,
+                };
             }
-            if (stepArgs.extract) {
-                if (stepArgs.extract.extractType === 'extract_attribute') {
-                    const extractArgs = stepArgs.extract.metadata
-                        ? [stepArgs.extract.attributeName, stepArgs.extract.metadata]
-                        : [stepArgs.extract.attributeName];
-                    actions.push(new ExtractAction_1.ExtractAction('extract_attribute', extractArgs));
-                }
+        }
+        if (this.primaryAction instanceof GetVariableValue_1.GetVariableValue) {
+            details.variableName = this.substituteMablscriptVariable(this.primaryAction.variable);
+        }
+        if (this.primaryAction instanceof JavaScriptAction_1.JavaScriptAction) {
+            const jsYaml = JavaScriptAction_1.JavaScriptAction.toYamlFromJavaScriptDescriptor(this.primaryAction.javaScript);
+            if (jsYaml.snippet) {
+                details.snippet = jsYaml.snippet;
+                details.snippet.parameterOverrides = jsYaml.parameterOverrides;
             }
-            if (stepArgs.condition) {
-                if (stepArgs.condition.conditionType === 'comparison') {
-                    const comparisonType = stepArgs.condition
-                        .comparisonType;
-                    const stepName = ConditionDescriptor_1.AssertionConditionFieldToStepName[comparisonType];
-                    const conditionType = ConditionDescriptor_1.AssertionStepNameToField[stepName];
-                    actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType(conditionType), [
-                        comparisonType,
-                        stepArgs.condition.comparatorValue,
-                        {
-                            caseInsensitive: stepArgs.condition.caseInsensitive,
-                        },
-                    ]));
-                }
-                else if (stepArgs.condition.conditionType === 'presence') {
-                    const conditionType = stepArgs.condition.presenceType === 'present'
-                        ? 'present'
-                        : 'not_present';
-                    actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType(conditionType), [conditionType]));
-                }
-                else if (stepArgs.condition.conditionType === 'truthy') {
-                }
-                else if (stepArgs.condition.conditionType === 'ai_prompt') {
-                    actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType('ai_prompt'), [
-                        stepArgs.condition.userPrompt,
-                        {
-                            metaPrompt: stepArgs.condition.metaPrompt,
-                            criteria: stepArgs.condition.criteria,
-                        },
-                    ]));
-                }
+            else {
+                details.snippet = jsYaml;
             }
-            return actions;
         }
+        if (this.extractAction) {
+            details.attribute = this.extractAction.extractionAttribute;
+        }
+        if (this.primaryAction instanceof FindAction_1.FindAction ||
+            this.primaryAction instanceof MobileFindAction_1.MobileFindAction) {
+            const find = this.primaryAction.toDescriptor();
+            details.find = find;
+        }
+        return details;
+    }
+    static getActionsFromYamlForCondition(stepArgs) {
+        const actions = [];
         if (stepArgs.find) {
             if ((0, domUtil_1.isMobileFindDescriptor)(stepArgs.find)) {
                 actions.push(MobileFindAction_1.MobileFindAction.fromDescriptor(stepArgs.find));
             }
             else {
-                actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs));
+                if (stepArgs.find.findType === domUtil_1.FindType.FIND_ONE) {
+                    actions.push(FindAction_1.FindAction.findActionFromStepArgs({
+                        selector: stepArgs.find.findTarget.selector,
+                        findOptions: stepArgs.find.findOptions,
+                    }));
+                }
+                else {
+                    actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs.find.findTarget));
+                }
             }
         }
         else if (stepArgs.selector) {
@@ -181,14 +148,15 @@ class IfConditionStep extends MablStepV2_1.MablStepV2 {
             actions.push(new ExtractAction_1.ExtractAction('extract_attribute', extractArgs));
         }
         if (stepArgs.variableName) {
-            actions.push(GetVariableValue_1.GetVariableValue.buildAction(stepArgs.variableName));
+            actions.push(new GetVariableValue_1.GetVariableValue('get_variable_value', [
+                `{{@${stepArgs.variableName}}}`,
+            ]));
         }
         if (stepArgs.snippet) {
             actions.push(JavaScriptAction_1.JavaScriptAction.fromYaml(stepArgs.snippet));
         }
         if (stepArgs.condition) {
-            const conditionStepName = stepArgs.condition;
-            const conditionType = ConditionDescriptor_1.AssertionStepNameToField[conditionStepName];
+            const conditionType = ConditionDescriptor_1.AssertionStepNameToField[stepArgs.condition];
             if (conditionType === 'ai_prompt') {
                 actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType(conditionType), [
                     stepArgs.aiPrompt?.userPrompt ?? stepArgs.userPrompt,
@@ -199,7 +167,11 @@ class IfConditionStep extends MablStepV2_1.MablStepV2 {
                 ]));
             }
             else {
-                actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType(conditionType), [conditionType, stepArgs.conditionValue, stepArgs.conditionOptions]));
+                actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType(conditionType), [
+                    ConditionDescriptor_1.AssertionStepNameToField[stepArgs.condition],
+                    stepArgs.conditionValue,
+                    stepArgs.conditionOptions,
+                ]));
             }
         }
         return actions;
@@ -215,37 +187,25 @@ class IfConditionStep extends MablStepV2_1.MablStepV2 {
     }
     static fromYaml(_stepName, stepArgs) {
         const actions = IfConditionStep.getActionsFromYamlForCondition(stepArgs);
-        const validatedActions = IfConditionStep.validateAndParseActions(actions);
-        const stepDescriptor = IfConditionStep.buildDescriptor(validatedActions);
-        const step = new IfConditionStep(IfConditionStep.stepName, IfConditionStep.actionCode, stepDescriptor, validatedActions);
+        const step = new IfConditionStep('conditional_if', [], actions);
         step.setStepId(stepArgs.id);
         return step;
     }
     toMablscript() {
-        const actions = [
-            this.primaryAction,
-            this.extractAction,
-            this.conditionAction,
-        ].filter(Boolean);
-        return `${actions.reduce((mablscript, action) => `${mablscript}${action?.toMablscript()}.`, '')}conditional_if()`;
+        return `${this.actions.reduce((mablscript, action) => `${mablscript}${action.toMablscript()}.`, '')}conditional_if()`;
     }
     getInputVariables() {
-        const actions = [
-            this.primaryAction,
-            this.extractAction,
-            this.conditionAction,
-        ].filter(Boolean);
-        return (0, MablAction_1.distinctStrings)(actions.flatMap((action) => action?.getInputVariables() ?? []));
-    }
-    stepDescription() {
-        return 'IF condition';
+        return (0, MablAction_1.distinctStrings)([
+            ...this.primaryAction.getInputVariables(),
+            ...(this.conditionAction?.getInputVariables() ?? []),
+            ...(this.extractAction?.getInputVariables() ?? []),
+        ]);
     }
 }
 exports.IfConditionStep = IfConditionStep;
-IfConditionStep.stepName = 'If';
-IfConditionStep.actionCode = 'conditional_if';
-IfConditionStep.mablScriptStepNames = [IfConditionStep.actionCode];
-IfConditionStep.yamlMablScriptNames = [IfConditionStep.stepName];
+IfConditionStep.stepName = 'conditional_if';
+IfConditionStep.mablScriptStepNames = [IfConditionStep.stepName];
+IfConditionStep.yamlMablScriptNames = ['If'];
 function isIfConditionStep(value) {
     return (value?.getStepName &&
         value?.getStepName() === IfConditionStep.yamlMablScriptNames[0]);

package/mablscript/steps/NavigateStep.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NavigateStep = void 0;
-const MablStepV2_1 = require("../MablStepV2");
-const MablAction_1 = require("../MablAction");
-class NavigateStep extends MablStepV2_1.MablStepV2 {
-    constructor(descriptor) {
-        super(NavigateStep.stepName, descriptor, NavigateStep.actionCode);
-        this.navigation = descriptor.navigation;
+const MablStep_1 = require("../MablStep");
+class NavigateStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'navigate');
+        this.navigation = this.getActionArgs()[0];
     }
     getStepName() {
-        return NavigateStep.stepName;
+        return 'Navigate';
     }
     toStepDescriptor() {
         return {
@@ -18,33 +17,14 @@ class NavigateStep extends MablStepV2_1.MablStepV2 {
         };
     }
     static fromYaml(_stepName, stepArgs) {
-        const stepDescriptor = {
-            navigation: stepArgs.navigation,
-            actionCode: NavigateStep.actionCode,
-        };
-        const step = new NavigateStep(stepDescriptor);
+        const step = new NavigateStep('navigate', [stepArgs.navigation], []);
         step.setStepId(stepArgs.id);
         return step;
     }
-    static fromLegacyMablscript(args, _actions) {
-        const stepDescriptor = {
-            navigation: args[0],
-            actionCode: NavigateStep.actionCode,
-        };
-        return new NavigateStep(stepDescriptor);
-    }
     toMablscript() {
         return `navigate("${this.navigation}")`;
     }
-    getInputVariables() {
-        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.navigation);
-    }
-    stepDescription() {
-        return `Navigate to "${this.navigation}"`;
-    }
 }
 exports.NavigateStep = NavigateStep;
-NavigateStep.stepName = 'Navigate';
-NavigateStep.actionCode = 'navigate';
-NavigateStep.mablScriptStepNames = [NavigateStep.actionCode];
-NavigateStep.yamlMablScriptNames = [NavigateStep.stepName];
+NavigateStep.mablScriptStepNames = ['navigate'];
+NavigateStep.yamlMablScriptNames = ['Navigate'];