@mablhq/playwright-tools 2.49.1

package/mablscript/steps/AssertStep.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertStep = exports.assertStepYamlMablscriptNames = exports.OnFailure = void 0;
+const ConditionAction_1 = require("../actions/ConditionAction");
+const FindAction_1 = require("../actions/FindAction");
+const MablStep_1 = require("../MablStep");
+const MablAction_1 = require("../MablAction");
+const ExtractAction_1 = require("../actions/ExtractAction");
+const domUtil_1 = require("../../domUtil");
+const ConditionDescriptor_1 = require("../types/ConditionDescriptor");
+const GetUrlAction_1 = require("../actions/GetUrlAction");
+const GetCurrentLocationDescriptor_1 = require("../types/GetCurrentLocationDescriptor");
+const GetVariableValue_1 = require("../actions/GetVariableValue");
+const GetVariableDescriptor_1 = require("../types/GetVariableDescriptor");
+const CountAction_1 = require("../actions/CountAction");
+const MobileFindAction_1 = require("../mobile/steps/actions/MobileFindAction");
+const GetViewportDescriptor_1 = require("../types/GetViewportDescriptor");
+const GetViewportAction_1 = require("../actions/GetViewportAction");
+var OnFailure;
+(function (OnFailure) {
+    OnFailure["ContinueWithWarning"] = "continue";
+    OnFailure["FailImmediately"] = "terminate";
+    OnFailure["FailTestAtEnd"] = "failAtEnd";
+})(OnFailure || (exports.OnFailure = OnFailure = {}));
+const assertStepYamlMablscriptNames = () => {
+    const assertionNames = Object.keys(ConditionDescriptor_1.AssertionStepNameToField);
+    assertionNames.push('WaitUntil');
+    return assertionNames;
+};
+exports.assertStepYamlMablscriptNames = assertStepYamlMablscriptNames;
+class AssertStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        var _a, _b;
+        super(name, args, actions, 'assert');
+        const firstAction = actions[0];
+        if (firstAction instanceof FindAction_1.FindAction ||
+            firstAction instanceof MobileFindAction_1.MobileFindAction ||
+            firstAction instanceof GetUrlAction_1.GetUrlAction ||
+            firstAction instanceof GetVariableValue_1.GetVariableValue ||
+            firstAction instanceof GetViewportAction_1.GetViewportAction) {
+            this.primaryAction = firstAction;
+        }
+        else if (firstAction instanceof ConditionAction_1.ConditionAction &&
+            (0, ConditionDescriptor_1.isAIPromptCondition)(firstAction.conditionDescriptor)) {
+            this.primaryAction = new GetViewportAction_1.GetViewportAction();
+        }
+        else {
+            throw new Error(`Unexpected action type. Expected FindAction|MobileFindAction|GetUrlAction|GetVariableValue but got: ${firstAction.constructor.name}`);
+        }
+        if (actions.length === 3) {
+            if (actions[1] instanceof CountAction_1.CountAction) {
+                this.countAction = actions[1];
+            }
+            else {
+                this.extractAction = actions[1];
+            }
+            this.conditionAction = actions[2];
+        }
+        else if (firstAction instanceof ConditionAction_1.ConditionAction) {
+            this.conditionAction = firstAction;
+        }
+        else {
+            this.conditionAction = actions[1];
+        }
+        this.aiPrompt = (0, ConditionDescriptor_1.isAIPromptCondition)(this.conditionAction.conditionDescriptor)
+            ? {
+                userPrompt: this.conditionAction.conditionDescriptor.userPrompt,
+                metaPrompt: this.conditionAction.conditionDescriptor.metaPrompt,
+                criteria: this.conditionAction.conditionDescriptor.criteria,
+            }
+            : undefined;
+        this.assertionType = (0, ConditionDescriptor_1.getAssertionConditionFieldFromDescriptor)(this.conditionAction.conditionDescriptor);
+        this.assertionValue = (0, ConditionDescriptor_1.getOptionalComparatorValue)(this.conditionAction.conditionDescriptor);
+        this.isWaitUntilStep = this.determineIfWaitUntilStep();
+        this.assertArguments =
+            args[0] && typeof args[0] === 'object'
+                ? args[0]
+                : undefined;
+        this.onFailure =
+            ((_a = this.assertArguments) === null || _a === void 0 ? void 0 : _a.onFailure) ||
+                OnFailure.FailImmediately;
+        this.observationScope = (_b = this.assertArguments) === null || _b === void 0 ? void 0 : _b.observationScope;
+    }
+    canContinueOnFailure() {
+        return this.onFailure !== OnFailure.FailImmediately;
+    }
+    canFailAtEnd() {
+        return this.onFailure === OnFailure.FailTestAtEnd;
+    }
+    validate() {
+        if (!(this.actions.length === 2 || this.actions.length === 3) &&
+            !(this.actions[0] instanceof FindAction_1.FindAction) &&
+            !(this.actions[this.actions.length - 1] instanceof ConditionAction_1.ConditionAction)) {
+            throw new Error('Invalid assertion step');
+        }
+    }
+    determineIfWaitUntilStep() {
+        var _a, _b;
+        const find = this.primaryAction.toDescriptor();
+        if (ConditionDescriptor_1.AssertionConditionFieldToStepName[this.assertionType] ===
+            'AssertPresent' &&
+            (0, domUtil_1.isFindElementDescriptor)(find)) {
+            if ((_b = (_a = find.findOptions) === null || _a === void 0 ? void 0 : _a.waitUntil) === null || _b === void 0 ? void 0 : _b.timeoutSeconds) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getStepName() {
+        if (this.isWaitUntilStep) {
+            return 'WaitUntil';
+        }
+        return ConditionDescriptor_1.AssertionConditionFieldToStepName[this.assertionType];
+    }
+    toStepDescriptor() {
+        var _a, _b;
+        const find = this.primaryAction.toDescriptor();
+        const descriptorToActionMap = new Map()
+            .set(find, this.primaryAction)
+            .set(this.conditionAction.conditionDescriptor, this.conditionAction);
+        if (this.extractAction) {
+            descriptorToActionMap.set(this.extractAction.extractDescriptor, this.extractAction);
+        }
+        if (this.countAction) {
+            descriptorToActionMap.set(this.countAction.countDescriptor, this.countAction);
+        }
+        return {
+            find,
+            extractDescriptor: (_a = this.extractAction) === null || _a === void 0 ? void 0 : _a.extractDescriptor,
+            conditionDescriptor: this.conditionAction.conditionDescriptor,
+            countDescriptor: (_b = this.countAction) === null || _b === void 0 ? void 0 : _b.countDescriptor,
+            onFailure: this.onFailure,
+            observationScope: this.observationScope,
+            descriptorToActionMap,
+            actionCode: this.actionCode,
+        };
+    }
+    getFormattedStep(_fullLocatorsOn) {
+        var _a, _b;
+        const result = {};
+        result[this.getStepName()] = { ...this.annotationsAsYml() };
+        const formatted = result[this.getStepName()];
+        if (this.extractAction) {
+            formatted.attribute = this.extractAction.extractionAttribute;
+            formatted.extractType =
+                ExtractAction_1.ExtractAction.mablscriptToYamlType[this.extractAction.extractionType];
+        }
+        if (this.countAction) {
+            formatted.attribute = 'count';
+        }
+        if (this.assertionValue !== undefined) {
+            formatted.assertionValue = this.assertionValue;
+        }
+        if (this.aiPrompt !== undefined) {
+            formatted.aiPrompt = this.aiPrompt;
+        }
+        const targetDescriptor = this.primaryAction.toDescriptor();
+        if ((0, GetVariableDescriptor_1.isGetVariableDescriptor)(targetDescriptor)) {
+            formatted.target = (0, GetVariableDescriptor_1.convertGetVariableDescriptorToYaml)(targetDescriptor);
+        }
+        else {
+            formatted.target = targetDescriptor;
+        }
+        if (this.conditionAction.hasOptionsAtInstantiation) {
+            formatted.conditionOptions = (0, ConditionDescriptor_1.getOptionalConditionOptions)(this.conditionAction.conditionDescriptor);
+        }
+        if (!!((_a = this.assertArguments) === null || _a === void 0 ? void 0 : _a.observationScope) ||
+            !!((_b = this.assertArguments) === null || _b === void 0 ? void 0 : _b.onFailure)) {
+            formatted.assertArguments = this.assertArguments;
+        }
+        result[this.getStepName()] =
+            MablStep_1.MablStep.cloneAndRemoveUndefinedEntriesFromObject(formatted);
+        if (this.stepId()) {
+            result[this.getStepName()].id = this.stepId();
+        }
+        return result;
+    }
+    static fromYaml(stepName, stepArgs) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const actions = [];
+        const assertionType = ConditionDescriptor_1.AssertionStepNameToField[stepName];
+        const assertionValue = stepArgs.assertionValue;
+        const conditionOptions = stepArgs.conditionOptions;
+        let primaryAction;
+        if (((_a = stepArgs.target) === null || _a === void 0 ? void 0 : _a.kind) === GetCurrentLocationDescriptor_1.GET_CURRENT_LOCATION_KIND) {
+            primaryAction = new GetUrlAction_1.GetUrlAction(GetUrlAction_1.GetUrlAction.mablScriptStepNames[0], []);
+        }
+        else if (((_b = stepArgs.target) === null || _b === void 0 ? void 0 : _b.kind) === GetVariableDescriptor_1.GET_VARIABLE_VALUE) {
+            primaryAction = new GetVariableValue_1.GetVariableValue(GetVariableValue_1.GetVariableValue.mablScriptStepNames[0], [(_c = stepArgs.target) === null || _c === void 0 ? void 0 : _c.variable]);
+        }
+        else if ((0, GetViewportDescriptor_1.isGetViewportDescriptor)(stepArgs.target)) {
+            primaryAction = new GetViewportAction_1.GetViewportAction();
+        }
+        else if ((0, domUtil_1.isNormalizedFindEmailDescriptor)((_d = stepArgs.target) === null || _d === void 0 ? void 0 : _d.findTarget) ||
+            (0, domUtil_1.isCookieSelector)((_e = stepArgs.target) === null || _e === void 0 ? void 0 : _e.findTarget) ||
+            (0, domUtil_1.isTabSelector)((_f = stepArgs.target) === null || _f === void 0 ? void 0 : _f.findTarget)) {
+            const { findTarget, findType } = stepArgs.target;
+            primaryAction = new FindAction_1.FindAction(findType, [findTarget]);
+        }
+        else if ((0, domUtil_1.isMobileFindDescriptor)(stepArgs.target)) {
+            primaryAction = MobileFindAction_1.MobileFindAction.fromDescriptor(stepArgs.target);
+        }
+        else if ((0, domUtil_1.isFindElementDescriptor)(stepArgs.target)) {
+            const { findOptions, findTarget, findType } = stepArgs.target;
+            if (findType === domUtil_1.FindType.FIND_ONE) {
+                primaryAction = new FindAction_1.FindAction(findType, [findTarget, findOptions]);
+            }
+            else {
+                primaryAction = new FindAction_1.FindAction(findType, [findTarget, findOptions]);
+            }
+        }
+        else {
+            throw new Error(`Error parsing [${stepName}] with incompatible step arguments`);
+        }
+        actions.push(primaryAction);
+        if (assertionType === 'ai_prompt') {
+            actions.push(new ConditionAction_1.ConditionAction('evaluate_ai_prompt', [
+                (_h = (_g = stepArgs.aiPrompt) === null || _g === void 0 ? void 0 : _g.userPrompt) !== null && _h !== void 0 ? _h : stepArgs.userPrompt,
+                {
+                    metaPrompt: (_k = (_j = stepArgs.aiPrompt) === null || _j === void 0 ? void 0 : _j.metaPrompt) !== null && _k !== void 0 ? _k : stepArgs.metaPrompt,
+                    criteria: (_l = stepArgs.aiPrompt) === null || _l === void 0 ? void 0 : _l.criteria,
+                },
+            ]));
+        }
+        else if (assertionType === 'present' || assertionType === 'not_present') {
+            actions.push(new ConditionAction_1.ConditionAction('evaluate_presence', [assertionType]));
+        }
+        else if (stepName === 'WaitUntil') {
+            actions.push(new ConditionAction_1.ConditionAction('evaluate_presence', ['present']));
+        }
+        else {
+            if (stepArgs.attribute === 'count') {
+                actions.push(new CountAction_1.CountAction('count', [stepArgs.attribute]));
+            }
+            else if (((_m = stepArgs.target) === null || _m === void 0 ? void 0 : _m.kind) !== GetVariableDescriptor_1.GET_VARIABLE_VALUE) {
+                actions.push(new ExtractAction_1.ExtractAction(ExtractAction_1.ExtractAction.mablScriptTypeFromYamlType(stepArgs.extractType), [stepArgs.attribute]));
+            }
+            actions.push(new ConditionAction_1.ConditionAction('evaluate_condition', [
+                assertionType,
+                assertionValue,
+                conditionOptions,
+            ]));
+        }
+        const assertStep = new AssertStep('assert', [stepArgs.assertArguments], actions);
+        if (stepArgs.annotation) {
+            assertStep.setAnnotation(stepArgs.annotation);
+        }
+        assertStep.setStepId(stepArgs.id);
+        return assertStep;
+    }
+    toMablscript() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (this.primaryAction instanceof MobileFindAction_1.MobileFindAction) {
+            throw new Error('Mobile steps do not generate mablscript');
+        }
+        let primaryActionMablscriptPrefix = this.primaryAction.toMablscript();
+        if (primaryActionMablscriptPrefix.length > 0) {
+            primaryActionMablscriptPrefix += '.';
+        }
+        let primaryActionFindMablscriptPrefix = this.primaryAction.generateFindMablscript();
+        if (primaryActionFindMablscriptPrefix.length > 0) {
+            primaryActionFindMablscriptPrefix += '.';
+        }
+        const assertAction = `.assert(${!!(((_a = this.assertArguments) === null || _a === void 0 ? void 0 : _a.onFailure) ||
+            ((_b = this.assertArguments) === null || _b === void 0 ? void 0 : _b.observationScope))
+            ? (0, MablAction_1.convertObjectToMablscriptArgs)({
+                ...this.assertArguments,
+                onFailure: ((_c = this.assertArguments) === null || _c === void 0 ? void 0 : _c.onFailure) === OnFailure.FailImmediately
+                    ? undefined
+                    : (_d = this.assertArguments) === null || _d === void 0 ? void 0 : _d.onFailure,
+            })
+            : ''})`;
+        if (this.countAction) {
+            return `${primaryActionMablscriptPrefix}${this.countAction.toMablscript()}.${this.conditionAction.toMablscript()}${assertAction}`;
+        }
+        if (this.extractAction) {
+            return `${primaryActionMablscriptPrefix}${this.extractAction.toMablscript()}.${this.conditionAction.toMablscript()}${assertAction}`;
+        }
+        if (this.assertionType === 'present' ||
+            this.assertionType === 'not_present') {
+            return `${primaryActionFindMablscriptPrefix}evaluate_presence("${this.assertionType}")${assertAction}`;
+        }
+        if (this.assertionType === 'ai_prompt') {
+            const aiOptions = {};
+            if ((_e = this.aiPrompt) === null || _e === void 0 ? void 0 : _e.metaPrompt) {
+                aiOptions.metaPrompt = this.aiPrompt.metaPrompt;
+            }
+            if (((_f = this.aiPrompt) === null || _f === void 0 ? void 0 : _f.criteria) && this.aiPrompt.criteria.length > 0) {
+                aiOptions.criteria = (_g = this.aiPrompt) === null || _g === void 0 ? void 0 : _g.criteria;
+            }
+            return `${primaryActionFindMablscriptPrefix}evaluate_ai_prompt("${(_h = this.aiPrompt) === null || _h === void 0 ? void 0 : _h.userPrompt}", ${JSON.stringify(aiOptions)})${assertAction}`;
+        }
+        return `${primaryActionMablscriptPrefix}${this.conditionAction.toMablscript()}${assertAction}`;
+    }
+    toLineDiffFormat() {
+        if (this.primaryAction instanceof MobileFindAction_1.MobileFindAction) {
+            const lineDiffProperties = {
+                annotation: this.annotation,
+                disabled: this.isDisabled(),
+                descriptor: this.toStepDescriptor(),
+            };
+            return this.stringify(lineDiffProperties);
+        }
+        return super.toLineDiffFormat();
+    }
+    getInputVariables() {
+        var _a, _b, _c, _d;
+        return (0, MablAction_1.distinctStrings)([
+            ...this.primaryAction.getInputVariables(),
+            ...((_b = (_a = this.countAction) === null || _a === void 0 ? void 0 : _a.getInputVariables()) !== null && _b !== void 0 ? _b : []),
+            ...this.conditionAction.getInputVariables(),
+            ...((_d = (_c = this.extractAction) === null || _c === void 0 ? void 0 : _c.getInputVariables()) !== null && _d !== void 0 ? _d : []),
+        ]);
+    }
+}
+exports.AssertStep = AssertStep;
+AssertStep.mablScriptStepNames = ['assert'];
+AssertStep.yamlMablScriptNames = (0, exports.assertStepYamlMablscriptNames)();

