@mablhq/playwright-tools 2.49.1

package/mablscript/steps/RemoveCookieStep.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveCookieStep = void 0;
+const MablStep_1 = require("../MablStep");
+const MablAction_1 = require("../MablAction");
+const CookieUtils_1 = require("./CookieUtils");
+const domUtil_1 = require("../../domUtil");
+class RemoveCookieStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'remove_cookie');
+        this.cookieName = CookieUtils_1.CookieUtils.normalizeName(this.getActionArgs()[0].name);
+    }
+    getStepName() {
+        return 'RemoveCookie';
+    }
+    toStepDescriptor() {
+        return {
+            name: this.cookieName,
+            actionCode: this.actionCode,
+        };
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new RemoveCookieStep('remove_cookie', [stepArgs], []);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `remove_cookie({ name : "${(0, domUtil_1.escapeMablscriptString)(this.cookieName)}" })`;
+    }
+    getInputVariables() {
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.cookieName);
+    }
+}
+exports.RemoveCookieStep = RemoveCookieStep;
+RemoveCookieStep.mablScriptStepNames = ['remove_cookie'];
+RemoveCookieStep.yamlMablScriptNames = ['RemoveCookie'];

package/mablscript/steps/RightClickStep.js

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

package/mablscript/steps/SelectStep.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectStep = void 0;
+const FindAction_1 = require("../actions/FindAction");
+const MablAction_1 = require("../MablAction");
+const MablStep_1 = require("../MablStep");
+const domUtil_1 = require("../../domUtil");
+class SelectStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'select');
+        this.selectOptions = this.getActionArgs()[0];
+        this.selectOptionType = this.getActionArgs()[1];
+        this.validate();
+        this.findAction = this.actions[0];
+    }
+    validate() {
+        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
+            throw new Error('Select steps should have exactly on sub action and it should be a find');
+        }
+    }
+    getStepName() {
+        return 'Select';
+    }
+    toStepDescriptor() {
+        const selectOptionsCopy = this.selectOptions;
+        selectOptionsCopy.selectOptionType = this.selectOptionType;
+        const formatted = { ...selectOptionsCopy };
+        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}`);
+        }
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+        const selectOptionType = stepArgs.selectOptionType;
+        delete stepArgs.selector;
+        delete stepArgs.selectorAncestors;
+        delete stepArgs.selectOptionType;
+        const selectOptions = stepArgs;
+        const step = new SelectStep('select', [selectOptions, selectOptionType], [findAction]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    getFormattedStep(_fullLocatorsOn) {
+        const step = this.selectOptions;
+        const { find, ...ymlStep } = step;
+        const finalStep = {
+            Select: {
+                ...ymlStep,
+                ...super.annotationsAsYml(),
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            finalStep.Select.id = this.stepId();
+        }
+        return finalStep;
+    }
+    toMablscript() {
+        const selectOptionType = this.selectOptionType
+            ? `, "${this.selectOptionType}"`
+            : '';
+        return `${this.findAction.toMablscript()}.select(${(0, MablAction_1.convertObjectToMablscriptArgs)(this.selectOptions)}${selectOptionType})`;
+    }
+    getInputVariables() {
+        return (0, MablAction_1.distinctStrings)([
+            ...this.findAction.getInputVariables(),
+            ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.selectOptions),
+        ]);
+    }
+}
+exports.SelectStep = SelectStep;
+SelectStep.mablScriptStepNames = ['select'];
+SelectStep.yamlMablScriptNames = ['Select'];

package/mablscript/steps/SendHttpRequestStep.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendHttpRequestVariableSource = exports.SendHttpRequestStep = void 0;
+const ConditionDescriptor_1 = require("../types/ConditionDescriptor");
+const AbstractAssertionsAndVariablesStep_1 = require("./AbstractAssertionsAndVariablesStep");
+class SendHttpRequestStep extends AbstractAssertionsAndVariablesStep_1.AbstractAssertionsAndVariablesStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'send_http_request', SendHttpRequestStep.stepName, args[0]);
+    }
+    static fromYaml(_stepName, stepArgs) {
+        var _a;
+        const formatted = stepArgs;
+        const comparisonTypeConverter = {
+            Equals: ConditionDescriptor_1.AssertionConditionField.Equals,
+            DoesNotEqual: ConditionDescriptor_1.AssertionConditionField.DoesNotEqual,
+            Contains: ConditionDescriptor_1.AssertionConditionField.Contains,
+            DoesNotContain: ConditionDescriptor_1.AssertionConditionField.DoesNotContain,
+            StartsWith: ConditionDescriptor_1.AssertionConditionField.StartsWith,
+            StartsWithout: ConditionDescriptor_1.AssertionConditionField.StartsWithout,
+            EndsWith: ConditionDescriptor_1.AssertionConditionField.EndsWith,
+            EndsWithout: ConditionDescriptor_1.AssertionConditionField.EndsWithout,
+            GreaterThan: ConditionDescriptor_1.AssertionConditionField.GreaterThan,
+            LessThan: ConditionDescriptor_1.AssertionConditionField.LessThan,
+            GreaterThanOrEquals: ConditionDescriptor_1.AssertionConditionField.GreaterThanOrEquals,
+            LessThanOrEquals: ConditionDescriptor_1.AssertionConditionField.LessThanOrEquals,
+        };
+        (_a = formatted.assertions) === null || _a === void 0 ? void 0 : _a.forEach((assertion) => {
+            if (assertion.assertion in comparisonTypeConverter) {
+                assertion.assertion = comparisonTypeConverter[assertion.assertion];
+            }
+        });
+        const step = new SendHttpRequestStep(SendHttpRequestStep.stepName, [formatted], []);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+}
+exports.SendHttpRequestStep = SendHttpRequestStep;
+SendHttpRequestStep.stepName = 'SendHttpRequest';
+SendHttpRequestStep.mablScriptStepNames = ['send_http_request'];
+SendHttpRequestStep.yamlMablScriptNames = [SendHttpRequestStep.stepName];
+var SendHttpRequestVariableSource;
+(function (SendHttpRequestVariableSource) {
+    SendHttpRequestVariableSource["Body"] = "body";
+    SendHttpRequestVariableSource["Header"] = "header";
+    SendHttpRequestVariableSource["Json"] = "json";
+    SendHttpRequestVariableSource["Response"] = "response";
+    SendHttpRequestVariableSource["Status"] = "status";
+})(SendHttpRequestVariableSource || (exports.SendHttpRequestVariableSource = SendHttpRequestVariableSource = {}));

package/mablscript/steps/SendKeyStep.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendKeyStep = void 0;
+const FindAction_1 = require("../actions/FindAction");
+const MablStep_1 = require("../MablStep");
+const domUtil_1 = require("../../domUtil");
+const SendKeyStepDescriptor_1 = require("../types/SendKeyStepDescriptor");
+const STEP_NAME = 'SendKeys';
+class SendKeyStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'send_keys');
+        if (this.actions.length !== 1 && !(this.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])}`);
+        }
+        const keys = this.getActionArgs();
+        if (!(keys === null || keys === void 0 ? void 0 : keys.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)}`);
+        }
+    }
+    getStepName() {
+        return STEP_NAME;
+    }
+    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}`);
+        }
+    }
+    getFormattedStep() {
+        const step = {
+            [STEP_NAME]: {
+                ...super.annotationsAsYml(),
+                sendKeys: this.keys,
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step[STEP_NAME].id = this.stepId();
+        }
+        return step;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new SendKeyStep('send_keys', stepArgs.sendKeys, [
+            FindAction_1.FindAction.findActionFromStepArgs(stepArgs),
+        ]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        const keysToSend = this.keys
+            .map((key) => (0, domUtil_1.buildStepArgumentString)({ params: { ...key }, legacy: true }))
+            .join();
+        return `${this.findAction.toMablscript()}.send_keys(${keysToSend})`;
+    }
+    getInputVariables() {
+        return this.findAction.getInputVariables();
+    }
+}
+exports.SendKeyStep = SendKeyStep;
+SendKeyStep.mablScriptStepNames = ['send_keys'];
+SendKeyStep.yamlMablScriptNames = ['SendKeys'];

package/mablscript/steps/SetCookieStep.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetCookieStep = void 0;
+const MablStep_1 = require("../MablStep");
+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;
+        }
+    }
+    getStepName() {
+        return 'SetCookie';
+    }
+    toStepDescriptor() {
+        return {
+            name: this.cookieName,
+            value: this.cookieValue,
+            options: this.cookieOptions,
+            actionCode: this.actionCode,
+        };
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new SetCookieStep('set_cookie', [stepArgs], []);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const cookieSelector = {
+            name: this.cookieName,
+            value: this.cookieValue,
+            domain: (_a = this.cookieOptions) === null || _a === void 0 ? void 0 : _a.domain,
+            path: (_b = this.cookieOptions) === null || _b === void 0 ? void 0 : _b.path,
+            expiry: (_c = this.cookieOptions) === null || _c === void 0 ? void 0 : _c.expires,
+            http_only: (_d = this.cookieOptions) === null || _d === void 0 ? void 0 : _d.httpOnly,
+            secure: (_e = this.cookieOptions) === null || _e === void 0 ? void 0 : _e.secure,
+            same_site: (_f = this.cookieOptions) === null || _f === void 0 ? void 0 : _f.sameSite,
+            url: (_g = this.cookieOptions) === null || _g === void 0 ? void 0 : _g.url,
+        };
+        return `set_cookie(${(0, domUtil_1.buildStepArgumentString)({
+            params: cookieSelector,
+            legacy: false,
+        })})`;
+    }
+    getInputVariables() {
+        return (0, MablAction_1.distinctStrings)([
+            ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.cookieName),
+            ...MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.cookieValue),
+        ]);
+    }
+}
+exports.SetCookieStep = SetCookieStep;
+SetCookieStep.mablScriptStepNames = ['set_cookie'];
+SetCookieStep.yamlMablScriptNames = ['SetCookie'];

