@applitools/driver 1.9.3 → 1.9.6

package/dist/capabilities.js

@@ -33,9 +33,13 @@ function parseCapabilities(capabilities, customConfig) {
         info.orientation = (_m = ((_l = capabilities.deviceOrientation) !== null && _l !== void 0 ? _l : capabilities.orientation)) === null || _m === void 0 ? void 0 : _m.toLowerCase();
     }
     if (info.isNative) {
+        info.displaySize = extractDisplaySize(capabilities);
         info.pixelRatio = capabilities.pixelRatio;
         info.statusBarHeight = capabilities.statBarHeight;
-        info.displaySize = extractDisplaySize(capabilities);
+        if (info.displaySize && capabilities.viewportRect) {
+            info.navigationBarHeight =
+                info.displaySize.height - (capabilities.viewportRect.top + capabilities.viewportRect.height);
+        }
     }
     return info;
 }

package/dist/driver.js

@@ -184,14 +184,17 @@ class Driver {
                     // navigation bar height is replaced with the width in landscape orientation on android (due to the bug in appium)
                     if (orientation === 'landscape')
                         barsSize.navigationBarHeight = barsSize.navigationBarWidth;
-                    // when status bar is overlapping content on android it returns status bar height equal to viewport height
+                    // when status bar is overlapping content on android it returns status bar height equal to display height
                     if (barsSize.statusBarHeight < this._driverInfo.displaySize.height) {
                         this._driverInfo.statusBarHeight = Math.max((_u = this._driverInfo.statusBarHeight) !== null && _u !== void 0 ? _u : 0, barsSize.statusBarHeight);
                     }
-                    // when navigation bar is invisible on android it returns navigation bar height equal to viewport height
+                    // when navigation bar is invisible on android it returns navigation bar height equal to display height
                     if (barsSize.navigationBarHeight < this._driverInfo.displaySize.height) {
                         this._driverInfo.navigationBarHeight = Math.max((_v = this._driverInfo.navigationBarHeight) !== null && _v !== void 0 ? _v : 0, barsSize.navigationBarHeight);
                     }
+                    else {
+                        this._driverInfo.navigationBarHeight = 0;
+                    }
                     // bar heights have to be scaled on android
                     (_5 = this._driverInfo).statusBarHeight && (_5.statusBarHeight = this._driverInfo.statusBarHeight / this.pixelRatio);
                     (_6 = this._driverInfo).navigationBarHeight && (_6.navigationBarHeight = this._driverInfo.navigationBarHeight / this.pixelRatio);

package/dist/element.js

@@ -278,18 +278,24 @@ class Element {
         });
     }
     async getTouchPadding() {
+        var _a, _b;
         if (this._state.touchPadding == null) {
             if (this.driver.isWeb)
                 this._state.touchPadding = 0;
             else if (this.driver.isIOS)
                 this._state.touchPadding = 10;
             else if (this.driver.isAndroid) {
-                const touchPadding = await this.getAttribute('contentSize')
-                    .then(data => JSON.parse(data).touchPadding)
-                    .catch(err => {
-                    this._logger.warn(`Unable to get the attribute 'contentSize' when looking up 'touchPadding' due to the following error: '${err.message}'`);
-                });
-                this._state.touchPadding = touchPadding !== null && touchPadding !== void 0 ? touchPadding : 21;
+                if (((_a = this.driver.helper) === null || _a === void 0 ? void 0 : _a.name) === 'android') {
+                    this._state.touchPadding = await ((_b = this.driver.helper) === null || _b === void 0 ? void 0 : _b.getTouchPadding());
+                }
+                if (!this._state.touchPadding) {
+                    const touchPadding = await this.getAttribute('contentSize')
+                        .then(data => JSON.parse(data).touchPadding)
+                        .catch(err => {
+                        this._logger.warn(`Unable to get the attribute 'contentSize' when looking up 'touchPadding' due to the following error: '${err.message}'`);
+                    });
+                    this._state.touchPadding = touchPadding !== null && touchPadding !== void 0 ? touchPadding : 20;
+                }
                 this._logger.log('Touch padding set:', this._state.touchPadding);
             }
         }
@@ -355,6 +361,7 @@ class Element {
     }
     async scrollTo(offset, options) {
         return this.withRefresh(async () => {
+            var _a;
             offset = utils.geometry.round({ x: Math.max(offset.x, 0), y: Math.max(offset.y, 0) });
             if (this.driver.isWeb) {
                 let actualOffset = await this.context.execute(snippets.scrollTo, [this, offset]);
@@ -374,22 +381,29 @@ class Element {
                     y: Math.round(scrollableRegion.height * (contentSize.height / scrollableRegion.height - 1)),
                 };
                 const requiredOffset = { x: Math.min(offset.x, maxOffset.x), y: Math.min(offset.y, maxOffset.y) };
+                if (((_a = this.driver.helper) === null || _a === void 0 ? void 0 : _a.name) === 'android' && utils.geometry.equals(requiredOffset, { x: 0, y: 0 })) {
+                    await this.driver.helper.scrollToTop(this);
+                    this._state.scrollOffset = requiredOffset;
+                    return this._state.scrollOffset;
+                }
                 let effectiveRegion = scrollableRegion;
                 let remainingOffset = utils.geometry.equals(requiredOffset, { x: 0, y: 0 })
                     ? { x: -maxOffset.x, y: -maxOffset.y } // if it has to be scrolled to the very beginning, then scroll maximum amount of pixels
                     : utils.geometry.offsetNegative(requiredOffset, currentScrollOffset);
                 if (this.driver.isAndroid) {
-                    remainingOffset = utils.geometry.scale(remainingOffset, this.driver.pixelRatio);
-                    effectiveRegion = utils.geometry.scale(effectiveRegion, this.driver.pixelRatio);
+                    remainingOffset = utils.geometry.round(utils.geometry.scale(remainingOffset, this.driver.pixelRatio));
+                    effectiveRegion = utils.geometry.round(utils.geometry.scale(effectiveRegion, this.driver.pixelRatio));
                 }
-                const actions = [];
-                const touchPadding = await this.getTouchPadding();
                 const isPager = await this.isPager();
-                const xPadding = Math.max(Math.floor(effectiveRegion.width * 0.07), touchPadding);
+                const touchPadding = await this.getTouchPadding();
+                const actions = [];
+                // horizontal scrolling
+                const xPadding = touchPadding + 3;
                 const yTrack = Math.floor(effectiveRegion.y + effectiveRegion.height / 2); // center
                 const xLeft = effectiveRegion.y + xPadding;
                 const xDirection = remainingOffset.x > 0 ? 'right' : 'left';
                 const xGap = xDirection === 'right' ? -touchPadding : touchPadding;
+                const xCompensation = xDirection === 'right' ? -1 : 1;
                 let xRemaining = Math.abs(remainingOffset.x);
                 if (isPager) {
                     const xPages = Math.floor(xRemaining / effectiveRegion.width);
@@ -407,28 +421,44 @@ class Element {
                             { action: 'release' },
                         ]);
                     }
-                    else {
+                    else if (this.driver.isAndroid) {
+                        actions.push([
+                            // move through scrolling gap (actual scrolling will be triggered only after that)
+                            { action: 'press', y: yTrack, x: xStart - xGap },
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', y: yTrack, x: xStart + xCompensation },
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', y: yTrack, x: xStart },
+                            // perform actual scrolling
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', y: yTrack, x: xEnd },
+                            { action: 'release' },
+                        ]);
+                    }
+                    else if (this.driver.isIOS) {
                         actions.push([
-                            { action: 'press', y: yTrack, x: xStart },
                             // move through scrolling gap (actual scrolling will be triggered only after that)
+                            { action: 'press', y: yTrack, x: xStart - xGap },
                             { action: 'wait', ms: 100 },
-                            { action: 'moveTo', y: yTrack, x: xStart + xGap },
+                            { action: 'moveTo', y: yTrack, x: xStart },
                             // perform actual scrolling
                             { action: 'wait', ms: 100 },
-                            { action: 'moveTo', y: yTrack, x: xEnd + xGap },
+                            { action: 'moveTo', y: yTrack, x: xEnd },
                             // prevent inertial scrolling after release
                             { action: 'wait', ms: 100 },
-                            { action: 'moveTo', y: yTrack + 1, x: xEnd + xGap },
+                            { action: 'moveTo', y: yTrack + 1, x: xEnd },
                             { action: 'release' },
                         ]);
                     }
                     xRemaining -= xRight - xLeft;
                 }
-                const yPadding = Math.max(Math.floor(effectiveRegion.height * 0.07), touchPadding);
+                // vertical scrolling
+                const yPadding = Math.max(Math.floor(effectiveRegion.height * 0.05), touchPadding + 3);
                 const xTrack = Math.floor(effectiveRegion.x + 5); // a little bit off left border
                 const yBottom = effectiveRegion.y + effectiveRegion.height - yPadding;
                 const yDirection = remainingOffset.y > 0 ? 'down' : 'up';
                 const yGap = yDirection === 'down' ? -touchPadding : touchPadding;
+                const yCompensation = yDirection === 'down' ? -1 : 1;
                 let yRemaining = Math.abs(remainingOffset.y);
                 if (isPager) {
                     const yPages = Math.floor(yRemaining / effectiveRegion.height);
@@ -446,18 +476,32 @@ class Element {
                             { action: 'release' },
                         ]);
                     }
-                    else {
+                    else if (this.driver.isAndroid) {
+                        actions.push([
+                            // move through scrolling gap (actual scrolling will be triggered only after that)
+                            { action: 'press', x: xTrack, y: yStart - yGap },
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', x: xTrack, y: yStart + yCompensation },
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', x: xTrack, y: yStart },
+                            // perform actual scrolling
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', x: xTrack, y: yEnd },
+                            { action: 'release' },
+                        ]);
+                    }
+                    else if (this.driver.isIOS) {
                         actions.push([
-                            { action: 'press', x: xTrack, y: yStart },
                             // move through scrolling gap (actual scrolling will be triggered only after that)
+                            { action: 'press', x: xTrack, y: yStart - yGap },
                             { action: 'wait', ms: 100 },
-                            { action: 'moveTo', x: xTrack, y: yStart + yGap },
+                            { action: 'moveTo', x: xTrack, y: yStart },
                             // perform actual scrolling
                             { action: 'wait', ms: 100 },
-                            { action: 'moveTo', x: xTrack, y: yEnd + yGap },
+                            { action: 'moveTo', x: xTrack, y: yEnd },
                             // prevent inertial scrolling after release
                             { action: 'wait', ms: 100 },
-                            { action: 'moveTo', x: xTrack + 1, y: yEnd + yGap },
+                            { action: 'moveTo', x: xTrack + 1, y: yEnd },
                             { action: 'release' },
                         ]);
                     }
@@ -474,10 +518,10 @@ class Element {
                     await this._spec.performAction(this.driver.target, [].concat(...actions));
                 }
                 const actualScrollableRegion = await this.getClientRegion();
-                this._state.scrollOffset = utils.geometry.round(utils.geometry.offsetNegative(requiredOffset, {
+                this._state.scrollOffset = utils.geometry.offsetNegative(requiredOffset, {
                     x: scrollableRegion.x - actualScrollableRegion.x,
                     y: scrollableRegion.y - actualScrollableRegion.y,
-                }));
+                });
                 return this._state.scrollOffset;
             }
         });

package/dist/helper-android.js

@@ -1,12 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HelperAndroid = void 0;
+const utils = __importStar(require("@applitools/utils"));
 class HelperAndroid {
     constructor(options) {
         this._spec = options.spec;
         this._element = options.element;
         this._legacy = options.legacy;
         this._logger = options.logger;
+        this.name = this._legacy ? 'android-legacy' : 'android';
     }
     static async make(options) {
         const { spec, driver, logger } = options;
@@ -31,10 +56,10 @@ class HelperAndroid {
         return resourceId.split('/')[1];
     }
     async getContentSize(element) {
-        let contentHeight;
+        let contentHeightString;
         if (this._legacy) {
             await this._element.click();
-            contentHeight = await this._element.getText();
+            contentHeightString = await this._element.getText();
         }
         else {
             const elementId = await this._getElementId(element);
@@ -42,11 +67,14 @@ class HelperAndroid {
                 return null;
             await this._element.type(`offset;${elementId};0;0;0`);
             await this._element.click();
-            contentHeight = await this._element.getText();
+            contentHeightString = await this._element.getText();
             await this._element.type('');
         }
         const region = await this._spec.getElementRegion(this._element.driver.target, element.target);
-        return { width: region.width, height: Number(contentHeight) };
+        const contentHeight = Number(contentHeightString);
+        if (Number.isNaN(contentHeight))
+            return utils.geometry.size(region);
+        return { width: region.width, height: contentHeight };
     }
     async getRegion(element) {
         if (this._legacy)
@@ -64,5 +92,37 @@ class HelperAndroid {
             return null;
         return region;
     }
+    async scrollToTop(element) {
+        if (this._legacy)
+            return null;
+        const elementId = await this._getElementId(element);
+        if (!elementId)
+            return null;
+        await this._element.type(`moveToTop;${elementId};0;-1`);
+        await this._element.click();
+        await this._element.type('');
+    }
+    async scrollBy(element, offset) {
+        if (this._legacy)
+            return null;
+        const elementId = await this._getElementId(element);
+        if (!elementId)
+            return null;
+        await this._element.type(`scroll;${elementId};${offset.y};0;0`);
+        await this._element.click();
+        await this._element.type('');
+    }
+    async getTouchPadding() {
+        if (this._legacy)
+            return null;
+        await this._element.type(`getTouchPadding;0;0;0;0`);
+        await this._element.click();
+        const touchPaddingString = await this._element.getText();
+        await this._element.type('');
+        const touchPadding = Number(touchPaddingString);
+        if (Number.isNaN(touchPadding))
+            return null;
+        return touchPadding;
+    }
 }
 exports.HelperAndroid = HelperAndroid;

package/dist/helper-ios.js

@@ -7,6 +7,7 @@ class HelperIOS {
         this._element = options.element;
         this._spec = options.spec;
         this._logger = options.logger;
+        this.name = 'ios';
     }
     static async make(options) {
         const { spec, driver, logger } = options;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/driver",
-  "version": "1.9.3",
+  "version": "1.9.6",
   "description": "Applitools universal framework wrapper",
   "keywords": [
     "applitools",
@@ -76,10 +76,10 @@
     }
   },
   "dependencies": {
-    "@applitools/logger": "1.1.11",
-    "@applitools/snippets": "2.4.1",
-    "@applitools/types": "1.5.2",
-    "@applitools/utils": "1.3.7"
+    "@applitools/logger": "1.1.13",
+    "@applitools/snippets": "2.4.3",
+    "@applitools/types": "1.5.4",
+    "@applitools/utils": "1.3.9"
   },
   "devDependencies": {
     "@applitools/bongo": "^2.1.5",

package/types/helper-android.d.ts

@@ -12,6 +12,7 @@ export declare class HelperAndroid<TDriver, TContext, TElement, TSelector> {
     private readonly _element;
     private readonly _legacy;
     private _logger;
+    readonly name: 'android' | 'android-legacy';
     constructor(options: {
         spec: types.SpecDriver<TDriver, TContext, TElement, TSelector>;
         element: Element<TDriver, TContext, TElement, TSelector>;
@@ -21,4 +22,7 @@ export declare class HelperAndroid<TDriver, TContext, TElement, TSelector> {
     _getElementId(element: Element<TDriver, TContext, TElement, TSelector>): Promise<string>;
     getContentSize(element: Element<TDriver, TContext, TElement, TSelector>): Promise<types.Size>;
     getRegion(element: Element<TDriver, TContext, TElement, TSelector>): Promise<types.Region>;
+    scrollToTop(element: Element<TDriver, TContext, TElement, TSelector>): Promise<void>;
+    scrollBy(element: Element<TDriver, TContext, TElement, TSelector>, offset: types.Location): Promise<void>;
+    getTouchPadding(): Promise<number>;
 }

package/types/helper-ios.d.ts

@@ -12,6 +12,7 @@ export declare class HelperIOS<TDriver, TContext, TElement, TSelector> {
     private readonly _element;
     private readonly _spec;
     private _logger;
+    readonly name: 'ios';
     constructor(options: {
         driver: Driver<TDriver, TContext, TElement, TSelector>;
         element: Element<TDriver, TContext, TElement, TSelector>;