package/mablscript/steps/AssertStepOld.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertStepOld = void 0;
+const ExtractAction_1 = require("../actions/ExtractAction");
+const MablStep_1 = require("../MablStep");
+const FindAction_1 = require("../actions/FindAction");
+const domUtil_1 = require("../../domUtil");
+const importer_1 = require("../importer");
+const GetCurrentLocationDescriptor_1 = require("../types/GetCurrentLocationDescriptor");
+const GetVariableDescriptor_1 = require("../types/GetVariableDescriptor");
+const GetViewportDescriptor_1 = require("../types/GetViewportDescriptor");
+const oldToNewAssertionTypes = {
+    assert_contains: 'AssertContains',
+    assert_does_not_contain: 'AssertDoesNotContain',
+    assert_does_not_equal: 'AssertDoesNotEqual',
+    assert_download: 'AssertDownload',
+    assert_equals: 'AssertEquals',
+    assert_greater_than: 'AssertGreaterThan',
+    assert_greater_than_or_equals: 'AssertGreaterThanOrEquals',
+    assert_less_than: 'AssertLessThan',
+    assert_less_than_or_equals: 'AssertLessThanOrEquals',
+    assert_not_present: 'AssertNotPresent',
+    assert_present: 'AssertPresent',
+    assert_starts_with: 'AssertStartsWith',
+    assert_starts_without: 'AssertStartsWithout',
+    assert_ends_with: 'AssertEndsWith',
+    assert_ends_without: 'AssertEndsWithout',
+};
+class AssertStepOld extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, name);
+        this.assertionType = '';
+        this.assertAttribute = '';
+        this.validate();
+        this.setAssertAttribute();
+        this.assertionType = this.name;
+        this.primaryAction = actions[0];
+        this.extractAction = actions[1];
+        if (args.length === 1) {
+            this.onFailure = args[0].onFailure;
+            this.observationScope = args[0].observationScope;
+        }
+        else if (args.length === 2) {
+            this.onFailure = args[1].onFailure;
+            this.observationScope = args[1].observationScope;
+        }
+    }
+    validate() {
+        if (this.actions.length !== 2 &&
+            !(this.actions[0] instanceof FindAction_1.FindAction) &&
+            !(this.actions[1] instanceof ExtractAction_1.ExtractAction)) {
+            throw new Error('Legacy assert steps should have exactly two sub action:  a find and an extract');
+        }
+    }
+    setAssertAttribute() {
+        this.assertAttribute = this.getActionArgs()[0];
+    }
+    getStepName() {
+        return oldToNewAssertionTypes[this.getAssertionType()];
+    }
+    getAssertionType() {
+        return this.assertionType;
+    }
+    toStepDescriptor() {
+        const formatted = {};
+        if (this.assertionType !== 'assert_present' &&
+            this.assertionType !== 'assert_not_present') {
+            formatted.assertionValue = this.assertAttribute;
+        }
+        if (this.extractAction) {
+            formatted.extractType =
+                ExtractAction_1.ExtractAction.mablscriptToYamlType[this.extractAction.extractionType];
+            formatted.attribute = this.extractAction.extractionAttribute;
+        }
+        const find = this.primaryAction.toDescriptor();
+        formatted.findOptions = find.selectorFindOption;
+        if ((0, GetCurrentLocationDescriptor_1.isGetCurrentLocationDescriptor)(find) ||
+            (0, GetVariableDescriptor_1.isGetVariableDescriptor)(find) ||
+            (0, GetViewportDescriptor_1.isGetViewportDescriptor)(find)) {
+            formatted.kind = find.kind;
+        }
+        else {
+            switch (find.findType) {
+                case domUtil_1.FindType.FIND_COOKIE:
+                case domUtil_1.FindType.FIND_EMAIL:
+                    formatted.findType = FindAction_1.findTypesToFormattedType[find.findType];
+                    formatted.selector = find.findTarget;
+                    break;
+                case domUtil_1.FindType.FIND_FIRST:
+                case domUtil_1.FindType.FIND_LAST:
+                case domUtil_1.FindType.FIND_ANY:
+                case domUtil_1.FindType.FIND_ALL:
+                    formatted.findType = FindAction_1.findTypesToFormattedType[find.findType];
+                    formatted.selector = find.findTarget;
+                    break;
+                case domUtil_1.FindType.FIND_ONE:
+                    formatted.selector = find.findTarget.selector;
+                    break;
+                default:
+                    throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
+            }
+        }
+        formatted.assertArguments = {
+            onFailure: this.onFailure,
+            observationScope: this.observationScope,
+        };
+        return formatted;
+    }
+    getFormattedStep(_fullLocatorsOn) {
+        const result = {};
+        result[this.getStepName()] = { ...this.annotationsAsYml() };
+        const formatted = result[this.getStepName()];
+        if (this.extractAction) {
+            formatted.attribute = this.extractAction.extractionAttribute;
+            formatted.extractType =
+                ExtractAction_1.ExtractAction.mablscriptToYamlType[this.extractAction.extractionType];
+        }
+        if (this.assertionType !== 'assert_present' &&
+            this.assertionType !== 'assert_not_present') {
+            formatted.assertionValue = this.assertAttribute;
+        }
+        const targetDescriptor = this.primaryAction.toDescriptor();
+        if ((0, GetVariableDescriptor_1.isGetVariableDescriptor)(targetDescriptor)) {
+            formatted.target = (0, GetVariableDescriptor_1.convertGetVariableDescriptorToYaml)(targetDescriptor);
+        }
+        else {
+            formatted.target = targetDescriptor;
+        }
+        formatted.assertArguments = {
+            onFailure: this.onFailure,
+            observationScope: this.observationScope,
+        };
+        if (this.stepId()) {
+            formatted.id = this.stepId();
+        }
+        return result;
+    }
+    getNewAssertionStep() {
+        const yamlified = (0, importer_1.yamlifyTheLoadedSteps)([this]);
+        const reloadedSteps = (0, importer_1.loadYamlSteps)(yamlified);
+        const result = reloadedSteps[0];
+        if (this.stepSourceIndexInFlow !== undefined) {
+            result.setStepSourceIndexInFlow(this.stepSourceIndexInFlow);
+        }
+        this.actions.forEach((_oldAction, actionIndex) => {
+            result.actions[actionIndex].setActionSourceIndexInStep(actionIndex);
+        });
+        if (this.actionSourceIndexInStep !== undefined) {
+            result.setActionSourceIndexInStep(this.actionSourceIndexInStep);
+        }
+        return result;
+    }
+    static fromYaml(stepName, _stepArgs) {
+        return new MablStep_1.MablStep(stepName, [], [], 'assert');
+    }
+}
+exports.AssertStepOld = AssertStepOld;
+AssertStepOld.mablScriptStepNames = Object.keys(oldToNewAssertionTypes);
+AssertStepOld.yamlMablScriptNames = [];

