@mablhq/playwright-tools 2.49.1

package/mablscript/steps/EnterAuthCodeStep.js

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

package/mablscript/steps/EnterTextStep.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnterTextStep = void 0;
+const FindAction_1 = require("../actions/FindAction");
+const MablAction_1 = require("../MablAction");
+const MablStep_1 = require("../MablStep");
+const domUtil_1 = require("../../domUtil");
+class EnterTextStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'enter_text');
+        const arg = this.getActionArgs()[0];
+        this.text = (0, MablAction_1.parseArgument)(arg);
+        this.validate();
+        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])}`);
+        }
+    }
+    validate() {
+        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
+            throw new Error('Enter text steps should have exactly on sub action and it should be a find');
+        }
+    }
+    getStepName() {
+        return 'EnterText';
+    }
+    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),
+                    text: this.text,
+                    actionCode: this.actionCode,
+                };
+            default:
+                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
+        }
+    }
+    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;
+        }
+        if (step.find.findType === domUtil_1.FindType.FIND_ONE) {
+            formatted[stepName].selector = step.find.findTarget.selector;
+            if ((_a = step.find.findTarget.auxiliaryDescriptors) === null || _a === void 0 ? void 0 : _a.length) {
+                formatted[stepName].selectorAncestors =
+                    step.find.findTarget.auxiliaryDescriptors.map((descriptor) => descriptor.selector);
+            }
+        }
+        else {
+            formatted[stepName].selector = step.find.findTarget;
+        }
+        formatted[stepName].findType = FindAction_1.findTypesToFormattedType[step.find.findType];
+        formatted[stepName].text = this.text.toString();
+        if (this.stepId()) {
+            formatted[stepName].id = this.stepId();
+        }
+        return formatted;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new EnterTextStep('enter_text', [stepArgs.text], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        const enterText = typeof this.text === 'string'
+            ? `"${(0, domUtil_1.escapeMablscriptString)(this.text)}"`
+            : this.substituteMablscriptVariable(this.text);
+        return `${this.findAction.toMablscript()}.enter_text(${enterText})`;
+    }
+    getInputVariables() {
+        return (0, MablAction_1.distinctStrings)([
+            ...this.findAction.getInputVariables(),
+            ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.text),
+        ]);
+    }
+}
+exports.EnterTextStep = EnterTextStep;
+EnterTextStep.mablScriptStepNames = ['enter_text'];
+EnterTextStep.yamlMablScriptNames = ['EnterText'];

package/mablscript/steps/EvaluateFlowStep.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEvaluateFlowStep = exports.EvaluateFlowStep = exports.EVALUATE_FLOW_STEP_NAME = void 0;
+const domUtil_1 = require("../../domUtil");
+const MablStep_1 = require("../MablStep");
+exports.EVALUATE_FLOW_STEP_NAME = 'EvaluateFlow';
+class EvaluateFlowStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'evaluate_flow');
+        if (args.length < 1 || args.length > 2) {
+            throw new Error('EvaluateFlowStep expects 1 or 2 arguments');
+        }
+        this.flowDescriptor = this.getActionArgs()[0];
+        if (args.length === 2) {
+            this.config = this.getActionArgs()[1];
+        }
+    }
+    getStepName() {
+        return exports.EVALUATE_FLOW_STEP_NAME;
+    }
+    toStepDescriptor() {
+        return {
+            descriptor: this.flowDescriptor,
+            config: this.config,
+            actionCode: this.actionCode,
+        };
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const { descriptor, config } = stepArgs;
+        const step = new EvaluateFlowStep(EvaluateFlowStep.mablScriptStepNames[0], [descriptor, config], []);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        const flowReference = (0, domUtil_1.buildStepArgumentString)({
+            params: { ...this.flowDescriptor },
+            legacy: true,
+        });
+        const flowConfig = this.config
+            ? ', ' + (0, domUtil_1.buildStepArgumentString)({ params: { ...this.config }, legacy: true })
+            : '';
+        return `${EvaluateFlowStep.mablScriptStepNames[0]}(${flowReference}${flowConfig})`;
+    }
+}
+exports.EvaluateFlowStep = EvaluateFlowStep;
+EvaluateFlowStep.mablScriptStepNames = ['evaluate_flow'];
+EvaluateFlowStep.yamlMablScriptNames = [exports.EVALUATE_FLOW_STEP_NAME];
+function isEvaluateFlowStep(step) {
+    return (step === null || step === void 0 ? void 0 : step.getStepName()) === exports.EVALUATE_FLOW_STEP_NAME;
+}
+exports.isEvaluateFlowStep = isEvaluateFlowStep;

package/mablscript/steps/EvaluateJavaScriptStep.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEvaluateJavaScriptStep = exports.EvaluateJavaScriptStep = void 0;
+const MablStep_1 = require("../MablStep");
+const JavaScriptAction_1 = require("../actions/JavaScriptAction");
+const STEP_NAME = 'EvaluateJavaScript';
+class EvaluateJavaScriptStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions || [], 'evaluate_js');
+        this.evaluateJsAction = new JavaScriptAction_1.JavaScriptAction(JavaScriptAction_1.JavaScriptAction.mablscriptName, args);
+    }
+    getStepName() {
+        return STEP_NAME;
+    }
+    toStepDescriptor() {
+        return this.evaluateJsAction.toDescriptor();
+    }
+    getFormattedStep() {
+        const step = {
+            [STEP_NAME]: {
+                ...super.annotationsAsYml(),
+                ...this.evaluateJsAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step[STEP_NAME].id = this.stepId();
+        }
+        return step;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const evaluateJsAction = JavaScriptAction_1.JavaScriptAction.fromYaml(stepArgs);
+        const step = new EvaluateJavaScriptStep(evaluateJsAction.name, evaluateJsAction.args);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return this.evaluateJsAction.toMablscript();
+    }
+    getInputVariables() {
+        return this.evaluateJsAction.getInputVariables();
+    }
+}
+exports.EvaluateJavaScriptStep = EvaluateJavaScriptStep;
+EvaluateJavaScriptStep.stepName = STEP_NAME;
+EvaluateJavaScriptStep.mablScriptStepNames = [JavaScriptAction_1.JavaScriptAction.mablscriptName];
+EvaluateJavaScriptStep.yamlMablScriptNames = [STEP_NAME];
+function isEvaluateJavaScriptStep(value) {
+    return (value === null || value === void 0 ? void 0 : value.getStepName) && (value === null || value === void 0 ? void 0 : value.getStepName()) === STEP_NAME;
+}
+exports.isEvaluateJavaScriptStep = isEvaluateJavaScriptStep;

package/mablscript/steps/HoverStep.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverStep = void 0;
+const FindAction_1 = require("../actions/FindAction");
+const MablStep_1 = require("../MablStep");
+const domUtil_1 = require("../../domUtil");
+class HoverStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'hover');
+        this.validate();
+        this.findAction = this.actions[0];
+    }
+    validate() {
+        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
+            throw new Error('Hover steps should have exactly on sub action and it should be a find');
+        }
+    }
+    getStepName() {
+        return 'Hover';
+    }
+    toStepDescriptor() {
+        const find = this.findAction.toDescriptor();
+        switch (find.findType) {
+            case domUtil_1.FindType.FIND_FIRST:
+            case domUtil_1.FindType.FIND_LAST:
+            case domUtil_1.FindType.FIND_ANY:
+            case domUtil_1.FindType.FIND_ONE:
+                return {
+                    find,
+                    descriptorToActionMap: new Map().set(find, this.findAction),
+                    actionCode: this.actionCode,
+                };
+            default:
+                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
+        }
+    }
+    getFormattedStep(_fullLocatorsOn) {
+        const step = {
+            Hover: {
+                ...super.annotationsAsYml(),
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step.Hover.id = this.stepId();
+        }
+        return step;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new HoverStep('hover', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `${this.findAction.toMablscript()}.hover()`;
+    }
+    getInputVariables() {
+        return this.findAction.getInputVariables();
+    }
+}
+exports.HoverStep = HoverStep;
+HoverStep.mablScriptStepNames = ['hover'];
+HoverStep.yamlMablScriptNames = ['Hover'];

package/mablscript/steps/IfConditionStep.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIfConditionStep = exports.IfConditionStep = void 0;
+const ConditionAction_1 = require("../actions/ConditionAction");
+const GetVariableValue_1 = require("../actions/GetVariableValue");
+const AssertStep_1 = require("./AssertStep");
+const FindAction_1 = require("../actions/FindAction");
+const MablAction_1 = require("../MablAction");
+const MablStep_1 = require("../MablStep");
+const ExtractAction_1 = require("../actions/ExtractAction");
+const domUtil_1 = require("../../domUtil");
+const JavaScriptAction_1 = require("../actions/JavaScriptAction");
+const GetUrlAction_1 = require("../actions/GetUrlAction");
+const ConditionDescriptor_1 = require("../types/ConditionDescriptor");
+class IfConditionStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'conditional_if');
+        const candidatePrimaryActions = actions.filter((action) => action instanceof FindAction_1.FindAction ||
+            action instanceof GetVariableValue_1.GetVariableValue ||
+            action instanceof GetUrlAction_1.GetUrlAction ||
+            action instanceof JavaScriptAction_1.JavaScriptAction);
+        if (candidatePrimaryActions.length > 1) {
+            throw new Error(`Too many primary actions. Only one primary action is allowed of: Find, Get Url, Get Variable, or Javascript actions`);
+        }
+        if (candidatePrimaryActions[0] === undefined) {
+            throw new Error(`At least one primary action is required: Find, Get Url, Get Variable, or Javascript action.`);
+        }
+        this.primaryAction = candidatePrimaryActions[0];
+        this.conditionAction = actions.find((action) => action instanceof ConditionAction_1.ConditionAction);
+        this.extractAction = actions.find((action) => action instanceof ExtractAction_1.ExtractAction);
+    }
+    getStepName() {
+        return 'If';
+    }
+    toStepDescriptor() {
+        var _a, _b;
+        const conditionDescriptor = this.conditionAction !== undefined
+            ? (_a = this.conditionAction) === null || _a === void 0 ? void 0 : _a.conditionDescriptor
+            : { conditionType: ConditionDescriptor_1.ConditionType.Truthy };
+        const find = this.primaryAction.toDescriptor();
+        return {
+            find,
+            extractDescriptor: (_b = this.extractAction) === null || _b === void 0 ? void 0 : _b.extractDescriptor,
+            conditionDescriptor,
+            onFailure: AssertStep_1.OnFailure.FailImmediately,
+            descriptorToActionMap: new Map().set(find, this.primaryAction),
+            actionCode: this.actionCode,
+        };
+    }
+    getFormattedStep(_fullLocatorsOn) {
+        const result = {};
+        result[this.getStepName()] = this.toYamlConditionDetails();
+        if (this.stepId()) {
+            result[this.getStepName()].id = this.stepId();
+        }
+        return result;
+    }
+    toYamlConditionDetails() {
+        const details = {
+            ...super.annotationsAsYml(),
+        };
+        if (this.conditionAction) {
+            details.condition =
+                ConditionDescriptor_1.AssertionConditionFieldToStepName[(0, ConditionDescriptor_1.getAssertionConditionFieldFromDescriptor)(this.conditionAction.conditionDescriptor)];
+            details.conditionValue = (0, ConditionDescriptor_1.getOptionalComparatorValue)(this.conditionAction.conditionDescriptor);
+            const optionalConditionOptions = (0, ConditionDescriptor_1.getOptionalConditionOptions)(this.conditionAction.conditionDescriptor);
+            details.conditionOptions = this.conditionAction.hasOptionsAtInstantiation
+                ? optionalConditionOptions
+                : undefined;
+            if (this.conditionAction.conditionDescriptor.conditionType ===
+                ConditionDescriptor_1.ConditionType.AIPrompt) {
+                details.aiPrompt = {
+                    userPrompt: this.conditionAction.conditionDescriptor.userPrompt,
+                    metaPrompt: this.conditionAction.conditionDescriptor.metaPrompt,
+                    criteria: this.conditionAction.conditionDescriptor.criteria,
+                };
+            }
+        }
+        if (this.primaryAction instanceof GetVariableValue_1.GetVariableValue) {
+            details.variableName = this.substituteMablscriptVariable(this.primaryAction.variable);
+        }
+        if (this.primaryAction instanceof JavaScriptAction_1.JavaScriptAction) {
+            const jsYaml = JavaScriptAction_1.JavaScriptAction.toYamlFromJavaScriptDescriptor(this.primaryAction.javaScript);
+            if (jsYaml.snippet) {
+                details.snippet = jsYaml.snippet;
+                details.snippet.parameterOverrides = jsYaml.parameterOverrides;
+            }
+            else {
+                details.snippet = jsYaml;
+            }
+        }
+        if (this.extractAction) {
+            details.attribute = this.extractAction.extractionAttribute;
+        }
+        if (this.primaryAction instanceof FindAction_1.FindAction) {
+            const find = this.primaryAction.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:
+                    details.selector = find.findTarget;
+                    break;
+                case domUtil_1.FindType.FIND_ONE:
+                    details.selector = find.findTarget.selector;
+                    if (find.findOptions) {
+                        details.findOptions = find.findOptions;
+                    }
+                    break;
+            }
+        }
+        return details;
+    }
+    static getActionsFromYamlForCondition(stepArgs) {
+        var _a, _b, _c, _d, _e;
+        const actions = [];
+        if (stepArgs.selector) {
+            const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+            actions.push(findAction);
+        }
+        if (stepArgs.attribute) {
+            const extractArgs = stepArgs.metadata
+                ? [stepArgs.attribute, stepArgs.metadata]
+                : [stepArgs.attribute];
+            actions.push(new ExtractAction_1.ExtractAction('extract_attribute', extractArgs));
+        }
+        if (stepArgs.variableName) {
+            actions.push(new GetVariableValue_1.GetVariableValue('get_variable_value', [
+                `{{@${stepArgs.variableName}}}`,
+            ]));
+        }
+        if (stepArgs.snippet) {
+            actions.push(JavaScriptAction_1.JavaScriptAction.fromYaml(stepArgs.snippet));
+        }
+        if (stepArgs.condition) {
+            const conditionType = ConditionDescriptor_1.AssertionStepNameToField[stepArgs.condition];
+            if (conditionType === 'ai_prompt') {
+                actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType(conditionType), [
+                    (_b = (_a = stepArgs.aiPrompt) === null || _a === void 0 ? void 0 : _a.userPrompt) !== null && _b !== void 0 ? _b : stepArgs.userPrompt,
+                    {
+                        metaPrompt: (_d = (_c = stepArgs.aiPrompt) === null || _c === void 0 ? void 0 : _c.metaPrompt) !== null && _d !== void 0 ? _d : stepArgs.metaPrompt,
+                        criteria: (_e = stepArgs.aiPrompt) === null || _e === void 0 ? void 0 : _e.criteria,
+                    },
+                ]));
+            }
+            else {
+                actions.push(new ConditionAction_1.ConditionAction(this.getConditionActionNameForConditionType(conditionType), [
+                    ConditionDescriptor_1.AssertionStepNameToField[stepArgs.condition],
+                    stepArgs.conditionValue,
+                    stepArgs.conditionOptions,
+                ]));
+            }
+        }
+        return actions;
+    }
+    static getConditionActionNameForConditionType(conditionType) {
+        if (conditionType === 'present' || conditionType === 'not_present') {
+            return 'evaluate_presence';
+        }
+        else if (conditionType === 'ai_prompt') {
+            return 'evaluate_ai_prompt';
+        }
+        return 'evaluate_condition';
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const actions = IfConditionStep.getActionsFromYamlForCondition(stepArgs);
+        const step = new IfConditionStep('conditional_if', [], actions);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `${this.actions.reduce((mablscript, action) => `${mablscript}${action.toMablscript()}.`, '')}conditional_if()`;
+    }
+    getInputVariables() {
+        var _a, _b, _c, _d;
+        return (0, MablAction_1.distinctStrings)([
+            ...this.primaryAction.getInputVariables(),
+            ...((_b = (_a = this.conditionAction) === null || _a === void 0 ? void 0 : _a.getInputVariables()) !== null && _b !== void 0 ? _b : []),
+            ...((_d = (_c = this.extractAction) === null || _c === void 0 ? void 0 : _c.getInputVariables()) !== null && _d !== void 0 ? _d : []),
+        ]);
+    }
+}
+exports.IfConditionStep = IfConditionStep;
+IfConditionStep.stepName = 'conditional_if';
+IfConditionStep.mablScriptStepNames = [IfConditionStep.stepName];
+IfConditionStep.yamlMablScriptNames = ['If'];
+function isIfConditionStep(value) {
+    return ((value === null || value === void 0 ? void 0 : value.getStepName) &&
+        (value === null || value === void 0 ? void 0 : value.getStepName()) === IfConditionStep.yamlMablScriptNames[0]);
+}
+exports.isIfConditionStep = isIfConditionStep;

package/mablscript/steps/NavigateStep.js

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

package/mablscript/steps/OpenEmailStep.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenEmailStep = void 0;
+const FindAction_1 = require("../actions/FindAction");
+const MablStep_1 = require("../MablStep");
+class OpenEmailStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, OpenEmailStep.stepName);
+        this.tabUuid = this.getActionArgs()[0] || {};
+        this.validate();
+        this.findAction = this.actions[0];
+    }
+    validate() {
+        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
+            throw new Error('Open email steps should have exactly one sub action and it should be a find');
+        }
+    }
+    getStepName() {
+        return 'OpenEmail';
+    }
+    toStepDescriptor() {
+        const find = this.findAction.toDescriptor();
+        return {
+            tab: this.tabUuid,
+            selector: find.findTarget.selector,
+            findType: 'FindEmail',
+            configuration: find.findTarget.configuration,
+            actionCode: this.actionCode,
+        };
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new OpenEmailStep(OpenEmailStep.stepName, [stepArgs.tab], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `${this.findAction.toMablscript()}.open_email("${this.tabUuid}")`;
+    }
+    getInputVariables() {
+        return this.findAction.getInputVariables();
+    }
+}
+exports.OpenEmailStep = OpenEmailStep;
+OpenEmailStep.stepName = 'open_email';
+OpenEmailStep.mablScriptStepNames = [OpenEmailStep.stepName];
+OpenEmailStep.yamlMablScriptNames = ['OpenEmail'];

package/mablscript/steps/ReleaseStep.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseStep = void 0;
+const FindAction_1 = require("../actions/FindAction");
+const MablStep_1 = require("../MablStep");
+const MablAction_1 = require("../MablAction");
+const domUtil_1 = require("../../domUtil");
+const ActionsUtils_1 = require("./ActionsUtils");
+const ReleaseStepDescriptor_1 = require("../types/ReleaseStepDescriptor");
+class ReleaseStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        var _a;
+        super(name, args, actions, 'release');
+        this.findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(this.actions);
+        this.releaseArgs = (_a = this.parseArgs(args)) !== null && _a !== void 0 ? _a : { isHtml5: false };
+    }
+    parseArgs(args) {
+        if (args.length === 0) {
+            return undefined;
+        }
+        if (args.length !== 1) {
+            throw new Error(`Unexpected number of arguments to ${this.getStepName()} step.`);
+        }
+        if (!(0, ReleaseStepDescriptor_1.isReleaseArgs)(args[0])) {
+            throw new Error(`Invalid argument passed to ${this.getStepName()} step.`);
+        }
+        return args[0];
+    }
+    getStepName() {
+        return 'Release';
+    }
+    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,
+                    releaseArgs: this.releaseArgs,
+                };
+            default:
+                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
+        }
+    }
+    getFormattedStep(_fullLocatorsOn) {
+        const step = {
+            Release: {
+                ...super.annotationsAsYml(),
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step.Release.id = this.stepId();
+        }
+        return step;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new ReleaseStep('release', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        const args = (0, MablAction_1.convertObjectToMablscriptArgs)(this.releaseArgs);
+        return `${this.findAction.toMablscript()}.release(${args})`;
+    }
+    getInputVariables() {
+        return this.findAction.getInputVariables();
+    }
+}
+exports.ReleaseStep = ReleaseStep;
+ReleaseStep.mablScriptStepNames = ['release'];
+ReleaseStep.yamlMablScriptNames = ['Release'];