@mablhq/mabl-cli 2.72.4 → 2.72.12

package/mablscript/steps/SendKeyStep.js

@@ -5,68 +5,51 @@ const FindAction_1 = require("../actions/FindAction");
 const domUtil_1 = require("../../domUtil");
 const SendKeyStepDescriptor_1 = require("../types/SendKeyStepDescriptor");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
-const STEP_NAME = 'SendKeys';
 class SendKeyStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'send_keys');
-        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
+    constructor(descriptor, findAction) {
+        super(SendKeyStep.stepName, descriptor, SendKeyStep.actionCode, findAction);
+        this.keys = descriptor.keys;
+    }
+    static validateActionsAndGetFindAction(name, actions) {
+        if (actions.length !== 1 || !(actions[0] instanceof FindAction_1.FindAction)) {
             throw new Error(`${name} step should have one sub-action and it should be a find`);
         }
-        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])}`);
+        if ((0, domUtil_1.isFindElementType)(actions[0].getActionName())) {
+            return actions[0];
         }
-        const keys = this.getActionArgs();
-        if (!keys?.length) {
+        throw new Error(`Unexpected find action for ${name} step: ${JSON.stringify(actions[0])}`);
+    }
+    static validateKeys(name, args) {
+        if (!args?.length) {
             throw new Error(`${name} step expects at least one key`);
         }
-        if (keys.every(SendKeyStepDescriptor_1.isCrossPlatformKeyPress)) {
-            this.keys = keys;
-        }
-        else {
-            throw new Error(`Unexpected key format for ${name} step: ${JSON.stringify(keys)}`);
+        if (args.every(SendKeyStepDescriptor_1.isCrossPlatformKeyPress)) {
+            return args;
         }
+        throw new Error(`Unexpected key format for ${name} step: ${JSON.stringify(args)}`);
     }
     getStepName() {
-        return STEP_NAME;
+        return SendKeyStep.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,
-                    keys: this.keys,
-                    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}`);
-        }
+        return buildStepDescriptor(this.findAction, this.keys);
     }