package/mablscript/steps/AwaitTabStep.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasCustomFindOptions = exports.AwaitTabStep = void 0;
+const domUtil_1 = require("../../domUtil");
+const MablStep_1 = require("../MablStep");
+class AwaitTabStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        super(name, args, actions, 'await_tab');
+        this.tab = this.getActionArgs()[0];
+    }
+    getStepName() {
+        return 'AwaitTab';
+    }
+    toStepDescriptor() {
+        return {
+            tab: this.tab,
+            actionCode: this.actionCode,
+        };
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new AwaitTabStep('await_tab', [stepArgs.tab], []);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `await_tab(${AwaitTabStep.getMablscriptSelectorFromTabFindAction(this.tab)})`;
+    }
+    static hasCustomFindOptions(tab) {
+        var _a, _b;
+        return Object.keys((_b = (_a = tab.configuration) === null || _a === void 0 ? void 0 : _a.propertyPreferences) !== null && _b !== void 0 ? _b : {}).length > 0;
+    }
+    static getMablscriptSelectorFromTabFindAction(tab) {
+        const mablscriptSelectorChunks = ['selector_type: "tab"'];
+        if (tab.title !== undefined) {
+            mablscriptSelectorChunks.push(`title: "${(0, domUtil_1.escapeMablscriptString)(tab.title)}"`);
+        }
+        if (tab.url !== undefined) {
+            mablscriptSelectorChunks.push(`url: "${(0, domUtil_1.escapeMablscriptString)(tab.url)}"`);
+        }
+        if (tab.uuid !== undefined) {
+            mablscriptSelectorChunks.push(`uuid: "${(0, domUtil_1.escapeMablscriptString)(tab.uuid)}"`);
+        }
+        let descriptor = mablscriptSelectorChunks.join(', ');
+        if (tab.configuration) {
+            descriptor = `${descriptor}, ${AwaitTabStep.getConfigurationString(tab)}`;
+        }
+        return `{${descriptor}}`;
+    }
+    static getConfigurationString(tabSelector) {
+        let configString;
+        if (hasCustomFindOptions(tabSelector)) {
+            configString = (0, domUtil_1.buildStepArgumentString)({
+                params: { ...tabSelector.configuration },
+                legacy: true,
+            });
+        }
+        if (configString) {
+            return `configuration: ${configString}`;
+        }
+        return '';
+    }
+}
+exports.AwaitTabStep = AwaitTabStep;
+AwaitTabStep.mablScriptStepNames = ['await_tab'];
+AwaitTabStep.yamlMablScriptNames = ['AwaitTab'];
+function hasCustomFindOptions(tab) {
+    return AwaitTabStep.hasCustomFindOptions(tab);
+}
+exports.hasCustomFindOptions = hasCustomFindOptions;

