@mablhq/playwright-tools 2.49.1

package/mablscript/steps/ClickStep.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClickStep = void 0;
+const FindAction_1 = require("../actions/FindAction");
+const MablStep_1 = require("../MablStep");
+const domUtil_1 = require("../../domUtil");
+const ActionsUtils_1 = require("./ActionsUtils");
+class ClickStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'click');
+        this.findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(this.actions);
+    }
+    getStepName() {
+        return 'Click';
+    }
+    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 = {
+            Click: {
+                ...super.annotationsAsYml(),
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step.Click.id = this.stepId();
+        }
+        return step;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new ClickStep('click', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `${this.findAction.toMablscript()}.click()`;
+    }
+    getInputVariables() {
+        return this.findAction.getInputVariables();
+    }
+}
+exports.ClickStep = ClickStep;
+ClickStep.mablScriptStepNames = ['click'];
+ClickStep.yamlMablScriptNames = ['Click'];

package/mablscript/steps/CookieUtils.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CookieUtils = void 0;
+var CookieUtils;
+(function (CookieUtils) {
+    CookieUtils.validCookieNameCharacterRange = /^[\x21-\x7E]*$/;
+    CookieUtils.invalidCookieNameCharaters = /[()<>@,;:\\"\\/\[\]?={}]/;
+    CookieUtils.validCookieValueCharacters = /^(!|[\x23-\x2B]|[\x2D-\x3A]|[\x3C-\x5B]|[\x5D-\x7E])*$/;
+    function validateCookieName(name) {
+        const trimmed = name.trim();
+        if ('' === trimmed) {
+            return false;
+        }
+        if (!CookieUtils.validCookieNameCharacterRange.test(trimmed) ||
+            CookieUtils.invalidCookieNameCharaters.test(trimmed)) {
+            return false;
+        }
+        return true;
+    }
+    CookieUtils.validateCookieName = validateCookieName;
+    function normalizeName(name) {
+        const trimmed = name.trim();
+        if ('' === trimmed) {
+            throw new Error('Cookie name cannot be empty or include only whitespace characters');
+        }
+        return trimmed;
+    }
+    CookieUtils.normalizeName = normalizeName;
+    function validateCookieValue(value) {
+        const trimmed = value.trim();
+        if ('' === trimmed) {
+            return false;
+        }
+        if (!CookieUtils.validCookieValueCharacters.test(trimmed)) {
+            return false;
+        }
+        return true;
+    }
+    CookieUtils.validateCookieValue = validateCookieValue;
+    function normalizeValue(value) {
+        if (!value) {
+            throw new Error('Cookie value cannot be empty');
+        }
+        const trimmed = value.trim();
+        const bareValue = trimmed.startsWith('"') && trimmed.endsWith('"')
+            ? trimmed.substring(1, trimmed.length - 1)
+            : trimmed;
+        if ('' === bareValue) {
+            throw new Error('Cookie value cannot be empty or include only whitespace characters');
+        }
+        return trimmed;
+    }
+    CookieUtils.normalizeValue = normalizeValue;
+})(CookieUtils || (exports.CookieUtils = CookieUtils = {}));

package/mablscript/steps/CreateVariableStep.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCreateVariableStep = exports.CreateVariableStep = void 0;
+const domUtil_1 = require("../../domUtil");
+const CountAction_1 = require("../actions/CountAction");
+const ExtractAction_1 = require("../actions/ExtractAction");
+const FindAction_1 = require("../actions/FindAction");
+const GenerateEmailAddressAction_1 = require("../actions/GenerateEmailAddressAction");
+const GenerateRandomStringAction_1 = require("../actions/GenerateRandomStringAction");
+const JavaScriptAction_1 = require("../actions/JavaScriptAction");
+const MablStep_1 = require("../MablStep");
+const CreateVariableStepDescriptor_1 = require("../types/CreateVariableStepDescriptor");
+class CreateVariableStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'as');
+        this.variableName = this.getActionArgs()[0];
+        this.generationType = this.calculateGenerationType();
+    }
+    getStepName() {
+        return CreateVariableStep.stepName;
+    }
+    calculateGenerationType() {
+        if (this.actions.length === 2 && this.actions[0] instanceof FindAction_1.FindAction) {
+            if (this.actions[0].findDescriptor.findType === domUtil_1.FindType.FIND_COOKIE) {
+                return CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE;
+            }
+            if (this.actions[1] instanceof ExtractAction_1.ExtractAction) {
+                return CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE;
+            }
+            else if (this.actions[1] instanceof CountAction_1.CountAction) {
+                return CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT;
+            }
+        }
+        else if (this.actions.length === 1 &&
+            this.actions[0] instanceof GenerateEmailAddressAction_1.GenerateEmailAddressAction) {
+            return CreateVariableStepDescriptor_1.VariableGenerator.EMAIL;
+        }
+        else if (this.actions.length === 1 &&
+            this.actions[0] instanceof JavaScriptAction_1.JavaScriptAction) {
+            return CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT;
+        }
+        else if (this.actions.length === 1 &&
+            this.actions[0] instanceof GenerateRandomStringAction_1.GenerateRandomStringAction) {
+            return CreateVariableStepDescriptor_1.VariableGenerator.PATTERN;
+        }
+        throw new Error('Unsupported variable generation type');
+    }
+    toStepDescriptor() {
+        let step;
+        switch (this.generationType) {
+            case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
+                const cookieFindAction = this.actions[0];
+                const cookieFind = cookieFindAction.toDescriptor();
+                step = {
+                    name: this.variableName,
+                    generator: {
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE,
+                        cookieSelector: cookieFind.findTarget,
+                        attribute: this.actions[1].extractionAttribute,
+                    },
+                    find: cookieFind,
+                    descriptorToActionMap: new Map().set(cookieFind, cookieFindAction),
+                    actionCode: this.actionCode,
+                };
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
+                const findAction = this.actions[0];
+                const find = findAction.toDescriptor();
+                step = {
+                    name: this.variableName,
+                    generator: {
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE,
+                        attribute: this.actions[1].extractionAttribute,
+                        find,
+                    },
+                    find,
+                    descriptorToActionMap: new Map().set(find, findAction),
+                    actionCode: this.actionCode,
+                };
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
+                step = {
+                    name: this.variableName,
+                    generator: { type: CreateVariableStepDescriptor_1.VariableGenerator.EMAIL },
+                    actionCode: this.actionCode,
+                };
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT:
+                step = {
+                    name: this.variableName,
+                    generator: {
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT,
+                        javaScript: this.actions[0].javaScript,
+                    },
+                    actionCode: this.actionCode,
+                };
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.PATTERN:
+                step = {
+                    name: this.variableName,
+                    generator: {
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.PATTERN,
+                        pattern: this.actions[0]
+                            .generateString,
+                    },
+                    actionCode: this.actionCode,
+                };
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
+                const countFindAction = this.actions[0];
+                const countFind = countFindAction.toDescriptor();
+                step = {
+                    find: countFind,
+                    name: this.variableName,
+                    generator: {
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT,
+                        find: countFind,
+                    },
+                    descriptorToActionMap: new Map().set(countFind, countFindAction),
+                    actionCode: this.actionCode,
+                };
+                break;
+        }
+        return step;
+    }
+    getFormattedStep() {
+        var _a;
+        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;
+        }
+        switch (step.generator.type) {
+            case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
+                formatted[stepName] = {
+                    ...formatted[stepName],
+                    generator: step.generator,
+                    name: this.variableName,
+                    selector: step.generator.find.findTarget,
+                };
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
+                formatted[stepName] = {
+                    ...formatted[stepName],
+                    generator: step.generator,
+                    name: this.variableName,
+                    selector: step.generator.find.findTarget.selector,
+                    selectorAncestors: ((_a = step.generator.find.findTarget.auxiliaryDescriptors) !== null && _a !== void 0 ? _a : []).map((descriptor) => descriptor.selector),
+                };
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT:
+                formatted[stepName] = {
+                    ...formatted[stepName],
+                    generator: {
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT,
+                        javaScript: this.actions[0].toYaml(),
+                    },
+                    name: this.variableName,
+                };
+                break;
+            default:
+                formatted[stepName] = {
+                    ...formatted[stepName],
+                    generator: step.generator,
+                    name: this.variableName,
+                };
+        }
+        if (this.stepId()) {
+            formatted[stepName].id = this.stepId();
+        }
+        return formatted;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const variableName = stepArgs.name;
+        const generator = stepArgs.generator;
+        const generationType = generator.type;
+        const actions = [];
+        switch (generationType) {
+            case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
+                actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs));
+                const extractArgs = generator.metadata
+                    ? [generator.attribute, generator.metadata]
+                    : [generator.attribute];
+                actions.push(new ExtractAction_1.ExtractAction('extract_attribute', extractArgs));
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
+                actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs, domUtil_1.FindType.FIND_ALL));
+                actions.push(new CountAction_1.CountAction('count', []));
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
+                actions.push(new GenerateEmailAddressAction_1.GenerateEmailAddressAction('generate_email_address', []));
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT:
+                actions.push(JavaScriptAction_1.JavaScriptAction.fromYaml(generator.javaScript));
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.PATTERN:
+                actions.push(new GenerateRandomStringAction_1.GenerateRandomStringAction('generate_random_string', [
+                    generator.pattern,
+                ]));
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
+                actions.push(new FindAction_1.FindAction('find_cookie', [generator.cookieSelector]));
+                const extractCookieArgs = [generator.attribute];
+                actions.push(new ExtractAction_1.ExtractAction('extract_attribute', extractCookieArgs));
+                break;
+        }
+        const step = new CreateVariableStep('as', [variableName], actions);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `${this.actions.reduce((mablscript, action) => `${mablscript}${action.toMablscript()}.`, '')}as("${this.variableName}")`;
+    }
+    getInputVariables() {
+        return this.actions[0].getInputVariables();
+    }
+    getOutputVariables() {
+        return [this.variableName];
+    }
+}
+exports.CreateVariableStep = CreateVariableStep;
+CreateVariableStep.stepName = 'CreateVariable';
+CreateVariableStep.mablScriptStepNames = ['as'];
+CreateVariableStep.yamlMablScriptNames = ['CreateVariable', 'GenerateEmailAddress'];
+function isCreateVariableStep(value) {
+    return ((value === null || value === void 0 ? void 0 : value.getStepName) &&
+        value.getStepName() === CreateVariableStep.stepName &&
+        !!value.generationType);
+}
+exports.isCreateVariableStep = isCreateVariableStep;

