@mablhq/playwright-tools 2.49.1

package/mablscript/mobile/steps/HideKeyboardStep.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HideKeyboardStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+const STEP_NAME = 'HideKeyboard';
+class HideKeyboardStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(HideKeyboardStep.stepName, descriptor, 'hide_keyboard');
+    }
+    stepDescription() {
+        return `Hide keyboard if present`;
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new HideKeyboardStep(stepDescriptor);
+    }
+}
+exports.HideKeyboardStep = HideKeyboardStep;
+HideKeyboardStep.stepName = STEP_NAME;
+HideKeyboardStep.yamlMablScriptNames = [HideKeyboardStep.stepName];
+HideKeyboardStep.stepVersion = 2;

package/mablscript/mobile/steps/InstallAppStep.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstallAppStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+class InstallAppStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(InstallAppStep.stepName, descriptor, 'installApp');
+    }
+    stepDescription() {
+        if (this.descriptor.packageName) {
+            return `Install app - ${this.descriptor.packageName}`;
+        }
+        return `Install primary app under test`;
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new InstallAppStep(stepDescriptor);
+    }
+}
+exports.InstallAppStep = InstallAppStep;
+InstallAppStep.stepName = 'InstallApp';
+InstallAppStep.yamlMablScriptNames = [InstallAppStep.stepName];
+InstallAppStep.stepVersion = 2;

package/mablscript/mobile/steps/NavigateBackStep.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NavigateBackStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+const STEP_NAME = 'NavigateBack';
+class NavigateBackStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(NavigateBackStep.stepName, descriptor, 'navigate_back');
+    }
+    stepDescription() {
+        return `Navigate back`;
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new NavigateBackStep(stepDescriptor);
+    }
+}
+exports.NavigateBackStep = NavigateBackStep;
+NavigateBackStep.stepName = STEP_NAME;
+NavigateBackStep.yamlMablScriptNames = [NavigateBackStep.stepName];
+NavigateBackStep.stepVersion = 2;

package/mablscript/mobile/steps/NavigateHomeStep.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NavigateHomeStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+const STEP_NAME = 'NavigateHome';
+class NavigateHomeStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(NavigateHomeStep.stepName, descriptor, 'navigate_home');
+        this.descriptor = descriptor;
+    }
+    stepDescription() {
+        return `Navigate home`;
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new NavigateHomeStep(stepDescriptor);
+    }
+}
+exports.NavigateHomeStep = NavigateHomeStep;
+NavigateHomeStep.stepName = STEP_NAME;
+NavigateHomeStep.yamlMablScriptNames = [NavigateHomeStep.stepName];
+NavigateHomeStep.stepVersion = 2;

package/mablscript/mobile/steps/OpenAppStep.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAppStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+class OpenAppStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(OpenAppStep.stepName, descriptor, 'OpenApp');
+    }
+    stepDescription() {
+        if (this.descriptor.packageName) {
+            return `Open app - ${this.descriptor.packageName}`;
+        }
+        return `Open primary app under test`;
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new OpenAppStep(stepDescriptor);
+    }
+}
+exports.OpenAppStep = OpenAppStep;
+OpenAppStep.stepName = 'OpenApp';
+OpenAppStep.yamlMablScriptNames = [OpenAppStep.stepName];
+OpenAppStep.stepVersion = 2;

package/mablscript/mobile/steps/OpenLinkStep.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenLinkStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+class OpenLinkStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(OpenLinkStep.stepName, descriptor, 'openLink');
+    }
+    stepDescription() {
+        return `Open deep link: ${this.descriptor.url}`;
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new OpenLinkStep(stepDescriptor);
+    }
+}
+exports.OpenLinkStep = OpenLinkStep;
+OpenLinkStep.stepName = 'OpenLink';
+OpenLinkStep.yamlMablScriptNames = [OpenLinkStep.stepName];
+OpenLinkStep.stepVersion = 2;