package/mablscript/steps/SetFilesStep.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetFilesStep = void 0;
+const FindAction_1 = require("../actions/FindAction");
+const MablAction_1 = require("../MablAction");
+const MablStep_1 = require("../MablStep");
+const domUtil_1 = require("../../domUtil");
+class SetFilesStep extends MablStep_1.MablStep {
+    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');
+        }
+    }
+    getStepName() {
+        return 'SetFiles';
+    }
+    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;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new SetFilesStep('set_files', stepArgs.files, [
+            FindAction_1.FindAction.findActionFromStepArgs(stepArgs),
+        ]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        const files = this.files
+            .map((key) => (0, MablAction_1.convertObjectToMablscriptArgs)(key))
+            .join(', ');
+        return `${this.findAction.toMablscript()}.set_files(${files})`;
+    }
+    getInputVariables() {
+        return this.findAction.getInputVariables();
+    }
+}
+exports.SetFilesStep = SetFilesStep;
+SetFilesStep.mablScriptStepNames = ['set_files'];
+SetFilesStep.yamlMablScriptNames = ['SetFiles'];

package/mablscript/steps/SetViewportStep.js

@@ -0,0 +1,38 @@
+"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 === null || viewportArg === void 0 ? void 0 : viewportArg.size;
+    }
+    getStepName() {
+        return 'SetViewport';
+    }
+    toStepDescriptor() {
+        return { size: this.size, actionCode: this.actionCode };
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new SetViewportStep('set_viewport', [stepArgs], []);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        let sizeArg;
+        if (this.size.height && this.size.width) {
+            sizeArg = `{ size : { width : ${this.size.width}, height : ${this.size.height} } }`;
+        }
+        else if (this.size.width) {
+            sizeArg = `{ size : { width : ${this.size.width} } }`;
+        }
+        else if (this.size.height) {
+            sizeArg = `{ size : { height : ${this.size.height} } }`;
+        }
+        return `set_viewport(${sizeArg})`;
+    }
+}
+exports.SetViewportStep = SetViewportStep;
+SetViewportStep.mablScriptStepNames = ['set_viewport'];
+SetViewportStep.yamlMablScriptNames = ['SetViewport'];