package/mablscript/steps/DatabaseQueryStep.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDatabaseQueryStep = exports.DatabaseQueryVariableSource = exports.DatabaseQueryStep = void 0;
+const AbstractAssertionsAndVariablesStep_1 = require("./AbstractAssertionsAndVariablesStep");
+class DatabaseQueryStep extends AbstractAssertionsAndVariablesStep_1.AbstractAssertionsAndVariablesStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, DatabaseQueryStep.mablScriptStepNames[0], DatabaseQueryStep.stepName, args[0]);
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const formatted = stepArgs;
+        const step = new DatabaseQueryStep(DatabaseQueryStep.stepName, [formatted], []);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+}
+exports.DatabaseQueryStep = DatabaseQueryStep;
+DatabaseQueryStep.stepName = 'DatabaseQuery';
+DatabaseQueryStep.mablScriptStepNames = ['database_query'];
+DatabaseQueryStep.yamlMablScriptNames = [DatabaseQueryStep.stepName];
+var DatabaseQueryVariableSource;
+(function (DatabaseQueryVariableSource) {
+    DatabaseQueryVariableSource["Metadata"] = "metadata";
+    DatabaseQueryVariableSource["Result"] = "result";
+})(DatabaseQueryVariableSource || (exports.DatabaseQueryVariableSource = DatabaseQueryVariableSource = {}));
+function isDatabaseQueryStep(step) {
+    return step.getStepName() === DatabaseQueryStep.stepName;
+}
+exports.isDatabaseQueryStep = isDatabaseQueryStep;