package/mablscript/mobile/steps/PrepareSessionStep.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrepareSessionStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+class PrepareSessionStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(PrepareSessionStep.stepName, descriptor, 'prepareSession');
+    }
+    stepDescription() {
+        return `Launch and initialize app session`;
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new PrepareSessionStep(stepDescriptor);
+    }
+}
+exports.PrepareSessionStep = PrepareSessionStep;
+PrepareSessionStep.stepName = 'PrepareSession';
+PrepareSessionStep.yamlMablScriptNames = [PrepareSessionStep.stepName];
+PrepareSessionStep.stepVersion = 2;

package/mablscript/mobile/steps/PushFileStep.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushFileStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+class PushFileStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(PushFileStep.stepName, descriptor, PushFileStep.stepName);
+    }
+    stepDescription() {
+        const filesLength = this.descriptor.files.length;
+        if (filesLength > 1) {
+            return `Push ${filesLength} files to the test device`;
+        }
+        const firstFile = this.descriptor.files[0];
+        if (firstFile.file.name) {
+            return `Push the file "${firstFile.file.name}" to the test device at path "${firstFile.path}"`;
+        }
+        return `Push file to the test device at path "${firstFile.path}"`;
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new PushFileStep(stepDescriptor);
+    }
+}
+exports.PushFileStep = PushFileStep;
+PushFileStep.stepName = 'PushFile';
+PushFileStep.yamlMablScriptNames = [PushFileStep.stepName];
+PushFileStep.stepVersion = 2;

package/mablscript/mobile/steps/ScrollStep.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScrollDirectionAndPercentageFromCoordinates = exports.formatPercentageVal = exports.humanizeScrollInformation = exports.ScrollStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+const ScrollStepDescriptor_1 = require("../../types/mobile/ScrollStepDescriptor");
+const stepUtil_1 = require("./stepUtil");
+const STEP_NAME = 'Scroll';
+class ScrollStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(ScrollStep.stepName, descriptor, 'scroll');
+    }
+    stepDescription() {
+        return humanizeScrollInformation(this.descriptor);
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        if (!stepDescriptor.scrollDirection) {
+            const { scrollDirection } = getScrollDirectionAndPercentageFromCoordinates(stepDescriptor.coordinates);
+            stepDescriptor.scrollDirection = scrollDirection;
+        }
+        if (!stepDescriptor.scrollType) {
+            stepDescriptor.scrollType = ScrollStepDescriptor_1.ScrollType.ScrollDeviceScreen;
+        }
+        return new ScrollStep(stepDescriptor);
+    }
+}
+exports.ScrollStep = ScrollStep;
+ScrollStep.stepName = STEP_NAME;
+ScrollStep.yamlMablScriptNames = [ScrollStep.stepName];
+ScrollStep.stepVersion = 2;
+function humanizeScrollInformation(stepDescriptor) {
+    switch (stepDescriptor.scrollType) {
+        case ScrollStepDescriptor_1.ScrollType.ScrollDeviceScreen: {
+            const { coordinates } = stepDescriptor;
+            return humanizeCoordinateScroll(coordinates, 'of the screen');
+        }
+        case ScrollStepDescriptor_1.ScrollType.ScrollToElement: {
+            const { coordinates, find, maxScrollAttempts, scrollDirection, targetElementDescriptor, } = stepDescriptor;
+            let scrollText = `Scroll ${scrollDirection} a maximum of ${maxScrollAttempts} times`;
+            if (coordinates) {
+                scrollText = humanizeCoordinateScroll(coordinates, `a maximum of ${maxScrollAttempts} times`);
+            }
+            const containerElementDescription = find
+                ? (0, stepUtil_1.getElementDescriptionFromMobileFindDescriptor)(find)
+                : 'screen';
+            const targetElementDescription = (0, stepUtil_1.getElementDescriptionFromMobileFindDescriptor)(targetElementDescriptor);
+            return `${scrollText} within the ${containerElementDescription} until the ${targetElementDescription} is visible`;
+        }
+        case ScrollStepDescriptor_1.ScrollType.ScrollWithinElement: {
+            const { coordinates, find } = stepDescriptor;
+            const containerElementDescription = (0, stepUtil_1.getElementDescriptionFromMobileFindDescriptor)(find);
+            return humanizeCoordinateScroll(coordinates, `within the ${containerElementDescription}`);
+        }
+        default:
+            return 'Unknown scroll step type';
+    }
+}
+exports.humanizeScrollInformation = humanizeScrollInformation;
+function humanizeCoordinateScroll(coordinates, scrollTargetActionString) {
+    const { scrollDirection, scrollPercent } = getScrollDirectionAndPercentageFromCoordinates(coordinates);
+    return `Scroll ${scrollDirection} ${scrollPercent} ${scrollTargetActionString}`;
+}
+function formatPercentageVal(percent) {
+    return `${Math.round(percent * 10000) / 100}%`;
+}
+exports.formatPercentageVal = formatPercentageVal;
+function getScrollDirectionAndPercentageFromCoordinates(coordinates) {
+    if (!coordinates) {
+        return { scrollDirection: ScrollStepDescriptor_1.ScrollDirection.Down, scrollPercent: '80%' };
+    }
+    const yScrollDistance = Math.abs(coordinates.to.yPercent - coordinates.from.yPercent);
+    const xScrollDistance = Math.abs(coordinates.to.xPercent - coordinates.from.xPercent);
+    if (yScrollDistance > xScrollDistance) {
+        const scrollDistanceFormatted = formatPercentageVal(yScrollDistance);
+        const isScrollUp = coordinates.from.yPercent < coordinates.to.yPercent;
+        const scrollDirection = isScrollUp
+            ? ScrollStepDescriptor_1.ScrollDirection.Up
+            : ScrollStepDescriptor_1.ScrollDirection.Down;
+        return { scrollDirection, scrollPercent: scrollDistanceFormatted };
+    }
+    const scrollDistanceFormatted = formatPercentageVal(xScrollDistance);
+    const isScrollLeft = coordinates.from.xPercent < coordinates.to.xPercent;
+    const scrollDirection = isScrollLeft
+        ? ScrollStepDescriptor_1.ScrollDirection.Left
+        : ScrollStepDescriptor_1.ScrollDirection.Right;
+    return { scrollDirection, scrollPercent: scrollDistanceFormatted };
+}
+exports.getScrollDirectionAndPercentageFromCoordinates = getScrollDirectionAndPercentageFromCoordinates;

