@mablhq/mabl-cli 2.72.0 → 2.72.4

package/mablscript/steps/SwitchContextStep.js

@@ -2,26 +2,53 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwitchContextStep = void 0;
 const FindAction_1 = require("../actions/FindAction");
-const MablStepV2_1 = require("../MablStepV2");
+const MablStep_1 = require("../MablStep");
 const SwitchContextStepDescriptor_1 = require("../types/SwitchContextStepDescriptor");
 const domUtil_1 = require("../../domUtil");
-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;
+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)}`);
         }
-        else if ((0, SwitchContextStepDescriptor_1.isSwitchTab)(descriptor)) {
-            this.tab = descriptor.tab;
+        if (maybeRoot === 'root') {
+            this.switch = {
+                frame: 'root',
+                actionCode: this.actionCode,
+            };
+            Object.freeze(this.switch);
+            return;
         }
-        else {
-            throw new Error(`Invalid SwitchContextStepDescriptor: ${JSON.stringify(descriptor)}`);
+        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;
         }
-        if (descriptor.find) {
-            this.findAction = FindAction_1.FindAction.findActionFromStepArgs(descriptor);
-            this.findAction.setActionSourceIndexInStep(0);
+        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;
         }
+        throw new Error(`Unexpected find type for ${name} step: ${findDescriptor.findType}`);
     }
     validate() {
         if (this.actions.length === 0 ||
@@ -30,22 +57,55 @@ class SwitchContextStep extends MablStepV2_1.MablStepV2 {
         }
     }
     getStepName() {
-        return SwitchContextStep.stepName;
+        return 'SwitchContext';
     }
     toStepDescriptor() {
-        return buildStepDescriptor(this.findAction);
+        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;
     }
     static fromYaml(_stepName, stepArgs) {
+        let step;
         if (stepArgs.switch) {
-            return SwitchContextStep.fromLegacyMablscript([stepArgs.switch], []);
+            step = new SwitchContextStep('switch_context_to', [stepArgs.switch], []);
         }
-        else if (stepArgs.selector) {
-            return SwitchContextStep.fromLegacyMablscript([], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        else {
+            step = new SwitchContextStep('switch_context_to', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
         }
-        return new SwitchContextStep(stepArgs);
+        step.setStepId(stepArgs.id);
+        return step;
     }
     toMablscript() {
-        if ((0, SwitchContextStepDescriptor_1.isSwitchRoot)(this.descriptor) && this.descriptor.frame === 'root') {
+        if ((0, SwitchContextStepDescriptor_1.isSwitchRoot)(this.switch) && this.switch.frame === 'root') {
             return 'switch_context_to("root")';
         }
         return `${this.findAction?.toMablscript()}.switch_context_to()`;
@@ -53,73 +113,7 @@ class SwitchContextStep extends MablStepV2_1.MablStepV2 {
     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.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}`);