-    getFormattedStep() {
-        const step = {
-            [STEP_NAME]: {
-                ...super.annotationsAsYml(),
-                sendKeys: this.keys,
-                ...this.findAction.toYaml(),
-            },
-        };
-        if (this.stepId()) {
-            step[STEP_NAME].id = this.stepId();
+    static fromYaml(_stepName, stepArgs) {
+        const keys = stepArgs.keys || stepArgs.sendKeys;
+        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+        const stepDescriptor = buildStepDescriptor(findAction, keys);
+        const step = new SendKeyStep(stepDescriptor, findAction);
+        if (stepArgs.id) {
+            step.setStepId(stepArgs.id);
         }
         return step;
     }
-    static fromYaml(_stepName, stepArgs) {
-        const step = new SendKeyStep('send_keys', stepArgs.sendKeys, [
-            FindAction_1.FindAction.findActionFromStepArgs(stepArgs),
-        ]);
-        step.setStepId(stepArgs.id);
+    static fromLegacyMablscript(args, actions) {
+        const findAction = SendKeyStep.validateActionsAndGetFindAction(SendKeyStep.stepName, actions);
+        const keys = SendKeyStep.validateKeys(SendKeyStep.stepName, args);
+        const stepDescriptor = buildStepDescriptor(findAction, keys);
+        const step = new SendKeyStep(stepDescriptor, findAction);
+        step.actions = actions;
         return step;
     }
     toMablscript() {
@@ -78,7 +61,150 @@ class SendKeyStep extends MablStepWithFindAction_1.MablStepWithFindAction {
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
+    stepDescription() {
+        const keypresses = this.generateHumanizedKeys(this.isPasswordField());
+        const pluralizedKeypress = this.keys.length > 1 ? 'keypresses' : 'keypress';
+        const elementDescription = this.humanizeFind();
+        return `Send "${keypresses}" ${pluralizedKeypress} to ${elementDescription}`;
+    }
+    isPasswordField() {
+        return false;
+    }
+    generateHumanizedKeys(isPasswordField) {
+        return this.keys
+            .map((key) => this.humanizeKeyInfo(key, isPasswordField))
+            .join('');
+    }
+    humanizeKeyInfo(keyInfo, isPasswordField) {
+        if (!keyInfo) {
+            return '';
+        }
+        const activeModifiers = SendKeyStep.getActiveModifiers(keyInfo, false);
+        const activeModifierStrings = activeModifiers.map((modifierKey) => SendKeyStep.modifierKeyHumanizedMap[modifierKey]);
+        const hasActiveModifiersFlag = !this.isEmpty(activeModifierStrings);
+        const activeModifiersPrefix = hasActiveModifiersFlag
+            ? activeModifierStrings.join('+') + '+'
+            : '';
+        const hasMacOverride = keyInfo.mac?.key;
+        const hasWindowsOverride = keyInfo.windows?.key;
+        let humanizedString = `${activeModifiersPrefix}${this.generateHumanizedKey(keyInfo, isPasswordField)}`;
+        if (hasMacOverride || hasWindowsOverride) {
+            humanizedString = `Default: ${humanizedString}`;
+        }
+        if (hasMacOverride) {
+            humanizedString += `, Mac: ${this.humanizeKeyInfo(keyInfo.mac, isPasswordField)}`;
+        }
+        if (hasWindowsOverride) {
+            humanizedString += `, Windows: ${this.humanizeKeyInfo(keyInfo.windows, isPasswordField)}`;
+        }
+        return humanizedString;
+    }
+    generateHumanizedKey(keyInfo, isPasswordField) {
+        if (SendKeyStep.keyIsSpecial(keyInfo.key)) {
+            return `[${keyInfo.key.toUpperCase()}]`;
+        }
+        return isPasswordField ? '*' : keyInfo.key;
+    }
+    static keyIsSpecial(key) {
+        return SendKeyStep.specialKeys.includes(key);
+    }
+    static getActiveModifiers(keyInfo, includeOverrides) {
+        const modifiers = SendKeyStep.getModifiers(keyInfo, includeOverrides);
+        return Object.keys(SendKeyStep.pickBy(modifiers));
+    }
+    static getModifiers(keyInfo, includeOverrides) {
+        const objectKeys = Object.keys(SendKeyStep.modifierKeyIdentifierMap);
+        let modifiers = SendKeyStep.pick(keyInfo, objectKeys);
+        if (includeOverrides) {
+            modifiers = {
+                ...modifiers,
+                ...SendKeyStep.pick(keyInfo, objectKeys.map((key) => `windows.${key}`)),
+                ...SendKeyStep.pick(keyInfo, objectKeys.map((key) => `mac.${key}`)),
+            };
+        }
+        return modifiers;
+    }
+    isEmpty(obj) {
+        return obj === undefined || Object.keys(obj).length === 0;
+    }
+    static pick(object, paths) {
+        const result = {};
+        for (const path of paths) {
+            if (path in object) {
+                result[path] = object[path];
+            }
+        }
+        return result;
+    }
+    static pickBy(object) {
+        const result = {};
+        for (const key in object) {
+            if (object[key]) {
+                result[key] = object[key];
+            }
+        }
+        return result;
+    }
 }
 exports.SendKeyStep = SendKeyStep;
-SendKeyStep.mablScriptStepNames = ['send_keys'];
-SendKeyStep.yamlMablScriptNames = ['SendKeys'];
+SendKeyStep.stepName = 'SendKeys';
+SendKeyStep.actionCode = 'send_keys';
+SendKeyStep.mablScriptStepNames = [SendKeyStep.actionCode];
+SendKeyStep.yamlMablScriptNames = [SendKeyStep.stepName];
+SendKeyStep.modifierKeyHumanizedMap = {
+    altKey: 'Alt',
+    ctrlKey: 'Ctrl',
+    metaKey: 'Cmd',
+    shiftKey: 'Shift',
+};
+SendKeyStep.modifierKeyIdentifierMap = {
+    altKey: false,
+    ctrlKey: false,
+    metaKey: false,
+    shiftKey: false,
+};
+SendKeyStep.specialKeys = [
+    'Enter',
+    'Tab',
+    'Escape',
+    'Backspace',
+    'Delete',
+    'ArrowUp',
+    'ArrowDown',
+    'ArrowLeft',
+    'ArrowRight',
+    'Home',
+    'End',
+    'PageUp',
+    'PageDown',
+    'Insert',
+    'F1',
+    'F2',
+    'F3',
+    'F4',
+    'F5',
+    'F6',
+    'F7',
+    'F8',
+    'F9',
+    'F10',
+    'F11',
+    'F12',
+];
+function buildStepDescriptor(findAction, keys) {
+    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,
+                keys,
+                descriptorToActionMap: new Map().set(find, findAction),
+                actionCode: 'send_keys',
+            };
+        default:
+            throw new Error(`Error generating step descriptor for SendKeys: Unexpected find type ${find.findType}`);
+    }
+}

package/mablscript/steps/SetCookieStep.js

@@ -1,31 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetCookieStep = void 0;
-const MablStep_1 = require("../MablStep");
+const MablStepV2_1 = require("../MablStepV2");
 const MablAction_1 = require("../MablAction");
 const CookieUtils_1 = require("./CookieUtils");
 const domUtil_1 = require("../../domUtil");
-class SetCookieStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'set_cookie');
-        const cookieSelector = this.getActionArgs()[0];
-        this.cookieName = CookieUtils_1.CookieUtils.normalizeName(cookieSelector.name);
-        this.cookieValue = CookieUtils_1.CookieUtils.normalizeValue(cookieSelector.value);
-        const cookieOptions = {
-            domain: cookieSelector.domain,
-            path: cookieSelector.path,
-            expires: cookieSelector.expiry,
-            httpOnly: cookieSelector.http_only,
-            secure: cookieSelector.secure,
-            sameSite: cookieSelector.same_site,
-            url: cookieSelector.url,
-        };
-        if (Object.values(cookieOptions).filter((optionValue) => optionValue !== undefined).length > 0) {
-            this.cookieOptions = cookieOptions;
-        }
+class SetCookieStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(SetCookieStep.stepName, descriptor, SetCookieStep.actionCode);
+        this.cookieName = descriptor.name;
+        this.cookieValue = descriptor.value;
+        this.cookieOptions = descriptor.options;
     }
     getStepName() {
-        return 'SetCookie';
+        return SetCookieStep.stepName;
     }
     toStepDescriptor() {
         return {
@@ -36,10 +24,52 @@ class SetCookieStep extends MablStep_1.MablStep {
         };
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new SetCookieStep('set_cookie', [stepArgs], []);
+        const cookieName = CookieUtils_1.CookieUtils.normalizeName(stepArgs.name);
+        const cookieValue = CookieUtils_1.CookieUtils.normalizeValue(stepArgs.value);
+        const cookieOptions = {
+            domain: stepArgs.domain,
+            path: stepArgs.path,
+            expires: stepArgs.expiry,
+            httpOnly: stepArgs.http_only,
+            secure: stepArgs.secure,
+            sameSite: stepArgs.same_site,
+            url: stepArgs.url,
+        };
+        const hasOptions = Object.values(cookieOptions).filter((optionValue) => optionValue !== undefined).length > 0;
+        const stepDescriptor = {
+            name: cookieName,
+            value: cookieValue,
+            options: hasOptions ? cookieOptions : undefined,
+            actionCode: SetCookieStep.actionCode,
+        };
+        const step = new SetCookieStep(stepDescriptor);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(args, _actions) {
+        const cookieSelector = args[0];
+        const cookieName = CookieUtils_1.CookieUtils.normalizeName(cookieSelector.name);
+        const cookieValue = CookieUtils_1.CookieUtils.normalizeValue(cookieSelector.value);
+        const cookieOptions = {
+            domain: cookieSelector.domain,
+            path: cookieSelector.path,
+            expires: cookieSelector.expiry,
+            httpOnly: cookieSelector.http_only,
+            secure: cookieSelector.secure,
+            sameSite: cookieSelector.same_site,
+            url: cookieSelector.url,
+        };
+        const hasOptions = Object.values(cookieOptions).filter((optionValue) => optionValue !== undefined).length > 0;
+        const stepDescriptor = {
+            name: cookieName,
+            value: cookieValue,
+            options: hasOptions ? cookieOptions : undefined,
+            actionCode: SetCookieStep.actionCode,
+        };
+        const step = new SetCookieStep(stepDescriptor);
+        step.actions = _actions;
+        return step;
+    }
     toMablscript() {
         const cookieSelector = {
             name: this.cookieName,
@@ -63,7 +93,12 @@ class SetCookieStep extends MablStep_1.MablStep {
             ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.cookieValue),
         ]);
     }
+    stepDescription() {
+        return `Set cookie: "${this.cookieName}"`;
+    }
 }
 exports.SetCookieStep = SetCookieStep;