package/mablscript/steps/DoubleClickStep.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleClickStep = void 0;
+const MablStep_1 = require("../MablStep");
+const FindAction_1 = require("../actions/FindAction");
+const domUtil_1 = require("../../domUtil");
+class DoubleClickStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'double_click');
+        this.validate();
+        this.findAction = this.actions[0];
+    }
+    validate() {
+        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
+            throw new Error('Double click steps should have exactly on sub action and it should be a find');
+        }
+    }
+    getStepName() {
+        return 'DoubleClick';
+    }
+    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_ALL:
+            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 = {
+            DoubleClick: {
+                ...super.annotationsAsYml(),
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step.DoubleClick.id = this.stepId();
+        }
+        return step;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new DoubleClickStep('double_click', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `${this.findAction.toMablscript()}.double_click()`;
+    }
+    getInputVariables() {
+        return this.findAction.getInputVariables();
+    }
+}
+exports.DoubleClickStep = DoubleClickStep;
+DoubleClickStep.mablScriptStepNames = ['double_click'];
+DoubleClickStep.yamlMablScriptNames = ['DoubleClick'];

package/mablscript/steps/DownloadStep.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DownloadStep = void 0;
+const MablStep_1 = require("../MablStep");
+const MablAction_1 = require("../MablAction");
+const AwaitDownloadAction_1 = require("../actions/AwaitDownloadAction");
+const AwaitPDFDownloadAction_1 = require("../actions/AwaitPDFDownloadAction");
+const domUtil_1 = require("../../domUtil");
+class DownloadStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        var _a;
+        super(name, args, actions, 'assert_download');
+        this.validate();
+        this.fileAttributes = ((_a = this.getActionArgs()[0]) !== null && _a !== void 0 ? _a : {});
+        this.awaitDownloadAction = this.actions[0];
+    }
+    validate() {
+        if (this.actions.length !== 1 &&
+            !(this.actions[0] instanceof AwaitDownloadAction_1.AwaitDownloadAction)) {
+            throw new Error('Download step should contain an await download sub action');
+        }
+    }
+    getStepName() {
+        if (this.isPDFDownload()) {
+            return 'DownloadPdfStep';
+        }
+        return 'DownloadStep';
+    }
+    isPDFDownload() {
+        return this.awaitDownloadAction instanceof AwaitPDFDownloadAction_1.AwaitPDFDownloadAction;
+    }
+    toStepDescriptor() {
+        const formatted = {};
+        if (this.isPDFDownload()) {
+            formatted.tabIdentifier = this.actions[0].pdfUUID;
+        }
+        if (this.fileAttributes.file_name !== undefined) {
+            formatted.fileName = this.fileAttributes.file_name;
+        }
+        if (this.fileAttributes.file_mime_type !== undefined) {
+            formatted.mimeType = this.fileAttributes.file_mime_type;
+        }
+        if (this.fileAttributes.file_md5 !== undefined) {
+            formatted.fileMd5 = this.fileAttributes.file_md5;
+        }
+        if (this.fileAttributes.file_sha256 !== undefined) {
+            formatted.fileSha256 = this.fileAttributes.file_sha256;
+        }
+        if (this.fileAttributes.file_size_bytes !== undefined) {
+            formatted.sizeBytes = this.fileAttributes.file_size_bytes;
+        }
+        if (this.fileAttributes.file_size_bytes_max !== undefined) {
+            formatted.sizeBytesMax = this.fileAttributes.file_size_bytes_max;
+        }
+        if (this.fileAttributes.file_size_bytes_min !== undefined) {
+            formatted.sizeBytesMin = this.fileAttributes.file_size_bytes_min;
+        }
+        return formatted;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const fileAttributes = {};
+        const assertDownload = stepArgs;
+        fileAttributes.file_name = assertDownload.fileName;
+        fileAttributes.file_mime_type = assertDownload.mimeType;
+        fileAttributes.file_md5 = assertDownload.fileMd5;
+        fileAttributes.file_sha256 = assertDownload.fileSha256;
+        fileAttributes.file_size_bytes = assertDownload.sizeBytes;
+        fileAttributes.file_size_bytes_max = assertDownload.sizeBytesMax;
+        fileAttributes.file_size_bytes_min = assertDownload.sizeBytesMin;
+        let awaitDownloadAction;
+        if (assertDownload.tabIdentifier) {
+            awaitDownloadAction = new AwaitPDFDownloadAction_1.AwaitPDFDownloadAction('await_pdf', [
+                { uuid: assertDownload.tabIdentifier },
+            ]);
+        }
+        else {
+            awaitDownloadAction = new AwaitDownloadAction_1.AwaitDownloadAction('await_download', []);
+        }
+        const step = new DownloadStep('assert_download', [fileAttributes], [awaitDownloadAction]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        const mablArgs = (0, domUtil_1.buildStepArgumentString)({
+            params: { ...this.fileAttributes },
+            legacy: true,
+        });
+        return `${this.awaitDownloadAction.toMablscript()}.assert_download(${mablArgs ? mablArgs : ''})`;
+    }
+    getInputVariables() {
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.fileAttributes);
+    }
+}
+exports.DownloadStep = DownloadStep;
+DownloadStep.mablScriptStepNames = ['assert_download'];
+DownloadStep.yamlMablScriptNames = ['DownloadStep', 'DownloadPdfStep'];