package/mablscript/steps/AwaitUploadsStep.js

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

package/mablscript/steps/ClearCookiesStep.js

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

package/mablscript/steps/ClickAndHoldStep.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClickAndHoldStep = void 0;
+const FindAction_1 = require("../actions/FindAction");
+const MablStep_1 = require("../MablStep");
+const domUtil_1 = require("../../domUtil");
+const ActionsUtils_1 = require("./ActionsUtils");
+class ClickAndHoldStep extends MablStep_1.MablStep {
+    constructor(name, args, actions) {
+        var _a;
+        super(name, args, actions, 'click_and_hold');
+        this.findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(this.actions);
+        this.clickArgs = (_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 (!isClickAndHoldArgs(args[0])) {
+            throw new Error(`Invalid argument passed to ${this.getStepName()} step.`);
+        }
+        return args[0];
+    }
+    getStepName() {
+        return 'ClickAndHold';
+    }
+    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,
+                    isHtml5: this.clickArgs.isHtml5,
+                    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 = {
+            ClickAndHold: {
+                ...super.annotationsAsYml(),
+                ...this.findAction.toYaml(),
+            },
+        };
+        if (this.stepId()) {
+            step.ClickAndHold.id = this.stepId();
+        }
+        return step;
+    }
+    static fromYaml(_stepName, stepArgs) {
+        const step = new ClickAndHoldStep('click_and_hold', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        step.setStepId(stepArgs.id);
+        return step;
+    }
+    toMablscript() {
+        return `${this.findAction.toMablscript()}.click_and_hold({isHtml5:${this.clickArgs.isHtml5}})`;
+    }
+    getInputVariables() {
+        return this.findAction.getInputVariables();
+    }
+}
+exports.ClickAndHoldStep = ClickAndHoldStep;
+ClickAndHoldStep.mablScriptStepNames = ['click_and_hold'];
+ClickAndHoldStep.yamlMablScriptNames = ['ClickAndHold'];
+function isClickAndHoldArgs(value) {
+    return value.isHtml5 !== undefined;
+}