package/mablscript/mobile/steps/SetOrientationStep.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetOrientationStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+const STEP_NAME = 'SetOrientation';
+class SetOrientationStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(SetOrientationStep.stepName, descriptor, 'set_orientation');
+    }
+    stepDescription() {
+        return `Set orientation of device to ${this.descriptor.orientation.toLowerCase()}`;
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new SetOrientationStep(stepDescriptor);
+    }
+}
+exports.SetOrientationStep = SetOrientationStep;
+SetOrientationStep.stepName = STEP_NAME;
+SetOrientationStep.yamlMablScriptNames = [SetOrientationStep.stepName];
+SetOrientationStep.stepVersion = 2;

package/mablscript/mobile/steps/TapStep.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TapStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+const TapStepDescriptor_1 = require("../../types/mobile/TapStepDescriptor");
+const MobileFindAction_1 = require("./actions/MobileFindAction");
+const stepUtil_1 = require("./stepUtil");
+const MablAction_1 = require("../../MablAction");
+class TapStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(TapStep.stepName, descriptor, 'tap');
+        this.findAction = MobileFindAction_1.MobileFindAction.fromDescriptor(this.descriptor.find);
+        this.actions = [this.findAction];
+    }
+    getInputVariables() {
+        const { find } = this.descriptor;
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(find);
+    }
+    stepDescription() {
+        let prependedText;
+        switch (this.descriptor.type) {
+            case TapStepDescriptor_1.TapType.long:
+                prependedText = `Perform long press on `;
+                break;
+            default:
+                prependedText = `Tap on`;
+        }
+        return (0, stepUtil_1.getDescriptionForMobileStepDescriptor)(prependedText, this.descriptor);
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new TapStep(stepDescriptor);
+    }
+}
+exports.TapStep = TapStep;
+TapStep.stepName = 'Tap';
+TapStep.yamlMablScriptNames = [TapStep.stepName];
+TapStep.stepVersion = 2;