package/mablscript/steps/SwitchContextStep.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchContextStep = void 0;
+const FindAction_1 = require("../actions/FindAction");
+const MablStep_1 = require("../MablStep");
+const SwitchContextStepDescriptor_1 = require("../types/SwitchContextStepDescriptor");
+const domUtil_1 = require("../../domUtil");
+class SwitchContextStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'switch_context_to');
+        const maybeRoot = this.getActionArgs()[0];
+        if (maybeRoot !== undefined && maybeRoot !== 'root') {
+            throw new Error(`Unexpected argument for ${name} step: ${JSON.stringify(maybeRoot)}`);
+        }
+        if (maybeRoot === 'root') {
+            this.switch = {
+                frame: 'root',
+                actionCode: this.actionCode,
+            };
+            Object.freeze(this.switch);
+            return;
+        }
+        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 (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 ||
+            (this.actions.length === 1 && !(this.actions[0] instanceof FindAction_1.FindAction))) {
+            throw new Error('Invalid switch context step');
+        }
+    }
+    getStepName() {
+        return 'SwitchContext';
+    }
+    toStepDescriptor() {
+        return this.switch;
+    }
+    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 ((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 ((_a = step.frame.findTarget.auxiliaryDescriptors) === null || _a === void 0 ? void 0 : _a.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) {
+            step = new SwitchContextStep('switch_context_to', [stepArgs.switch], []);
+        }
+        else {
+            step = new SwitchContextStep('switch_context_to', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        }
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        var _a;
+        if ((0, SwitchContextStepDescriptor_1.isSwitchRoot)(this.switch) && this.switch.frame === 'root') {
+            return 'switch_context_to("root")';
+        }
+        return `${(_a = this.findAction) === null || _a === void 0 ? void 0 : _a.toMablscript()}.switch_context_to()`;
+    }
+    getInputVariables() {
+        var _a, _b;
+        return (_b = (_a = this.findAction) === null || _a === void 0 ? void 0 : _a.getInputVariables()) !== null && _b !== void 0 ? _b : [];
+    }
+}
+exports.SwitchContextStep = SwitchContextStep;
+SwitchContextStep.mablScriptStepNames = ['switch_context_to'];
+SwitchContextStep.yamlMablScriptNames = ['SwitchContext'];

package/mablscript/steps/SyntheticStep.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+        super(name, args, actions, name);
+        this.stepSourceIndexInFlow = stepSourceIndexInFlow;
+        this.actionSourceIndexInStep = 0;
+    }
+    getStepName() {
+        var _a;
+        return (_a = this.stepName) !== null && _a !== void 0 ? _a : 'Synthetic Step';
+    }
+    setStepName(stepName) {
+        this.stepName = stepName;
+    }
+}
+exports.SyntheticStep = SyntheticStep;