@mablhq/mabl-cli 2.71.0 → 2.72.0

package/mablscript/steps/SwitchContextStep.js

@@ -2,53 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwitchContextStep = void 0;
 const FindAction_1 = require("../actions/FindAction");
-const MablStep_1 = require("../MablStep");
+const MablStepV2_1 = require("../MablStepV2");
 const SwitchContextStepDescriptor_1 = require("../types/SwitchContextStepDescriptor");
 const domUtil_1 = require("../../domUtil");
-class SwitchContextStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'switch_context_to');
-        const maybeRoot = this.getActionArgs()[0];
-        if (maybeRoot !== undefined && maybeRoot !== 'root') {
-            throw new Error(`Unexpected argument for ${name} step: ${JSON.stringify(maybeRoot)}`);
+const mablscriptFind_1 = require("../../mablscriptFind");
+class SwitchContextStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(SwitchContextStep.stepName, descriptor, SwitchContextStep.actionCode);
+        if ((0, SwitchContextStepDescriptor_1.isSwitchRoot)(descriptor) || (0, SwitchContextStepDescriptor_1.isSwitchFrame)(descriptor)) {
+            this.frame = descriptor.frame;
         }
-        if (maybeRoot === 'root') {
-            this.switch = {
-                frame: 'root',
-                actionCode: this.actionCode,
-            };
-            Object.freeze(this.switch);
-            return;
+        else if ((0, SwitchContextStepDescriptor_1.isSwitchTab)(descriptor)) {
+            this.tab = descriptor.tab;
         }
-        if (actions.length !== 1) {
-            throw new Error(`No find action for ${name} step`);
-        }
-        this.findAction = new FindAction_1.FindAction(this.actions[0].name, this.actions[0].args);
-        if (this.actions[0].actionSourceIndexInStep !== undefined) {
-            this.findAction.setActionSourceIndexInStep(this.actions[0].actionSourceIndexInStep);
-        }
-        const findDescriptor = this.findAction.toDescriptor();
-        if (findDescriptor.findType === domUtil_1.FindType.FIND_TAB) {
-            this.switch = {
-                tab: findDescriptor,
-                find: findDescriptor,
-                descriptorToActionMap: new Map().set(findDescriptor, this.findAction),
-                actionCode: this.actionCode,
-            };
-            Object.freeze(this.switch);
-            return;
+        else {
+            throw new Error(`Invalid SwitchContextStepDescriptor: ${JSON.stringify(descriptor)}`);
         }
-        if (findDescriptor.findType === domUtil_1.FindType.FIND_ONE) {
-            this.switch = {
-                frame: findDescriptor,
-                find: findDescriptor,
-                descriptorToActionMap: new Map().set(findDescriptor, this.findAction),
-                actionCode: this.actionCode,
-            };
-            Object.freeze(this.switch);
-            return;
+        if (descriptor.find) {
+            this.findAction = FindAction_1.FindAction.findActionFromStepArgs(descriptor);
+            this.findAction.setActionSourceIndexInStep(0);
         }
-        throw new Error(`Unexpected find type for ${name} step: ${findDescriptor.findType}`);
     }
     validate() {
         if (this.actions.length === 0 ||
@@ -57,55 +30,22 @@ class SwitchContextStep extends MablStep_1.MablStep {
         }
     }
     getStepName() {
-        return 'SwitchContext';
+        return SwitchContextStep.stepName;
     }
     toStepDescriptor() {
-        return this.switch;
-    }
-    getFormattedStep() {
-        const step = this.toStepDescriptor();
-        const stepName = this.getStepName();
-        const formatted = {
-            [stepName]: {},
-        };
-        if (this.annotationsOnStep()) {
-            formatted[stepName].annotation = this.annotation;
-        }
-        if (this.description) {
-            formatted[stepName].description = this.description;
-        }
-        if ((0, SwitchContextStepDescriptor_1.isSwitchTab)(step)) {
-            formatted[stepName].findType = 'FindTab';
-            formatted[stepName].selector = step.tab.findTarget;
-        }
-        if ((0, SwitchContextStepDescriptor_1.isSwitchFrame)(step)) {
-            formatted[stepName].selector = step.frame.findTarget.selector;
-            if (step.frame.findTarget.auxiliaryDescriptors?.length) {
-                formatted[stepName].selectorAncestors =
-                    step.frame.findTarget.auxiliaryDescriptors.map((descriptor) => descriptor.selector);
-            }
-        }
-        if ((0, SwitchContextStepDescriptor_1.isSwitchRoot)(step) && step.frame === 'root') {
-            formatted[stepName].switch = 'root';
-        }
-        if (this.stepId()) {
-            formatted[stepName].id = this.stepId();
-        }
-        return formatted;
+        return buildStepDescriptor(this.findAction);
     }
     static fromYaml(_stepName, stepArgs) {
-        let step;
         if (stepArgs.switch) {
-            step = new SwitchContextStep('switch_context_to', [stepArgs.switch], []);
+            return SwitchContextStep.fromLegacyMablscript([stepArgs.switch], []);
         }
-        else {
-            step = new SwitchContextStep('switch_context_to', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        else if (stepArgs.selector) {
+            return SwitchContextStep.fromLegacyMablscript([], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
         }
-        step.setStepId(stepArgs.id);
-        return step;
+        return new SwitchContextStep(stepArgs);
     }
     toMablscript() {
-        if ((0, SwitchContextStepDescriptor_1.isSwitchRoot)(this.switch) && this.switch.frame === 'root') {
+        if ((0, SwitchContextStepDescriptor_1.isSwitchRoot)(this.descriptor) && this.descriptor.frame === 'root') {
             return 'switch_context_to("root")';
         }
         return `${this.findAction?.toMablscript()}.switch_context_to()`;
@@ -113,7 +53,73 @@ class SwitchContextStep extends MablStep_1.MablStep {
     getInputVariables() {
         return this.findAction?.getInputVariables() ?? [];
     }
+    stepDescription() {
+        if ((0, SwitchContextStepDescriptor_1.isSwitchRoot)(this.descriptor) && this.descriptor.frame === 'root') {
+            return 'Switch context to the root frame';
+        }
+        if (this.findAction) {
+            const findDescriptor = this.findAction.toDescriptor();
+            if (findDescriptor.findType === domUtil_1.FindType.FIND_TAB) {
+                if (typeof findDescriptor.findTarget === 'string') {
+                    return `Switch context to ${findDescriptor.findTarget} tab`;
+                }
+                return `Switch context to ${(0, mablscriptFind_1.humanizeTabSelector)(findDescriptor.findTarget)}`;
+            }
+            else if (findDescriptor.findType === domUtil_1.FindType.FIND_ONE) {
+                return `Switch context to ${(0, mablscriptFind_1.humanizeFindOneDescriptor)(findDescriptor.findTarget)}`;
+            }
+        }
+        return 'Switch context';
+    }
+    static fromLegacyMablscript(args, actions) {
+        const maybeRoot = args[0];
+        if (maybeRoot !== undefined && maybeRoot !== 'root') {
+            throw new Error(`Unexpected argument for ${name} step: ${JSON.stringify(maybeRoot)}`);
+        }
+        if (maybeRoot === 'root') {
+            return new SwitchContextStep({
+                frame: 'root',
+            });
+        }
+        if (actions.length !== 1) {
+            throw new Error(`No find action for ${name} step`);
+        }
+        const findAction = new FindAction_1.FindAction(actions[0].name, actions[0].args);
+        if (actions[0].actionSourceIndexInStep !== undefined) {
+            findAction.setActionSourceIndexInStep(actions[0].actionSourceIndexInStep);
+        }
+        const stepDescriptor = buildStepDescriptor(findAction);
+        return new SwitchContextStep(stepDescriptor);
+    }
 }
 exports.SwitchContextStep = SwitchContextStep;
-SwitchContextStep.mablScriptStepNames = ['switch_context_to'];
-SwitchContextStep.yamlMablScriptNames = ['SwitchContext'];
+SwitchContextStep.stepName = 'SwitchContext';
+SwitchContextStep.actionCode = 'switch_context_to';
+SwitchContextStep.mablScriptStepNames = [SwitchContextStep.actionCode];
+SwitchContextStep.yamlMablScriptNames = [SwitchContextStep.stepName];
+function buildStepDescriptor(findAction) {
+    if (!findAction) {
+        return {
+            frame: 'root',
+            actionCode: SwitchContextStep.actionCode,
+        };
+    }
+    const findDescriptor = findAction.toDescriptor();
+    if (findDescriptor.findType === domUtil_1.FindType.FIND_TAB) {
+        return {
+            tab: findDescriptor,
+            find: findDescriptor,
+            descriptorToActionMap: new Map().set(findDescriptor, findAction),
+            actionCode: SwitchContextStep.actionCode,
+        };
+    }
+    if (findDescriptor.findType === domUtil_1.FindType.FIND_ONE) {
+        return {
+            frame: findDescriptor,
+            find: findDescriptor,
+            descriptorToActionMap: new Map().set(findDescriptor, findAction),
+            actionCode: SwitchContextStep.actionCode,
+        };
+    }
+    throw new Error(`Unexpected find type for SwitchContext step: ${findDescriptor.findType}`);
+}

package/mablscript/steps/SyntheticStep.js

@@ -4,7 +4,7 @@ exports.SyntheticStep = exports.DEFAULT_STEP_SOURCE_INDEX_IN_FLOW = void 0;
 const MablStep_1 = require("../MablStep");
 exports.DEFAULT_STEP_SOURCE_INDEX_IN_FLOW = -1;
 class SyntheticStep extends MablStep_1.MablStep {
-    constructor(name, args = [], actions = [], stepSourceIndexInFlow = exports.DEFAULT_STEP_SOURCE_INDEX_IN_FLOW) {
+    constructor(name, args, actions, stepSourceIndexInFlow = exports.DEFAULT_STEP_SOURCE_INDEX_IN_FLOW) {
         super(name, args, actions, name);
         this.stepSourceIndexInFlow = stepSourceIndexInFlow;
         this.actionSourceIndexInStep = 0;

package/mablscript/steps/VisitUrlStep.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VisitUrlStep = void 0;
-const MablStep_1 = require("../MablStep");
 const MablAction_1 = require("../MablAction");
 const domUtil_1 = require("../../domUtil");
-class VisitUrlStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'visit_url');
-        const arg = this.getActionArgs()[0];
-        this.url = VisitUrlStep.normalizeUrl(arg);
+const MablStepV2_1 = require("../MablStepV2");
+class VisitUrlStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        descriptor.url = VisitUrlStep.sanitizeUrl(descriptor.url);
+        super(VisitUrlStep.stepName, descriptor, VisitUrlStep.actionCode);
+        this.url = descriptor.url;
     }
     getStepName() {
-        return 'VisitUrl';
+        return VisitUrlStep.stepName;
     }
     toStepDescriptor() {
         return {
@@ -19,10 +19,14 @@ class VisitUrlStep extends MablStep_1.MablStep {
             actionCode: this.actionCode,
         };
     }
-    static fromYaml(_stepName, stepArgs) {
-        const step = new VisitUrlStep('visit_url', [stepArgs.url], []);
-        step.setStepId(stepArgs.id);
-        return step;
+    static fromYaml(_stepName, stepDescriptor) {
+        return new VisitUrlStep(stepDescriptor);
+    }
+    static fromLegacyMablscript(args, _actions) {
+        const stepDescriptor = {
+            url: VisitUrlStep.sanitizeUrl(args[0]),
+        };
+        return new VisitUrlStep(stepDescriptor);
     }
     toMablscript() {
         const resolvedUrl = this.substituteMablscriptVariable((0, domUtil_1.escapeMablscriptString)(this.url.toString()));
@@ -34,27 +38,29 @@ class VisitUrlStep extends MablStep_1.MablStep {
     getInputVariables() {
         return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.url);
     }
-    static normalizeUrl(param) {
+    stepDescription() {
+        const inputVariables = this.getInputVariables();
+        if (inputVariables.length > 0) {
+            const variableName = inputVariables[0];
+            return `Visit URL assigned to variable "${variableName}"`;
+        }
+        return `Visit URL "${this.url}"`;
+    }
+    static sanitizeUrl(param) {
         const trimmed = param.trim();
-        if (param === '') {
+        if (trimmed === '') {
             throw new Error('Missing URL');
         }
-        if (trimmed.indexOf('{{@') >= 0) {
-            return trimmed;
-        }
         if (trimmed.indexOf('[not yet evaluated]') >= 0) {
             throw new Error('Unresolved variable found in URL');
         }
-        if (/^http[s]?:\/\//.test(trimmed)) {
-            return trimmed;
-        }
         if (VisitUrlStep.isFileUrl(trimmed)) {
             if (VisitUrlStep.isTestOverride()) {
                 return trimmed;
             }
             throw new Error('Access to local files is not permitted');
         }
-        return `http://${trimmed}`;
+        return trimmed;
     }
     static isTestOverride() {
         return process.env.MABL_SIMULATION === 'mabl-local-testing';
@@ -64,5 +70,7 @@ class VisitUrlStep extends MablStep_1.MablStep {
     }
 }
 exports.VisitUrlStep = VisitUrlStep;
-VisitUrlStep.mablScriptStepNames = ['visit_url'];
-VisitUrlStep.yamlMablScriptNames = ['VisitUrl'];
+VisitUrlStep.stepName = 'VisitUrl';
+VisitUrlStep.actionCode = 'visit_url';
+VisitUrlStep.mablScriptStepNames = [VisitUrlStep.actionCode];
+VisitUrlStep.yamlMablScriptNames = [VisitUrlStep.stepName];

package/mablscript/steps/WaitStep.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaitStep = void 0;
-const MablStep_1 = require("../MablStep");
-class WaitStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'wait');
-        this.milliseconds = WaitStep.validateWait(this.getActionArgs()[0]);
+const MablStepV2_1 = require("../MablStepV2");
+class WaitStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(WaitStep.stepName, descriptor, WaitStep.actionCode);
+        this.milliseconds = descriptor.milliseconds;
     }
     getStepName() {
         return WaitStep.stepName;
@@ -17,13 +17,23 @@ class WaitStep extends MablStep_1.MablStep {
         };
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new WaitStep(WaitStep.stepName, [stepArgs.milliseconds], []);
-        step.setStepId(stepArgs.id);
-        return step;
+        const stepDescriptor = {
+            milliseconds: WaitStep.validateWait(stepArgs.milliseconds),
+        };
+        return new WaitStep(stepDescriptor);
+    }
+    static fromLegacyMablscript(args, _actions) {
+        const stepDescriptor = {
+            milliseconds: WaitStep.validateWait(args[0]),
+        };
+        return new WaitStep(stepDescriptor);
     }
     toMablscript() {
         return `wait(${this.milliseconds})`;
     }
+    stepDescription() {
+        return `Wait for ${this.milliseconds / 1000} seconds`;
+    }
     static validateWait(wait) {
         if (typeof wait !== 'number') {
             throw new Error(`Invalid wait argument [${wait}]`);
@@ -33,5 +43,6 @@ class WaitStep extends MablStep_1.MablStep {
 }
 exports.WaitStep = WaitStep;
 WaitStep.stepName = 'Wait';
-WaitStep.mablScriptStepNames = ['wait'];
+WaitStep.actionCode = 'wait';
+WaitStep.mablScriptStepNames = [WaitStep.actionCode];
 WaitStep.yamlMablScriptNames = [WaitStep.stepName];

package/mablscript/steps/WaitUntilStep.js

@@ -3,18 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaitUntilStep = void 0;
 const domUtil_1 = require("../../domUtil");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
+const ActionsUtils_1 = require("./ActionsUtils");
 class WaitUntilStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'wait_until');
-        if ((0, domUtil_1.isFindElementType)(this.actions[0].getActionName())) {
-            this.findAction = this.actions[0];
-        }
-        else {
-            throw new Error(`Unexpected find action for ${name} step: ${JSON.stringify(this.actions[0])}`);
-        }
+    constructor(descriptor, findAction) {
+        super(WaitUntilStep.stepName, descriptor, WaitUntilStep.actionCode, findAction);
     }
     getStepName() {
-        return 'WaitUntil';
+        return WaitUntilStep.stepName;
     }
     toStepDescriptor() {
         const find = this.findAction.toDescriptor();
@@ -29,10 +24,13 @@ class WaitUntilStep extends MablStepWithFindAction_1.MablStepWithFindAction {
                 throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType} is not supported`);
         }
     }
-    static fromYaml(_stepName, stepArgs) {
-        const step = new WaitUntilStep('wait', [], []);
-        step.setStepId(stepArgs.id);
-        return step;
+    static fromYaml(_stepName, _stepArgs) {
+        throw new Error('YAML support for WaitUntilStep is not yet implemented');
+    }
+    static fromLegacyMablscript(_args, actions) {
+        const findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(actions);
+        const stepDescriptor = buildStepDescriptor(findAction);
+        return new WaitUntilStep(stepDescriptor, findAction);
     }
     toMablscript() {
         return `${this.findAction.toMablscript()}.evaluate_presence("present").assert()`;
@@ -40,7 +38,26 @@ class WaitUntilStep extends MablStepWithFindAction_1.MablStepWithFindAction {
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
+    stepDescription() {
+        const elementDescription = this.humanizeFind();
+        return `Wait until ${elementDescription} is present`;
+    }
 }
 exports.WaitUntilStep = WaitUntilStep;
+WaitUntilStep.stepName = 'WaitUntil';
+WaitUntilStep.actionCode = 'wait_until';
 WaitUntilStep.mablScriptStepNames = [];
-WaitUntilStep.yamlMablScriptNames = ['WaitUntil'];
+WaitUntilStep.yamlMablScriptNames = [WaitUntilStep.stepName];
+function buildStepDescriptor(findAction) {
+    const find = findAction.toDescriptor();
+    switch (find.findType) {
+        case domUtil_1.FindType.FIND_ONE:
+            return {
+                find,
+                descriptorToActionMap: new Map().set(find, findAction),
+                actionCode: WaitUntilStep.actionCode,
+            };
+        default:
+            throw new Error(`Error generating step descriptor for ${WaitUntilStep.stepName}: Unexpected find type ${find.findType} is not supported`);
+    }
+}

package/mablscript/types/AssertStepDescriptor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/mablscript/types/ConditionDescriptor.js

@@ -9,6 +9,7 @@ exports.isPresenceCondition = isPresenceCondition;
 exports.isAIPromptCondition = isAIPromptCondition;
 exports.isAbsenceExpected = isAbsenceExpected;
 exports.getAssertionConditionFieldFromDescriptor = getAssertionConditionFieldFromDescriptor;
+const MablSymbol_1 = require("../MablSymbol");
 var ConditionType;
 (function (ConditionType) {
     ConditionType["AIPrompt"] = "ai_prompt";
@@ -52,13 +53,12 @@ function getOptionalComparisonType(descriptor) {
     return undefined;
 }
 function getOptionalComparatorValue(descriptor) {
-    if (descriptor === undefined) {
+    if (descriptor?.conditionType !== ConditionType.Comparison) {
         return undefined;
     }
-    if (descriptor.conditionType === ConditionType.Comparison) {
-        return descriptor.comparatorValue.toString();
-    }
-    return undefined;
+    return (0, MablSymbol_1.isMablSymbolObject)(descriptor.comparatorValue)
+        ? `{{@${descriptor.comparatorValue.name}}}`
+        : descriptor.comparatorValue;
 }
 function getOptionalConditionOptions(descriptor) {
     if (descriptor === undefined ||

package/mablscript/types/GetVariableDescriptor.js

@@ -2,15 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GET_VARIABLE_VALUE = void 0;
 exports.isGetVariableDescriptor = isGetVariableDescriptor;
-exports.newGetVariableDescriptor = newGetVariableDescriptor;
-exports.convertGetVariableDescriptorToYaml = convertGetVariableDescriptorToYaml;
 exports.GET_VARIABLE_VALUE = 'GetVariable';
 function isGetVariableDescriptor(value) {
     return value.kind === exports.GET_VARIABLE_VALUE;
 }
-function newGetVariableDescriptor(variable) {
-    return { kind: exports.GET_VARIABLE_VALUE, variable };
-}
-function convertGetVariableDescriptorToYaml(descriptor) {
-    return { ...descriptor, variable: descriptor.variable.toString() };
-}

package/mablscript/types/StepGroupStepDescriptor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mablhq/mabl-cli",
-  "version": "2.71.0",
+  "version": "2.72.0",
   "license": "SEE LICENSE IN LICENSE.txt",
   "description": "The official mabl command line interface tool",
   "main": "index.js",