package/mablscript/mobile/steps/UninstallAppStep.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UninstallAppStep = void 0;
+const MablStepV2_1 = require("../../MablStepV2");
+class UninstallAppStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(UninstallAppStep.stepName, descriptor, 'uninstallApp');
+    }
+    stepDescription() {
+        if (this.descriptor.appId) {
+            return `Uninstall app - ${this.descriptor.appId}`;
+        }
+        return `Uninstall primary app under test`;
+    }
+    static fromYaml(_stepName, stepDescriptor) {
+        return new UninstallAppStep(stepDescriptor);
+    }
+}
+exports.UninstallAppStep = UninstallAppStep;
+UninstallAppStep.stepName = 'UninstallApp';
+UninstallAppStep.yamlMablScriptNames = [UninstallAppStep.stepName];
+UninstallAppStep.stepVersion = 2;

package/mablscript/mobile/steps/actions/MobileFindAction.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileFindAction = void 0;
+const MablAction_1 = require("../../../MablAction");
+class MobileFindAction extends MablAction_1.MablAction {
+    constructor(findDescriptor) {
+        super('MobileFindAction', 'mobile_find_action', [[]]);
+        this.findDescriptor = findDescriptor;
+    }
+    toDescriptor() {
+        return this.findDescriptor;
+    }
+    toYaml() {
+        return this.findDescriptor;
+    }
+    getInputVariables() {
+        return MablAction_1.MablAction.findUniqueVariableReferencesInValue(this.findDescriptor);
+    }
+    static fromDescriptor(mobileFindDescriptor) {
+        return new MobileFindAction(mobileFindDescriptor);
+    }
+}
+exports.MobileFindAction = MobileFindAction;