-SetCookieStep.mablScriptStepNames = ['set_cookie'];
-SetCookieStep.yamlMablScriptNames = ['SetCookie'];
+SetCookieStep.stepName = 'SetCookie';
+SetCookieStep.actionCode = 'set_cookie';
+SetCookieStep.mablScriptStepNames = [SetCookieStep.actionCode];
+SetCookieStep.yamlMablScriptNames = [SetCookieStep.stepName];

package/mablscript/steps/SetFilesStep.js

@@ -5,57 +5,33 @@ const FindAction_1 = require("../actions/FindAction");
 const MablAction_1 = require("../MablAction");
 const domUtil_1 = require("../../domUtil");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
+const ActionsUtils_1 = require("./ActionsUtils");
 class SetFilesStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'set_files');
-        this.files = this.getActionArgs();
-        this.validate();
-        this.findAction = this.actions[0];
-    }
-    validate() {
-        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
-            throw new Error('Set files steps should have exactly on sub action and it should be a find');
-        }
+    constructor(descriptor, findAction) {
+        super(SetFilesStep.stepName, descriptor, SetFilesStep.actionCode, findAction);
+        this.files = descriptor.files;
     }
     getStepName() {
-        return 'SetFiles';
+        return SetFilesStep.stepName;
     }
     toStepDescriptor() {
-        const formatted = {};
-        formatted.files = this.files;
-        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:
-                formatted.find = find;
-                formatted.descriptorToActionMap = new Map().set(find, this.findAction);
-                return formatted;
-            default:
-                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
-        }
-    }
-    getFormattedStep(_fullLocatorsOn) {
-        const step = {
-            SetFiles: {
-                ...super.annotationsAsYml(),
-                ...this.findAction.toYaml(),
-                files: this.files,
-            },
-        };
-        if (this.stepId()) {
-            step.SetFiles.id = this.stepId();
-        }
-        return step;
+        return buildStepDescriptor(this.findAction, this.files);
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new SetFilesStep('set_files', stepArgs.files, [
-            FindAction_1.FindAction.findActionFromStepArgs(stepArgs),
-        ]);
+        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+        const stepDescriptor = buildStepDescriptor(findAction, stepArgs.files);
+        const step = new SetFilesStep(stepDescriptor, findAction);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(args, actions) {
+        const files = args;
+        const findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(actions);
+        const stepDescriptor = buildStepDescriptor(findAction, files);
+        const step = new SetFilesStep(stepDescriptor, findAction);
+        step.actions = actions;
+        return step;
+    }
     toMablscript() {
         const files = this.files
             .map((key) => (0, MablAction_1.convertObjectToMablscriptArgs)(key))
@@ -65,7 +41,32 @@ class SetFilesStep extends MablStepWithFindAction_1.MablStepWithFindAction {
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
+    stepDescription() {
+        const fileCount = this.files.length;
+        const fileText = fileCount === 1 ? 'file' : 'files';
+        const elementDescription = this.humanizeFind();
+        return `Set ${fileCount} ${fileText} on ${elementDescription}`;
+    }
 }
 exports.SetFilesStep = SetFilesStep;
-SetFilesStep.mablScriptStepNames = ['set_files'];
-SetFilesStep.yamlMablScriptNames = ['SetFiles'];
+SetFilesStep.stepName = 'SetFiles';
+SetFilesStep.actionCode = 'set_files';
+SetFilesStep.mablScriptStepNames = [SetFilesStep.actionCode];
+SetFilesStep.yamlMablScriptNames = [SetFilesStep.stepName];
+function buildStepDescriptor(findAction, files) {
+    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 {
+                files,
+                find,
+                descriptorToActionMap: new Map().set(find, findAction),
+                actionCode: SetFilesStep.actionCode,
+            };
+        default:
+            throw new Error(`Error generating step descriptor for ${SetFilesStep.stepName}: Unexpected find type ${find.findType}`);
+    }
+}

package/mablscript/steps/SetViewportStep.js

@@ -1,22 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetViewportStep = void 0;
-const MablStep_1 = require("../MablStep");
-class SetViewportStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'set_viewport');
-        const viewportArg = this.getActionArgs()[0];
-        this.size = viewportArg?.size;
+const MablStepV2_1 = require("../MablStepV2");
+class SetViewportStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(SetViewportStep.stepName, descriptor, SetViewportStep.actionCode);
+        this.size = descriptor.size;
     }
     getStepName() {
-        return 'SetViewport';
+        return SetViewportStep.stepName;
     }
     toStepDescriptor() {
         return { size: this.size, actionCode: this.actionCode };
     }
