@applitools/driver 1.9.4 → 1.9.5

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,11 +184,11 @@ 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);
                     }

package/dist/element.js

@@ -288,7 +288,7 @@ class Element {
                 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());
                 }
-                else {
+                if (!this._state.touchPadding) {
                     const touchPadding = await this.getAttribute('contentSize')
                         .then(data => JSON.parse(data).touchPadding)
                         .catch(err => {
@@ -394,15 +394,16 @@ class Element {
                     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 isPager = await this.isPager();
                 const touchPadding = await this.getTouchPadding();
+                const actions = [];
                 // horizontal scrolling
-                const xPadding = Math.max(Math.floor(effectiveRegion.width * 0.07), touchPadding);
+                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);
@@ -420,29 +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;
                 }
                 // vertical scrolling
-                const yPadding = Math.max(Math.floor(effectiveRegion.height * 0.07), touchPadding);
+                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);
@@ -460,18 +476,32 @@ class Element {
                             { action: 'release' },
                         ]);
                     }
-                    else {
+                    else if (this.driver.isAndroid) {
                         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 + yCompensation },
+                            { action: 'wait', ms: 100 },
+                            { 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 },
+                            { action: 'release' },
+                        ]);
+                    }
+                    else if (this.driver.isIOS) {
+                        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 },
+                            // perform actual scrolling
+                            { action: 'wait', ms: 100 },
+                            { 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' },
                         ]);
                     }
@@ -488,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,6 +1,30 @@
 "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;
@@ -32,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);
@@ -43,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)
@@ -71,7 +98,7 @@ class HelperAndroid {
         const elementId = await this._getElementId(element);
         if (!elementId)
             return null;
-        await this._element.type(`moveToTop;${elementId};0;0`);
+        await this._element.type(`moveToTop;${elementId};0;-1`);
         await this._element.click();
         await this._element.type('');
     }
@@ -92,7 +119,10 @@ class HelperAndroid {
         await this._element.click();
         const touchPaddingString = await this._element.getText();
         await this._element.type('');
-        return Number(touchPaddingString);
+        const touchPadding = Number(touchPaddingString);
+        if (Number.isNaN(touchPadding))
+            return null;
+        return touchPadding;
     }
 }
 exports.HelperAndroid = HelperAndroid;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/driver",
-  "version": "1.9.4",
+  "version": "1.9.5",
   "description": "Applitools universal framework wrapper",
   "keywords": [
     "applitools",
@@ -76,10 +76,10 @@
     }
   },
   "dependencies": {
-    "@applitools/logger": "1.1.12",
-    "@applitools/snippets": "2.4.2",
-    "@applitools/types": "1.5.3",
-    "@applitools/utils": "1.3.8"
+    "@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",