-}
+SwitchContextStep.mablScriptStepNames = ['switch_context_to'];
+SwitchContextStep.yamlMablScriptNames = ['SwitchContext'];

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");
-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;
+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);
     }
     getStepName() {
-        return VisitUrlStep.stepName;
+        return 'VisitUrl';
     }
     toStepDescriptor() {
         return {
@@ -19,14 +19,10 @@ class VisitUrlStep extends MablStepV2_1.MablStepV2 {
             actionCode: this.actionCode,
         };
     }
-    static fromYaml(_stepName, stepDescriptor) {
-        return new VisitUrlStep(stepDescriptor);
-    }
-    static fromLegacyMablscript(args, _actions) {
-        const stepDescriptor = {
-            url: VisitUrlStep.sanitizeUrl(args[0]),
-        };
-        return new VisitUrlStep(stepDescriptor);
+    static fromYaml(_stepName, stepArgs) {
+        const step = new VisitUrlStep('visit_url', [stepArgs.url], []);
+        step.setStepId(stepArgs.id);
+        return step;
     }
     toMablscript() {
         const resolvedUrl = this.substituteMablscriptVariable((0, domUtil_1.escapeMablscriptString)(this.url.toString()));
@@ -38,29 +34,27 @@ class VisitUrlStep extends MablStepV2_1.MablStepV2 {
     getInputVariables() {
         return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.url);
     }
-    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) {
+    static normalizeUrl(param) {
         const trimmed = param.trim();
-        if (trimmed === '') {
+        if (param === '') {
             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 trimmed;
+        return `http://${trimmed}`;
     }
     static isTestOverride() {
         return process.env.MABL_SIMULATION === 'mabl-local-testing';
@@ -70,7 +64,5 @@ class VisitUrlStep extends MablStepV2_1.MablStepV2 {
     }
 }
 exports.VisitUrlStep = VisitUrlStep;
-VisitUrlStep.stepName = 'VisitUrl';
-VisitUrlStep.actionCode = 'visit_url';
-VisitUrlStep.mablScriptStepNames = [VisitUrlStep.actionCode];
-VisitUrlStep.yamlMablScriptNames = [VisitUrlStep.stepName];
+VisitUrlStep.mablScriptStepNames = ['visit_url'];
+VisitUrlStep.yamlMablScriptNames = ['VisitUrl'];

package/mablscript/steps/WaitStep.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaitStep = void 0;
-const MablStepV2_1 = require("../MablStepV2");
-class WaitStep extends MablStepV2_1.MablStepV2 {
-    constructor(descriptor) {
-        super(WaitStep.stepName, descriptor, WaitStep.actionCode);
-        this.milliseconds = descriptor.milliseconds;
+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]);
     }
     getStepName() {
         return WaitStep.stepName;
@@ -17,23 +17,13 @@ class WaitStep extends MablStepV2_1.MablStepV2 {
         };
     }
     static fromYaml(_stepName, stepArgs) {
-        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);
+        const step = new WaitStep(WaitStep.stepName, [stepArgs.milliseconds], []);
+        step.setStepId(stepArgs.id);
+        return step;
     }
     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}]`);
@@ -43,6 +33,5 @@ class WaitStep extends MablStepV2_1.MablStepV2 {
 }
 exports.WaitStep = WaitStep;
 WaitStep.stepName = 'Wait';
-WaitStep.actionCode = 'wait';
-WaitStep.mablScriptStepNames = [WaitStep.actionCode];
+WaitStep.mablScriptStepNames = ['wait'];
 WaitStep.yamlMablScriptNames = [WaitStep.stepName];

package/mablscript/steps/WaitUntilStep.js

@@ -3,13 +3,18 @@ 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(descriptor, findAction) {
-        super(WaitUntilStep.stepName, descriptor, WaitUntilStep.actionCode, findAction);
+    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])}`);
+        }
     }
     getStepName() {
-        return WaitUntilStep.stepName;
+        return 'WaitUntil';
     }
     toStepDescriptor() {
         const find = this.findAction.toDescriptor();
@@ -24,13 +29,10 @@ 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) {
-        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);
+    static fromYaml(_stepName, stepArgs) {
+        const step = new WaitUntilStep('wait', [], []);
+        step.setStepId(stepArgs.id);
+        return step;
     }
     toMablscript() {
         return `${this.findAction.toMablscript()}.evaluate_presence("present").assert()`;
@@ -38,26 +40,7 @@ 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 = [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`);
-    }
-}
+WaitUntilStep.yamlMablScriptNames = ['WaitUntil'];

package/mablscript/types/ConditionDescriptor.js

@@ -9,7 +9,6 @@ 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";
@@ -53,12 +52,13 @@ function getOptionalComparisonType(descriptor) {
     return undefined;
 }
 function getOptionalComparatorValue(descriptor) {
-    if (descriptor?.conditionType !== ConditionType.Comparison) {
+    if (descriptor === undefined) {
         return undefined;
     }
-    return (0, MablSymbol_1.isMablSymbolObject)(descriptor.comparatorValue)
-        ? `{{@${descriptor.comparatorValue.name}}}`
-        : descriptor.comparatorValue;
+    if (descriptor.conditionType === ConditionType.Comparison) {
+        return descriptor.comparatorValue.toString();
+    }
+    return undefined;
 }
 function getOptionalConditionOptions(descriptor) {
     if (descriptor === undefined ||

package/mablscript/types/GetVariableDescriptor.js

@@ -2,7 +2,15 @@
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mablhq/mabl-cli",
-  "version": "2.72.0",
+  "version": "2.72.4",
   "license": "SEE LICENSE IN LICENSE.txt",
   "description": "The official mabl command line interface tool",
   "main": "index.js",
@@ -77,8 +77,8 @@
     "open": "6.4.0",
     "ora": "4.0.4",
     "pixelmatch": "5.3.0",
-    "playwright": "1.51.1",
-    "playwright-core": "1.51.1",
+    "playwright": "1.54.2",
+    "playwright-core": "1.54.2",
     "pluralize": "8.0.0",
     "pngjs": "6.0.0",
     "portfinder": "1.0.28",

package/mablscript/steps/StepGroupStep.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StepGroupStep = void 0;
-const MablAction_1 = require("../MablAction");
-const MablStepV2_1 = require("../MablStepV2");
-const importer_1 = require("../importer");
-class StepGroupStep extends MablStepV2_1.MablStepV2 {
-    constructor(descriptor) {
-        super(StepGroupStep.stepName, descriptor, StepGroupStep.actionCode);
-        this.intent = descriptor.intent;
-        this.steps = this.createStepsFromDescriptors(descriptor.steps);
-    }
-    createStepsFromDescriptors(stepDescriptors) {
-        return (0, importer_1.interpretStepsFromObjects)(stepDescriptors);
-    }
-    getStepName() {
-        return StepGroupStep.stepName;
-    }
-    toStepDescriptor() {
-        const steps = this.steps.map((step) => ({
-            [step.getStepName()]: step.toStepDescriptor(true),
-        }));
-        return {
-            steps,
-            intent: this.intent,
-            actionCode: this.actionCode,
-        };
-    }
-    static fromYaml(_stepName, stepArgs) {
-        const stepDescriptor = {
-            steps: stepArgs.steps || [],
-            intent: stepArgs.intent || { description: '' },
-            actionCode: StepGroupStep.actionCode,
-        };
-        const step = new StepGroupStep(stepDescriptor);
-        step.setStepId(stepArgs.id);
-        return step;
-    }
-    static fromLegacyMablscript(_args, _actions) {
-        throw new Error('Legacy mablscript conversion not supported for StepGroupStep');
-    }
-    toMablscript() {
-        throw new Error('Legacy mablscript generation not supported for StepGroupStep');
-    }
-    stepDescription() {
-        return `Step Group: "${this.intent.description}" (${this.steps.length} steps)`;
-    }
-    getInputVariables() {
-        const inputVariables = this.steps.flatMap((step) => {
-            if (typeof step.getInputVariables === 'function') {
-                return step.getInputVariables();
-            }
-            return [];
-        });
-        return (0, MablAction_1.distinctStrings)(inputVariables);
-    }
-    getOutputVariables() {
-        return this.steps.flatMap((step) => {
-            if (typeof step.getOutputVariables === 'function') {
-                return step.getOutputVariables();
-            }
-            return [];
-        });
-    }
-}
-exports.StepGroupStep = StepGroupStep;
-StepGroupStep.stepName = 'StepGroup';
-StepGroupStep.actionCode = 'step_group';
-StepGroupStep.mablScriptStepNames = [StepGroupStep.actionCode];
-StepGroupStep.yamlMablScriptNames = [StepGroupStep.stepName];

package/mablscript/types/AssertStepDescriptor.js

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

package/mablscript/types/StepGroupStepDescriptor.js

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