package/mablscript/steps/EchoStep.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EchoStep = void 0;
+const MablStep_1 = require("../MablStep");
+const domUtil_1 = require("../../domUtil");
+const MablAction_1 = require("../MablAction");
+class EchoStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'echo');
+        this.echoValue = (0, MablAction_1.parseArgument)(this.getActionArgs()[0]);
+    }
+    getStepName() {
+        return EchoStep.stepName;
+    }
+    toStepDescriptor() {
+        return { value: this.echoValue.toString(), actionCode: this.actionCode };
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new EchoStep(EchoStep.stepName, [stepArgs.value], []);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        const stringEchoValue = `${this.echoValue}`;
+        return `echo("${(0, domUtil_1.escapeMablscriptString)(stringEchoValue)}")`;
+    }
+    getInputVariables() {
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.echoValue);
+    }
+}
+exports.EchoStep = EchoStep;
+EchoStep.stepName = 'Echo';
+EchoStep.mablScriptStepNames = ['echo'];
+EchoStep.yamlMablScriptNames = [EchoStep.stepName];

package/mablscript/steps/ElseIfConditionStep.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isElseIfConditionStep = exports.ElseIfConditionStep = void 0;
+const MablAction_1 = require("../MablAction");
+const IfConditionStep_1 = require("./IfConditionStep");
+class ElseIfConditionStep extends IfConditionStep_1.IfConditionStep {
+    getStepName() {
+        return 'ElseIf';
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const actions = [
+            new MablAction_1.MablAction('conditional_else', 'conditional_else_if', []),
+        ];
+        actions.push(...IfConditionStep_1.IfConditionStep.getActionsFromYamlForCondition(stepArgs));
+        const step = new ElseIfConditionStep('conditional_else_if', [], actions);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        const actions = this.actions.reduce((mablscript, action) => `${mablscript}${action.toMablscript()}.`, '');
+        return `conditional_else()${actions}conditional_else_if()`;
+    }
+}
+exports.ElseIfConditionStep = ElseIfConditionStep;
+ElseIfConditionStep.stepName = 'conditional_else_if';
+ElseIfConditionStep.mablScriptStepNames = [ElseIfConditionStep.stepName];
+ElseIfConditionStep.yamlMablScriptNames = ['ElseIf'];
+function isElseIfConditionStep(value) {
+    return ((value === null || value === void 0 ? void 0 : value.getStepName) &&
+        (value === null || value === void 0 ? void 0 : value.getStepName()) === ElseIfConditionStep.yamlMablScriptNames[0]);
+}
+exports.isElseIfConditionStep = isElseIfConditionStep;

package/mablscript/steps/ElseStep.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElseStep = void 0;
+const MablStep_1 = require("../MablStep");
+class ElseStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'conditional_else');
+    }
+    getStepName() {
+        return 'Else';
+    }
+    toStepDescriptor() {
+        return { actionCode: this.actionCode };
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new ElseStep('conditional_else', [], []);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `conditional_else()`;
+    }
+}
+exports.ElseStep = ElseStep;
+ElseStep.stepName = 'conditional_else';
+ElseStep.mablScriptStepNames = [ElseStep.stepName];
+ElseStep.yamlMablScriptNames = ['Else'];

package/mablscript/steps/EndStep.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndStep = void 0;
+const MablStep_1 = require("../MablStep");
+class EndStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'conditional_end');
+    }
+    getStepName() {
+        return 'End';
+    }
+    toStepDescriptor() {
+        return { actionCode: this.actionCode };
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new EndStep('conditional_end', [], []);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `conditional_end()`;
+    }
+}
+exports.EndStep = EndStep;
+EndStep.stepName = 'conditional_end';
+EndStep.mablScriptStepNames = [EndStep.stepName];
+EndStep.yamlMablScriptNames = ['End'];