-    static fromYaml(_stepName, stepArgs) {
-        const step = new SetViewportStep('set_viewport', [stepArgs], []);
-        step.setStepId(stepArgs.id);
+    static fromYaml(_stepName, stepDescriptor) {
+        return new SetViewportStep(stepDescriptor);
+    }
+    static fromLegacyMablscript(args, _actions) {
+        const stepDescriptor = {
+            size: {
+                width: args[0]?.size?.width ?? undefined,
+                height: args[0]?.size?.height ?? undefined,
+            },
+        };
+        const step = new SetViewportStep(stepDescriptor);
+        step.actions = _actions;
         return step;
     }
     toMablscript() {
@@ -32,7 +40,27 @@ class SetViewportStep extends MablStep_1.MablStep {
         }
         return `set_viewport(${sizeArg})`;
     }
+    stepDescription() {
+        if (this.size) {
+            let message = 'Set viewport size';
+            const width = this.size.width;
+            const height = this.size.height;
+            if (width) {
+                message += ` to width ${width}`;
+                if (height) {
+                    message += ` and height ${height}`;
+                }
+            }
+            else if (height) {
+                message += ` to height ${height}`;
+            }
+            return message;
+        }
+        return `Invalid set viewport step definition`;
+    }
 }
 exports.SetViewportStep = SetViewportStep;
-SetViewportStep.mablScriptStepNames = ['set_viewport'];
-SetViewportStep.yamlMablScriptNames = ['SetViewport'];
+SetViewportStep.stepName = 'SetViewport';
+SetViewportStep.actionCode = 'set_viewport';
+SetViewportStep.mablScriptStepNames = [SetViewportStep.actionCode];
+SetViewportStep.yamlMablScriptNames = [SetViewportStep.stepName];

package/mablscript/steps/StepGroupStep.js

@@ -0,0 +1,70 @@
+"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];