@mablhq/mabl-cli 2.70.35 → 2.72.0

package/mablscript/steps/EvaluateFlowStep.js

@@ -3,35 +3,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvaluateFlowStep = exports.EVALUATE_FLOW_STEP_NAME = void 0;
 exports.isEvaluateFlowStep = isEvaluateFlowStep;
 const domUtil_1 = require("../../domUtil");
-const MablStep_1 = require("../MablStep");
+const MablAction_1 = require("../MablAction");
+const MablStepV2_1 = require("../MablStepV2");
 exports.EVALUATE_FLOW_STEP_NAME = 'EvaluateFlow';
-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];
-        }
+class EvaluateFlowStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(EvaluateFlowStep.stepName, descriptor, EvaluateFlowStep.actionCode);
+        this.flowDescriptor = descriptor.flow;
+        this.config = descriptor.config;
     }
     getStepName() {
-        return exports.EVALUATE_FLOW_STEP_NAME;
+        return EvaluateFlowStep.stepName;
     }
     toStepDescriptor() {
         return {
-            descriptor: this.flowDescriptor,
+            actionCode: EvaluateFlowStep.actionCode,
+            flow: { invariant_id: this.flowDescriptor.invariant_id },
             config: this.config,
-            actionCode: this.actionCode,
         };
     }
+    stepDescription() {
+        return `Evaluate Flow "${this.flowDescriptor.invariant_id}"`;
+    }
     static fromYaml(_stepName, stepArgs) {
-        const { descriptor, config } = stepArgs;
-        const step = new EvaluateFlowStep(EvaluateFlowStep.mablScriptStepNames[0], [descriptor, config], []);
+        const { flow, config } = stepArgs;
+        const step = new EvaluateFlowStep({ flow, 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 },
@@ -42,10 +53,20 @@ class EvaluateFlowStep extends MablStep_1.MablStep {
             : '';
         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.mablScriptStepNames = ['evaluate_flow'];
-EvaluateFlowStep.yamlMablScriptNames = [exports.EVALUATE_FLOW_STEP_NAME];
+EvaluateFlowStep.stepName = exports.EVALUATE_FLOW_STEP_NAME;
+EvaluateFlowStep.actionCode = 'evaluate_flow';
+EvaluateFlowStep.mablScriptStepNames = [EvaluateFlowStep.actionCode];
+EvaluateFlowStep.yamlMablScriptNames = [EvaluateFlowStep.stepName];
 function isEvaluateFlowStep(step) {
     return step?.getStepName() === exports.EVALUATE_FLOW_STEP_NAME;
 }

package/mablscript/steps/EvaluateJavaScriptStep.js

@@ -2,47 +2,45 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvaluateJavaScriptStep = void 0;
 exports.isEvaluateJavaScriptStep = isEvaluateJavaScriptStep;
-const MablStep_1 = require("../MablStep");
+const MablStepV2_1 = require("../MablStepV2");
 const JavaScriptAction_1 = require("../actions/JavaScriptAction");
 const STEP_NAME = 'EvaluateJavaScript';
-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);
+class EvaluateJavaScriptStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(EvaluateJavaScriptStep.stepName, descriptor, EvaluateJavaScriptStep.actionCode);
+        this.evaluateJsAction = JavaScriptAction_1.JavaScriptAction.fromDescriptor(descriptor);
     }
     getStepName() {
-        return STEP_NAME;
+        return EvaluateJavaScriptStep.stepName;
     }
     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 step = new EvaluateJavaScriptStep(evaluateJsAction.name, evaluateJsAction.args);
+        const stepDescriptor = evaluateJsAction.toDescriptor();
+        const step = new EvaluateJavaScriptStep(stepDescriptor);
         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,60 +4,58 @@ 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(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');
-        }
+    constructor(descriptor, findAction) {
+        super(HoverStep.stepName, descriptor, HoverStep.actionCode, findAction);
     }
     getStepName() {
-        return 'Hover';
+        return HoverStep.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 = {
-            Hover: {
-                ...super.annotationsAsYml(),
-                ...this.findAction.toYaml(),
-            },
-        };
-        if (this.stepId()) {
-            step.Hover.id = this.stepId();
-        }
-        return step;
+        return buildStepDescriptor(this.findAction);
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new HoverStep('hover', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+        const stepDescriptor = buildStepDescriptor(findAction);
+        const step = new HoverStep(stepDescriptor, findAction);
         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.mablScriptStepNames = ['hover'];
-HoverStep.yamlMablScriptNames = ['Hover'];
+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}`);
+    }
+}

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 MablStep_1 = require("../MablStep");
+const MablStepV2_1 = require("../MablStepV2");
 const ExtractAction_1 = require("../actions/ExtractAction");
 const domUtil_1 = require("../../domUtil");
 const JavaScriptAction_1 = require("../actions/JavaScriptAction");
@@ -15,9 +15,21 @@ 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");
-class IfConditionStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'conditional_if');
+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) {
         const candidatePrimaryActions = actions.filter((action) => action instanceof FindAction_1.FindAction ||
             action instanceof MobileFindAction_1.MobileFindAction ||
             action instanceof GetVariableValue_1.GetVariableValue ||
@@ -26,106 +38,127 @@ class IfConditionStep extends MablStep_1.MablStep {
         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`);
         }