package/mablscript/mobile/steps/stepUtil.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPasswordField = exports.isStepWithFind = exports.humanizeCustomFind = exports.getElementDescriptionFromMobileFindDescriptor = exports.getDescriptionForMobileStepDescriptor = exports.getSimpleIOSElementName = exports.getSimpleAndroidElementName = void 0;
+const domUtil_1 = require("../../../domUtil");
+const mablscriptFind_1 = require("../../../mablscriptFind");
+function getSimpleAndroidElementName(className) {
+    if (!className) {
+        return 'unknown';
+    }
+    const parts = className.split('.');
+    return parts[parts.length - 1];
+}
+exports.getSimpleAndroidElementName = getSimpleAndroidElementName;
+function getSimpleIOSElementName(elementName) {
+    if (!elementName) {
+        return 'unknown';
+    }
+    const parts = elementName.split('XCUIElementType');
+    if (parts.length > 1) {
+        return parts[1];
+    }
+    return 'unknown';
+}
+exports.getSimpleIOSElementName = getSimpleIOSElementName;
+function getDescriptionForMobileStepDescriptor(predicateAction, descriptor) {
+    const elementDescription = getElementDescriptionFromMobileFindDescriptor(descriptor.find);
+    return `${predicateAction} ${elementDescription}`;
+}
+exports.getDescriptionForMobileStepDescriptor = getDescriptionForMobileStepDescriptor;
+function getElementDescriptionFromMobileFindDescriptor(descriptor) {
+    const findTarget = descriptor === null || descriptor === void 0 ? void 0 : descriptor.findTarget;
+    if ((0, domUtil_1.isMobileFindSpecification)(findTarget)) {
+        if ((0, domUtil_1.isWebViewFindElementDescriptor)(descriptor)) {
+            return getDescriptionForWebViewFindDescriptor(descriptor);
+        }
+        const selector = findTarget.selector;
+        if (selector.android && Object.keys(selector.android).length) {
+            return buildElementDescriptionForAndroid(findTarget);
+        }
+        else if (selector.iOS) {
+            return buildElementDescriptionForiOS(findTarget);
+        }
+    }
+    return 'unknown element';
+}
+exports.getElementDescriptionFromMobileFindDescriptor = getElementDescriptionFromMobileFindDescriptor;
+function buildElementDescriptionForAndroid(findTarget) {
+    var _a, _b, _c;
+    const selector = findTarget.selector;
+    if (!selector.android) {
+        return `unknown android element`;
+    }
+    const description = `"${getSimpleAndroidElementName(selector.android.class)}" element`;
+    if ((_a = selector.android) === null || _a === void 0 ? void 0 : _a.hint) {
+        return `${description} with hint "${(0, domUtil_1.normalizeText)(selector.android.hint)}"`;
+    }
+    if ((_b = selector.android) === null || _b === void 0 ? void 0 : _b.text) {
+        return `${description} with text "${(0, domUtil_1.normalizeText)(selector.android.text)}"`;
+    }
+    if ((_c = selector.android) === null || _c === void 0 ? void 0 : _c.contentDesc) {
+        return `${description} with content-desc "${(0, domUtil_1.normalizeText)(selector.android.contentDesc)}"`;
+    }
+    return description;
+}
+function buildElementDescriptionForiOS(findTarget) {
+    const selector = findTarget.selector;
+    if (!selector.iOS) {
+        return `unknown iOS element`;
+    }
+    if (selector.iOS.name) {
+        return `"${selector.iOS.name}" element`;
+    }
+    const simpleDescription = selector.iOS.type
+        ? `"${getSimpleIOSElementName(selector.iOS.type)}" element`
+        : `element`;
+    if (selector.iOS.label) {
+        return `${simpleDescription} with label "${(0, domUtil_1.normalizeText)(selector.iOS.label)}"`;
+    }
+    return simpleDescription;
+}
+function getDescriptionForWebViewFindDescriptor(webViewElementDescriptor) {
+    if ((0, domUtil_1.isFindElementDescriptor)(webViewElementDescriptor.webView.descriptor)) {
+        return (0, mablscriptFind_1.humanizeFindOneDescriptor)(webViewElementDescriptor.webView.descriptor.findTarget);
+    }
+    return `unknown webview element`;
+}
+function humanizeCustomFind(descriptor) {
+    if (isStepWithFind(descriptor)) {
+        if ((0, domUtil_1.isMobileFindCustomDescriptor)(descriptor.find)) {
+            return `xpath: ${descriptor.find.findTarget.xpath}`;
+        }
+    }
+    return `custom find`;
+}
+exports.humanizeCustomFind = humanizeCustomFind;
+function isStepWithFind(value) {
+    return !!(value === null || value === void 0 ? void 0 : value.find);
+}
+exports.isStepWithFind = isStepWithFind;
+function isPasswordField(descriptor) {
+    var _a, _b;
+    if ((0, domUtil_1.isMobileFindSpecification)(descriptor === null || descriptor === void 0 ? void 0 : descriptor.findTarget)) {
+        if (((_a = descriptor.findTarget.selector.android) === null || _a === void 0 ? void 0 : _a.password) === true) {
+            return true;
+        }
+        if (((_b = descriptor.findTarget.selector.iOS) === null || _b === void 0 ? void 0 : _b.type) ===
+            'XCUIElementTypeSecureTextField') {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isPasswordField = isPasswordField;

package/mablscript/mobile/tests/StepTestsUtil.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRawStepIntoMablStep = exports.parseAndValidateYamlConversion = void 0;
+const js_yaml_1 = require("js-yaml");
+const importer_1 = require("../../importer");
+function parseAndValidateYamlConversion(steps, expectedStepName, expectedDescriptor) {
+    const yamlfiedSteps = (0, js_yaml_1.dump)(steps);
+    const loadedSteps = (0, importer_1.loadYamlSteps)(yamlfiedSteps, true);
+    expect(loadedSteps[0].name).toEqual(expectedStepName);
+    expect(loadedSteps[0].descriptor).toEqual(expectedDescriptor);
+    const yamlfied = (0, importer_1.yamlifyTheLoadedSteps)(loadedSteps);
+    expect(yamlfied).toEqual(yamlfiedSteps);
+}
+exports.parseAndValidateYamlConversion = parseAndValidateYamlConversion;
+function loadRawStepIntoMablStep(step) {
+    const yamlfiedSteps = (0, js_yaml_1.dump)([step]);
+    const loadedSteps = (0, importer_1.loadYamlSteps)(yamlfiedSteps, true);
+    return loadedSteps[0];
+}
+exports.loadRawStepIntoMablStep = loadRawStepIntoMablStep;