-        this.conditionAction = actions.find((action) => action instanceof ConditionAction_1.ConditionAction);
-        this.extractAction = actions.find((action) => action instanceof ExtractAction_1.ExtractAction);
+        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;
         if (candidatePrimaryActions[0] === undefined) {
-            if (this.conditionAction !== undefined &&
-                (0, ConditionDescriptor_1.isAIPromptCondition)(this.conditionAction.conditionDescriptor)) {
-                this.primaryAction = new GetViewportAction_1.GetViewportAction();
+            if (conditionAction !== undefined &&
+                (0, ConditionDescriptor_1.isAIPromptCondition)(conditionAction.conditionDescriptor)) {
+                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 {
-            this.primaryAction = candidatePrimaryActions[0];
+            primaryAction = candidatePrimaryActions[0];
         }
+        return { primaryAction, conditionAction, extractAction, countAction };
     }
-    getStepName() {
-        return 'If';
-    }
-    toStepDescriptor() {
-        const conditionDescriptor = this.conditionAction !== undefined
-            ? this.conditionAction?.conditionDescriptor
+    static buildDescriptor(validatedActions) {
+        const conditionDescriptor = validatedActions.conditionAction !== undefined
+            ? validatedActions.conditionAction?.conditionDescriptor
             : { conditionType: ConditionDescriptor_1.ConditionType.Truthy };
-        const find = this.primaryAction.toDescriptor();
+        const target = validatedActions.primaryAction.toDescriptor();
+        const count = validatedActions.countAction?.countDescriptor;
+        const extract = validatedActions.extractAction?.toDescriptor();
         return {
-            find,
-            extractDescriptor: this.extractAction?.extractDescriptor,
-            conditionDescriptor,
+            target,
+            extract,
+            condition: conditionDescriptor,
+            count,
             onFailure: AssertStep_1.OnFailure.FailImmediately,
-            descriptorToActionMap: new Map().set(find, this.primaryAction),
-            actionCode: this.actionCode,
+            descriptorToActionMap: new Map().set(target, validatedActions.primaryAction),
+            actionCode: IfConditionStep.actionCode,
         };
     }
-    getFormattedStep(_fullLocatorsOn) {
-        const result = {};
-        result[this.getStepName()] = this.toYamlConditionDetails();
-        if (this.stepId()) {
-            result[this.getStepName()].id = this.stepId();
-        }
-        return result;
+    getStepName() {
+        return IfConditionStep.stepName;
     }
-    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,
-                };
+    toStepDescriptor() {
+        return IfConditionStep.buildDescriptor({
+            primaryAction: this.primaryAction,
+            conditionAction: this.conditionAction,
+            extractAction: this.extractAction,
+        });
+    }
+    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));
+                }
             }
-        }
-        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.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));
+                }
             }
-            else {
-                details.snippet = jsYaml;
+            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,
+                        },
+                    ]));
+                }
             }
+            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 {
-                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));
-                }
+                actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs));
             }
         }
         else if (stepArgs.selector) {
@@ -148,15 +181,14 @@ class IfConditionStep extends MablStep_1.MablStep {
             actions.push(new ExtractAction_1.ExtractAction('extract_attribute', extractArgs));
         }
         if (stepArgs.variableName) {
-            actions.push(new GetVariableValue_1.GetVariableValue('get_variable_value', [
-                `{{@${stepArgs.variableName}}}`,
-            ]));
+            actions.push(GetVariableValue_1.GetVariableValue.buildAction(stepArgs.variableName));
         }
         if (stepArgs.snippet) {
             actions.push(JavaScriptAction_1.JavaScriptAction.fromYaml(stepArgs.snippet));
         }
         if (stepArgs.condition) {
-            const conditionType = ConditionDescriptor_1.AssertionStepNameToField[stepArgs.condition];
+            const conditionStepName = stepArgs.condition;
+            const conditionType = ConditionDescriptor_1.AssertionStepNameToField[conditionStepName];
             if (conditionType === 'ai_prompt') {
                 actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType(conditionType), [
                     stepArgs.aiPrompt?.userPrompt ?? stepArgs.userPrompt,
@@ -167,11 +199,7 @@ class IfConditionStep extends MablStep_1.MablStep {
                 ]));
             }
             else {
-                actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType(conditionType), [
-                    ConditionDescriptor_1.AssertionStepNameToField[stepArgs.condition],
-                    stepArgs.conditionValue,
-                    stepArgs.conditionOptions,
-                ]));
+                actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType(conditionType), [conditionType, stepArgs.conditionValue, stepArgs.conditionOptions]));
             }
         }
         return actions;
@@ -187,25 +215,37 @@ class IfConditionStep extends MablStep_1.MablStep {
     }
     static fromYaml(_stepName, stepArgs) {
         const actions = IfConditionStep.getActionsFromYamlForCondition(stepArgs);
-        const step = new IfConditionStep('conditional_if', [], actions);
+        const validatedActions = IfConditionStep.validateAndParseActions(actions);
+        const stepDescriptor = IfConditionStep.buildDescriptor(validatedActions);
+        const step = new IfConditionStep(IfConditionStep.stepName, IfConditionStep.actionCode, stepDescriptor, validatedActions);
         step.setStepId(stepArgs.id);
         return step;
     }
     toMablscript() {
-        return `${this.actions.reduce((mablscript, action) => `${mablscript}${action.toMablscript()}.`, '')}conditional_if()`;
+        const actions = [
+            this.primaryAction,
+            this.extractAction,
+            this.conditionAction,
+        ].filter(Boolean);
+        return `${actions.reduce((mablscript, action) => `${mablscript}${action?.toMablscript()}.`, '')}conditional_if()`;
     }
     getInputVariables() {
-        return (0, MablAction_1.distinctStrings)([
-            ...this.primaryAction.getInputVariables(),
-            ...(this.conditionAction?.getInputVariables() ?? []),
-            ...(this.extractAction?.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';
     }
 }
 exports.IfConditionStep = IfConditionStep;
-IfConditionStep.stepName = 'conditional_if';
-IfConditionStep.mablScriptStepNames = [IfConditionStep.stepName];
-IfConditionStep.yamlMablScriptNames = ['If'];
+IfConditionStep.stepName = 'If';
+IfConditionStep.actionCode = 'conditional_if';
+IfConditionStep.mablScriptStepNames = [IfConditionStep.actionCode];
+IfConditionStep.yamlMablScriptNames = [IfConditionStep.stepName];
 function isIfConditionStep(value) {
     return (value?.getStepName &&
         value?.getStepName() === IfConditionStep.yamlMablScriptNames[0]);

package/mablscript/steps/NavigateStep.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NavigateStep = void 0;
-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];
+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;
     }
     getStepName() {
-        return 'Navigate';
+        return NavigateStep.stepName;
     }
     toStepDescriptor() {
         return {
@@ -17,14 +18,33 @@ class NavigateStep extends MablStep_1.MablStep {
         };
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new NavigateStep('navigate', [stepArgs.navigation], []);
+        const stepDescriptor = {
+            navigation: stepArgs.navigation,
+            actionCode: NavigateStep.actionCode,
+        };
+        const step = new NavigateStep(stepDescriptor);
         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.mablScriptStepNames = ['navigate'];
-NavigateStep.yamlMablScriptNames = ['Navigate'];
+NavigateStep.stepName = 'Navigate';
+NavigateStep.actionCode = 'navigate';
+NavigateStep.mablScriptStepNames = [NavigateStep.actionCode];
+NavigateStep.yamlMablScriptNames = [NavigateStep.stepName];