@applitools/driver 1.8.16 → 1.9.2

package/dist/capabilities.js

@@ -35,6 +35,7 @@ function parseCapabilities(capabilities, customConfig) {
     if (info.isNative) {
         info.pixelRatio = capabilities.pixelRatio;
         info.statusBarHeight = capabilities.statBarHeight;
+        info.displaySize = extractDisplaySize(capabilities);
     }
     return info;
 }
@@ -66,3 +67,11 @@ function isIOS(capabilities) {
 function isAndroid(capabilities) {
     return /Android/i.test(capabilities.platformName) || /Android/i.test(capabilities.browserName);
 }
+function extractDisplaySize(capabilities) {
+    if (!capabilities.deviceScreenSize)
+        return undefined;
+    const [width, height] = capabilities.deviceScreenSize.split('x');
+    if (Number.isNaN(Number(width)) || Number.isNaN(Number(height)))
+        return undefined;
+    return { width: Number(width), height: Number(height) };
+}

package/dist/driver.js

@@ -144,72 +144,87 @@ class Driver {
         this._currentContext = context;
     }
     async init() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
-        var _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+        var _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8;
         const capabilities = await ((_b = (_a = this._spec).getCapabilities) === null || _b === void 0 ? void 0 : _b.call(_a, this.target));
         this._logger.log('Driver capabilities', capabilities);
         const capabilitiesInfo = capabilities ? (0, capabilities_1.parseCapabilities)(capabilities, this._customConfig) : undefined;
         const driverInfo = await ((_d = (_c = this._spec).getDriverInfo) === null || _d === void 0 ? void 0 : _d.call(_c, this.target));
         this._driverInfo = { ...capabilitiesInfo, ...driverInfo };
         if (this.isWeb) {
-            (_e = (_w = this._driverInfo).pixelRatio) !== null && _e !== void 0 ? _e : (_w.pixelRatio = await this.execute(snippets.getPixelRatio));
-            (_f = (_x = this._driverInfo).viewportScale) !== null && _f !== void 0 ? _f : (_x.viewportScale = await this.execute(snippets.getViewportScale));
-            (_g = (_y = this._driverInfo).userAgent) !== null && _g !== void 0 ? _g : (_y.userAgent = await this.execute(snippets.getUserAgent));
+            (_e = (_x = this._driverInfo).pixelRatio) !== null && _e !== void 0 ? _e : (_x.pixelRatio = await this.execute(snippets.getPixelRatio));
+            (_f = (_y = this._driverInfo).viewportScale) !== null && _f !== void 0 ? _f : (_y.viewportScale = await this.execute(snippets.getViewportScale));
+            (_g = (_z = this._driverInfo).userAgent) !== null && _g !== void 0 ? _g : (_z.userAgent = await this.execute(snippets.getUserAgent));
             if (this._driverInfo.userAgent) {
                 const userAgentInfo = (0, user_agent_1.parseUserAgent)(this._driverInfo.userAgent);
                 this._driverInfo.browserName = (_h = userAgentInfo.browserName) !== null && _h !== void 0 ? _h : this._driverInfo.browserName;
                 this._driverInfo.browserVersion = (_j = userAgentInfo.browserVersion) !== null && _j !== void 0 ? _j : this._driverInfo.browserVersion;
                 if (this._driverInfo.isMobile) {
-                    (_k = (_z = this._driverInfo).platformName) !== null && _k !== void 0 ? _k : (_z.platformName = userAgentInfo.platformName);
-                    (_l = (_0 = this._driverInfo).platformVersion) !== null && _l !== void 0 ? _l : (_0.platformVersion = userAgentInfo.platformVersion);
+                    (_k = (_0 = this._driverInfo).platformName) !== null && _k !== void 0 ? _k : (_0.platformName = userAgentInfo.platformName);
+                    (_l = (_1 = this._driverInfo).platformVersion) !== null && _l !== void 0 ? _l : (_1.platformVersion = userAgentInfo.platformVersion);
                 }
                 else {
                     this._driverInfo.platformName = (_m = userAgentInfo.platformName) !== null && _m !== void 0 ? _m : this._driverInfo.platformName;
                     this._driverInfo.platformVersion = (_o = userAgentInfo.platformVersion) !== null && _o !== void 0 ? _o : this._driverInfo.platformVersion;
                 }
             }
-            (_p = (_1 = this._driverInfo).features) !== null && _p !== void 0 ? _p : (_1.features = {});
-            (_q = (_2 = this._driverInfo.features).allCookies) !== null && _q !== void 0 ? _q : (_2.allCookies = /chrome/i.test(this._driverInfo.browserName) && !this._driverInfo.isMobile);
+            (_p = (_2 = this._driverInfo).features) !== null && _p !== void 0 ? _p : (_2.features = {});
+            (_q = (_3 = this._driverInfo.features).allCookies) !== null && _q !== void 0 ? _q : (_3.allCookies = /chrome/i.test(this._driverInfo.browserName) && !this._driverInfo.isMobile);
         }
         else {
-            const displaySize = await this.getDisplaySize();
+            // this value always excludes the height of the navigation bar, and sometimes it also excludes the height of the status bar
+            let windowSize = await this._spec.getWindowSize(this.target);
+            (_r = (_4 = this._driverInfo).displaySize) !== null && _r !== void 0 ? _r : (_4.displaySize = windowSize);
             const orientation = await this.getOrientation();
-            // calculate status and navigation bars sizes
             if (this.isAndroid) {
                 // bar sizes could be extracted only on android
-                const barsSize = await ((_s = (_r = this._spec).getBarsSize) === null || _s === void 0 ? void 0 : _s.call(_r, this.target).catch(() => undefined));
+                const barsSize = await ((_t = (_s = this._spec).getBarsSize) === null || _t === void 0 ? void 0 : _t.call(_s, this.target).catch(() => undefined));
                 if (barsSize) {
                     this._logger.log('Driver bars size', barsSize);
                     // 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
-                    if (barsSize.statusBarHeight / this.pixelRatio < displaySize.height) {
-                        this._driverInfo.statusBarHeight = Math.max((_t = this._driverInfo.statusBarHeight) !== null && _t !== void 0 ? _t : 0, barsSize.statusBarHeight);
+                    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
-                    if (barsSize.navigationBarHeight / this.pixelRatio < displaySize.height) {
-                        this._driverInfo.navigationBarHeight = Math.max((_u = this._driverInfo.navigationBarHeight) !== null && _u !== void 0 ? _u : 0, barsSize.navigationBarHeight);
-                    }
-                    else {
-                        // if navigation bar height is bigger then display height he can use it to reset display height
-                        displaySize.height = barsSize.navigationBarHeight / this.pixelRatio;
+                    if (barsSize.navigationBarHeight < this._driverInfo.displaySize.height) {
+                        this._driverInfo.navigationBarHeight = Math.max((_v = this._driverInfo.navigationBarHeight) !== null && _v !== void 0 ? _v : 0, barsSize.navigationBarHeight);
                     }
                     // bar heights have to be scaled on android
-                    (_3 = this._driverInfo).statusBarHeight && (_3.statusBarHeight = this._driverInfo.statusBarHeight / this.pixelRatio);
-                    (_4 = this._driverInfo).navigationBarHeight && (_4.navigationBarHeight = this._driverInfo.navigationBarHeight / this.pixelRatio);
+                    (_5 = this._driverInfo).statusBarHeight && (_5.statusBarHeight = this._driverInfo.statusBarHeight / this.pixelRatio);
+                    (_6 = this._driverInfo).navigationBarHeight && (_6.navigationBarHeight = this._driverInfo.navigationBarHeight / this.pixelRatio);
                 }
+                windowSize = utils.geometry.scale(this._driverInfo.displaySize, 1 / this.pixelRatio);
+                (_7 = this._driverInfo).displaySize && (_7.displaySize = utils.geometry.scale(this._driverInfo.displaySize, 1 / this.pixelRatio));
             }
             // calculate viewport size
             if (!this._driverInfo.viewportSize) {
-                this._driverInfo.viewportSize = {
-                    width: displaySize.width,
-                    height: displaySize.height - this.statusBarHeight,
-                };
+                if (this.navigationBarHeight > 1) {
+                    if (orientation === 'landscape') {
+                        this._driverInfo.viewportSize = {
+                            width: this._driverInfo.displaySize.height - this.navigationBarHeight,
+                            height: this._driverInfo.displaySize.width - this.statusBarHeight,
+                        };
+                    }
+                    else {
+                        this._driverInfo.viewportSize = {
+                            width: this._driverInfo.displaySize.width,
+                            height: this._driverInfo.displaySize.height - this.statusBarHeight - this.navigationBarHeight,
+                        };
+                    }
+                }
+                else {
+                    this._driverInfo.viewportSize = {
+                        width: windowSize.width,
+                        height: windowSize.height - this.statusBarHeight,
+                    };
+                }
             }
             // calculate safe area
             if (this.isIOS && !this._driverInfo.safeArea) {
-                this._driverInfo.safeArea = { x: 0, y: 0, ...displaySize };
+                this._driverInfo.safeArea = { x: 0, y: 0, ...this._driverInfo.displaySize };
                 const topElement = await this.element({ type: '-ios class chain', selector: '**/XCUIElementTypeNavigationBar' });
                 if (topElement) {
                     const topRegion = await this._spec.getElementRegion(this.target, topElement.target);
@@ -230,7 +245,7 @@ class Driver {
                 : await helper_android_1.HelperAndroid.make({ spec: this._spec, driver: this, logger: this._logger });
         }
         if (this.isMobile) {
-            (_v = (_5 = this._driverInfo).orientation) !== null && _v !== void 0 ? _v : (_5.orientation = await this.getOrientation().catch(() => undefined));
+            (_w = (_8 = this._driverInfo).orientation) !== null && _w !== void 0 ? _w : (_8.orientation = await this.getOrientation().catch(() => undefined));
         }
         this._logger.log('Combined driver info', this._driverInfo);
         return this;
@@ -400,19 +415,22 @@ class Driver {
     async normalizeRegion(region) {
         if (this.isWeb || !utils.types.has(this._driverInfo, ['viewportSize', 'statusBarHeight']))
             return region;
-        const scaledRegion = this.isAndroid ? utils.geometry.scale(region, 1 / this.pixelRatio) : region;
-        const safeRegion = this.isIOS && utils.geometry.isIntersected(scaledRegion, this._driverInfo.safeArea)
-            ? utils.geometry.intersect(scaledRegion, this._driverInfo.safeArea)
-            : scaledRegion;
-        const offsetRegion = utils.geometry.offsetNegative(safeRegion, {
+        let normalizedRegion = region;
+        if (this.isAndroid) {
+            normalizedRegion = utils.geometry.scale(normalizedRegion, 1 / this.pixelRatio);
+        }
+        if (this.isIOS && utils.geometry.isIntersected(normalizedRegion, this._driverInfo.safeArea)) {
+            normalizedRegion = utils.geometry.intersect(normalizedRegion, this._driverInfo.safeArea);
+        }
+        normalizedRegion = utils.geometry.offsetNegative(normalizedRegion, {
             x: this.isAndroid && this.orientation === 'landscape' && this.platformVersion > 7 ? this.navigationBarHeight : 0,
             y: this.statusBarHeight,
         });
-        if (offsetRegion.y < 0) {
-            offsetRegion.height += offsetRegion.y;
-            offsetRegion.y = 0;
+        if (normalizedRegion.y < 0) {
+            normalizedRegion.height += normalizedRegion.y;
+            normalizedRegion.y = 0;
         }
-        return offsetRegion;
+        return normalizedRegion;
     }
     async getRegionInViewport(context, region) {
         await context.focus();
@@ -445,12 +463,6 @@ class Driver {
             else {
                 this._logger.log('Extracting viewport size from native driver');
                 size = await this.getDisplaySize();
-                if (size.height > size.width) {
-                    const orientation = await this.getOrientation();
-                    if (orientation === 'landscape') {
-                        size = { width: size.height, height: size.width };
-                    }
-                }
                 size.height -= this.statusBarHeight;
             }
             this._logger.log(`Rounding viewport size using`, this._customConfig.useCeilForViewportSize ? 'ceil' : 'round');
@@ -508,9 +520,17 @@ class Driver {
         throw new Error('Failed to set viewport size!');
     }
     async getDisplaySize() {
+        var _a;
         if (this.isWeb && !this.isMobile)
             return;
-        const size = await this._spec.getWindowSize(this.target);
+        if ((_a = this._driverInfo) === null || _a === void 0 ? void 0 : _a.displaySize) {
+            this._logger.log('Extracting display size from native driver using cached value');
+            return this._driverInfo.displaySize;
+        }
+        let size = await this._spec.getWindowSize(this.target);
+        if ((await this.getOrientation()) === 'landscape' && size.height > size.width) {
+            size = { width: size.height, height: size.width };
+        }
         const normalizedSize = this.isAndroid ? utils.geometry.scale(size, 1 / this.pixelRatio) : size;
         this._logger.log('Extracted and normalized display size:', normalizedSize);
         return normalizedSize;

package/dist/element.js

@@ -88,20 +88,46 @@ class Element {
     }
     async contains(innerElement) {
         const contains = await this.withRefresh(async () => {
+            var _a, _b, _c, _d, _e;
+            var _f;
             innerElement = innerElement instanceof Element ? innerElement.target : innerElement;
             if (this.driver.isWeb) {
                 this._logger.log('Checking if web element with selector', this.selector, 'contains element', innerElement);
                 return false; // TODO implement a snipped for web
             }
             else {
+                if ((_a = this._state.containedElements) === null || _a === void 0 ? void 0 : _a.has(innerElement))
+                    return this._state.containedElements.get(innerElement);
                 this._logger.log('Checking if native element with selector', this.selector, 'contains element', innerElement);
                 // appium doesn't have a way to check if an element is contained in another element, so juristic applied
                 if (await this.equals(innerElement))
                     return false;
-                // if inner element region is located contained in the this element region, then it is contained
-                const region = await this._spec.getElementRegion(this.driver.target, this.target);
+                // if the inner element region is contained in this element region, then it then could be assumed that the inner element is contained in this element
+                const contentRegion = await this.getAttribute('contentSize')
+                    .then(data => {
+                    const contentSize = JSON.parse(data);
+                    return {
+                        x: contentSize.left,
+                        y: contentSize.top,
+                        width: contentSize.width,
+                        height: this.driver.isIOS
+                            ? Math.max(contentSize.height, contentSize.scrollableOffset)
+                            : contentSize.height + contentSize.scrollableOffset,
+                    };
+                })
+                    .catch(() => this._spec.getElementRegion(this.driver.target, this.target));
+                const contentSize = await ((_b = this.driver.helper) === null || _b === void 0 ? void 0 : _b.getContentSize(this));
+                const region = {
+                    x: contentRegion.x,
+                    y: contentRegion.y,
+                    width: Math.max((_c = contentSize === null || contentSize === void 0 ? void 0 : contentSize.width) !== null && _c !== void 0 ? _c : 0, contentRegion.width),
+                    height: Math.max((_d = contentSize === null || contentSize === void 0 ? void 0 : contentSize.height) !== null && _d !== void 0 ? _d : 0, contentRegion.height),
+                };
                 const innerRegion = await this._spec.getElementRegion(this.driver.target, innerElement);
-                return utils.geometry.contains(region, innerRegion);
+                const contains = utils.geometry.contains(region, innerRegion);
+                (_e = (_f = this._state).containedElements) !== null && _e !== void 0 ? _e : (_f.containedElements = new Map());
+                this._state.containedElements.set(innerElement, contains);
+                return contains;
             }
         });
         this._logger.log('Element with selector', this.selector, contains ? 'contains' : `doesn't contain`, innerElement);
@@ -166,19 +192,20 @@ class Element {
             else {
                 this._logger.log('Extracting content size of native element with selector', this.selector);
                 try {
-                    const { touchPadding, ...contentRegion } = await this.getAttribute('contentSize')
+                    const contentRegion = await this.getAttribute('contentSize')
                         .then(data => {
                         const contentSize = JSON.parse(data);
                         return {
-                            touchPadding: contentSize.touchPadding,
                             x: contentSize.left,
                             y: contentSize.top,
                             width: contentSize.width,
-                            height: (this.driver.isAndroid ? contentSize.height : 0) + contentSize.scrollableOffset,
+                            height: this.driver.isIOS
+                                ? Math.max(contentSize.height, contentSize.scrollableOffset)
+                                : contentSize.height + contentSize.scrollableOffset,
                         };
                     })
                         .catch(err => {
-                        this._logger.log(`Unable to get the attribute 'contentSize' when looking up touchPadding due to the following error:`, `'${err.message}'`);
+                        this._logger.warn(`Unable to get the attribute 'contentSize' due to the following error: '${err.message}'`);
                         return this._spec.getElementRegion(this.driver.target, this.target);
                     });
                     this._logger.log('Extracted native content size attribute', contentRegion);
@@ -188,22 +215,12 @@ class Element {
                         width: Math.max((_b = contentSize === null || contentSize === void 0 ? void 0 : contentSize.width) !== null && _b !== void 0 ? _b : 0, contentRegion.width),
                         height: Math.max((_c = contentSize === null || contentSize === void 0 ? void 0 : contentSize.height) !== null && _c !== void 0 ? _c : 0, contentRegion.height),
                     };
-                    this._touchPadding = touchPadding !== null && touchPadding !== void 0 ? touchPadding : this._touchPadding;
-                    this._logger.log('touchPadding', this._touchPadding);
                     if (this.driver.isAndroid) {
                         this._state.contentSize = utils.geometry.scale(this._state.contentSize, 1 / this.driver.pixelRatio);
                     }
                     if (contentRegion.y < this.driver.statusBarHeight) {
                         this._state.contentSize.height -= this.driver.statusBarHeight - contentRegion.y;
                     }
-                    // android has a bug when after extracting 'contentSize' attribute the element is being scrolled by undetermined number of pixels
-                    if (this.driver.isAndroid) {
-                        this._logger.log('Stabilizing android scroll offset');
-                        const originalScrollOffset = await this.getScrollOffset();
-                        this._state.scrollOffset = { x: -1, y: -1 };
-                        await this.scrollTo({ x: 0, y: 0 });
-                        await this.scrollTo(originalScrollOffset);
-                    }
                     return this._state.contentSize;
                 }
                 catch (err) {
@@ -216,8 +233,22 @@ class Element {
         this._logger.log('Extracted content size', size);
         return size;
     }
+    async isPager() {
+        this._logger.log('Check if element with selector', this.selector, 'is scrollable by pages');
+        const isPager = await this.withRefresh(async () => {
+            if (this.driver.isAndroid) {
+                const className = await this.getAttribute('className');
+                return ['androidx.viewpager.widget.ViewPager'].includes(className);
+            }
+            else {
+                return false;
+            }
+        });
+        this._logger.log('Element scrollable by pages', isPager);
+        return isPager;
+    }
     async isScrollable() {
-        this._logger.log('Check is element with selector', this.selector, 'is scrollable');
+        this._logger.log('Check if element with selector', this.selector, 'is scrollable');
         const isScrollable = await this.withRefresh(async () => {
             if (this.driver.isWeb) {
                 return this.context.execute(snippets.isElementScrollable, [this]);
@@ -247,23 +278,22 @@ class Element {
         });
     }
     async getTouchPadding() {
-        var _a;
-        if (this._touchPadding == null) {
+        if (this._state.touchPadding == null) {
             if (this.driver.isWeb)
-                this._touchPadding = 0;
+                this._state.touchPadding = 0;
             else if (this.driver.isIOS)
-                this._touchPadding = 10;
+                this._state.touchPadding = 10;
             else if (this.driver.isAndroid) {
-                const data = await this.getAttribute('contentSize')
-                    .then(JSON.parse)
+                const touchPadding = await this.getAttribute('contentSize')
+                    .then(data => JSON.parse(data).touchPadding)
                     .catch(err => {
-                    this._logger.log(`Unable to get the attribute 'contentSize' when looking up touchPadding due to the following error:`, `'${err.message}'`);
+                    this._logger.warn(`Unable to get the attribute 'contentSize' when looking up 'touchPadding' due to the following error: '${err.message}'`);
                 });
-                this._touchPadding = (_a = data === null || data === void 0 ? void 0 : data.touchPadding) !== null && _a !== void 0 ? _a : 20;
-                this._logger.log('touchPadding', this._touchPadding);
+                this._state.touchPadding = touchPadding !== null && touchPadding !== void 0 ? touchPadding : 20;
+                this._logger.log('Touch padding set:', this._state.touchPadding);
             }
         }
-        return this._touchPadding;
+        return this._state.touchPadding;
     }
     async getText() {
         const text = await this.withRefresh(async () => {
@@ -279,20 +309,41 @@ class Element {
         return text;
     }
     async getAttribute(name) {
-        if (this.driver.isWeb) {
-            const properties = await this.context.execute(snippets.getElementProperties, [this, [name]]);
-            return properties[name];
-        }
-        else {
-            return this._spec.getElementAttribute(this.driver.target, this.target, name);
-        }
+        var _a;
+        // we assumes that attributes are not changed during the session
+        if ((_a = this._state.attributes) === null || _a === void 0 ? void 0 : _a[name])
+            return this._state.attributes[name];
+        const value = await this.withRefresh(async () => {
+            var _a;
+            var _b;
+            if (this.driver.isWeb) {
+                const properties = await this.context.execute(snippets.getElementProperties, [this, [name]]);
+                return properties[name];
+            }
+            else {
+                this._logger.log(`Extracting "${name}" attribute of native element with selector`, this.selector);
+                const value = await this._spec.getElementAttribute(this.driver.target, this.target, name);
+                (_a = (_b = this._state).attributes) !== null && _a !== void 0 ? _a : (_b.attributes = {});
+                this._state.attributes[name] = value;
+                if (this.driver.isAndroid && name === 'contentSize') {
+                    // android has a bug when after extracting 'contentSize' attribute the element is being scrolled by undetermined number of pixels
+                    this._logger.log('Stabilizing android scroll offset');
+                    const originalScrollOffset = await this.getScrollOffset();
+                    await this.scrollTo({ x: 0, y: 0 }, { force: true });
+                    await this.scrollTo(originalScrollOffset);
+                }
+                return value;
+            }
+        });
+        this._logger.log(`Extracted element "${name}" attribute:`, value);
+        return value;
     }
     async setAttribute(name, value) {
         if (this.driver.isWeb) {
             await this.context.execute(snippets.setElementAttributes, [this, { [name]: value }]);
         }
     }
-    async scrollTo(offset) {
+    async scrollTo(offset, options) {
         return this.withRefresh(async () => {
             offset = utils.geometry.round({ x: Math.max(offset.x, 0), y: Math.max(offset.y, 0) });
             if (this.driver.isWeb) {
@@ -304,75 +355,112 @@ class Element {
             }
             else {
                 const currentScrollOffset = await this.getScrollOffset();
-                if (utils.geometry.equals(offset, currentScrollOffset))
+                if (!(options === null || options === void 0 ? void 0 : options.force) && utils.geometry.equals(offset, currentScrollOffset))
                     return currentScrollOffset;
                 const contentSize = await this.getContentSize();
                 const scrollableRegion = await this.getClientRegion();
-                const effectiveRegion = this.driver.isAndroid
-                    ? utils.geometry.scale(scrollableRegion, this.driver.pixelRatio)
-                    : scrollableRegion;
                 const maxOffset = {
                     x: Math.round(scrollableRegion.width * (contentSize.width / scrollableRegion.width - 1)),
                     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) };
-                let remainingOffset = offset.x === 0 && offset.y === 0
+                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(scrollableRegion, this.driver.pixelRatio);
                 }
                 const actions = [];
                 const touchPadding = await this.getTouchPadding();
-                const xPadding = Math.max(Math.floor(effectiveRegion.width * 0.1), touchPadding);
+                const isPager = await this.isPager();
+                const xPadding = Math.max(Math.floor(effectiveRegion.width * 0.07), touchPadding);
                 const yTrack = Math.floor(effectiveRegion.y + effectiveRegion.height / 2); // center
                 const xLeft = effectiveRegion.y + xPadding;
-                const xDirection = remainingOffset.y > 0 ? 'right' : 'left';
+                const xDirection = remainingOffset.x > 0 ? 'right' : 'left';
                 const xGap = xDirection === 'right' ? -touchPadding : touchPadding;
                 let xRemaining = Math.abs(remainingOffset.x);
+                if (isPager) {
+                    const xPages = Math.floor(xRemaining / effectiveRegion.width);
+                    xRemaining = (effectiveRegion.width - xPadding * 2) * xPages;
+                }
                 while (xRemaining > 0) {
                     const xRight = effectiveRegion.x + Math.min(xRemaining + xPadding, effectiveRegion.width - xPadding);
                     const [xStart, xEnd] = xDirection === 'right' ? [xRight, xLeft] : [xLeft, xRight];
-                    actions.push([
-                        { action: 'press', y: yTrack, x: xStart },
-                        { action: 'wait', ms: 100 },
-                        { action: 'moveTo', y: yTrack, x: xStart + xGap },
-                        { action: 'wait', ms: 100 },
-                        { action: 'moveTo', y: yTrack, x: xEnd + xGap },
-                        { action: 'wait', ms: 100 },
-                        { action: 'moveTo', y: yTrack + 1, x: xEnd + xGap },
-                        { action: 'release' },
-                    ]);
+                    if (isPager) {
+                        actions.push([
+                            { action: 'press', y: yTrack, x: xStart },
+                            // scroll through the page
+                            { action: 'wait', ms: 170 },
+                            { action: 'moveTo', y: yTrack, x: xEnd },
+                            { action: 'release' },
+                        ]);
+                    }
+                    else {
+                        actions.push([
+                            { action: 'press', y: yTrack, x: xStart },
+                            // move through scrolling gap (actual scrolling will be triggered only after that)
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', y: yTrack, x: xStart + xGap },
+                            // perform actual scrolling
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', y: yTrack, x: xEnd + xGap },
+                            // prevent inertial scrolling after release
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', y: yTrack + 1, x: xEnd + xGap },
+                            { action: 'release' },
+                        ]);
+                    }
                     xRemaining -= xRight - xLeft;
                 }
-                const yPadding = Math.max(Math.floor(effectiveRegion.height * 0.1), touchPadding);
+                const yPadding = Math.max(Math.floor(effectiveRegion.height * 0.07), touchPadding);
                 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;
                 let yRemaining = Math.abs(remainingOffset.y);
+                if (isPager) {
+                    const yPages = Math.floor(yRemaining / effectiveRegion.height);
+                    yRemaining = (effectiveRegion.height - yPadding * 2) * yPages;
+                }
                 while (yRemaining > 0) {
                     const yTop = Math.max(yBottom - yRemaining, effectiveRegion.y + yPadding);
                     const [yStart, yEnd] = yDirection === 'down' ? [yBottom, yTop] : [yTop, yBottom];
-                    actions.push([
-                        { action: 'press', x: xTrack, y: yStart },
-                        { action: 'wait', ms: 100 },
-                        { action: 'moveTo', x: xTrack, y: yStart + yGap },
-                        { action: 'wait', ms: 100 },
-                        { action: 'moveTo', x: xTrack, y: yEnd + yGap },
-                        { action: 'wait', ms: 100 },
-                        { action: 'moveTo', x: xTrack + 1, y: yEnd + yGap },
-                        { action: 'release' },
-                    ]);
+                    if (isPager) {
+                        actions.push([
+                            { action: 'press', x: xTrack, y: yStart },
+                            // scroll through the page
+                            { action: 'wait', ms: 170 },
+                            { action: 'moveTo', x: xTrack, y: yEnd },
+                            { action: 'release' },
+                        ]);
+                    }
+                    else {
+                        actions.push([
+                            { action: 'press', x: xTrack, y: yStart },
+                            // move through scrolling gap (actual scrolling will be triggered only after that)
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', x: xTrack, y: yStart + yGap },
+                            // perform actual scrolling
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', x: xTrack, y: yEnd + yGap },
+                            // prevent inertial scrolling after release
+                            { action: 'wait', ms: 100 },
+                            { action: 'moveTo', x: xTrack + 1, y: yEnd + yGap },
+                            { action: 'release' },
+                        ]);
+                    }
                     yRemaining -= yBottom - yTop;
                 }
                 // ios actions should be executed one-by-one sequentially, otherwise the result isn't stable
-                if (this.driver.isIOS) {
+                // pages should be scrolled one-by-one as well
+                if (isPager || this.driver.isIOS) {
                     for (const action of actions) {
                         await this._spec.performAction(this.driver.target, action);
                     }
                 }
-                else {
+                else if (actions.length > 0) {
                     await this._spec.performAction(this.driver.target, [].concat(...actions));
                 }
                 const actualScrollableRegion = await this.getClientRegion();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/driver",
-  "version": "1.8.16",
+  "version": "1.9.2",
   "description": "Applitools universal framework wrapper",
   "keywords": [
     "applitools",
@@ -73,13 +73,13 @@
     }
   },
   "dependencies": {
-    "@applitools/logger": "1.1.8",
+    "@applitools/logger": "1.1.10",
     "@applitools/snippets": "2.2.3",
-    "@applitools/types": "1.4.5",
-    "@applitools/utils": "1.3.3"
+    "@applitools/types": "1.4.7",
+    "@applitools/utils": "1.3.6"
   },
   "devDependencies": {
-    "@applitools/bongo": "^2.1.1",
+    "@applitools/bongo": "^2.1.4",
     "@types/mocha": "^9.1.1",
     "@types/node": "^17.0.31",
     "@typescript-eslint/eslint-plugin": "^5.22.0",

package/types/element.d.ts

@@ -1,10 +1,13 @@
 import type * as types from '@applitools/types';
 import { type Logger } from '@applitools/logger';
 import { type Context } from './context';
-export declare type ElementState = {
+export declare type ElementState<TElement> = {
     contentSize?: types.Size;
     scrollOffset?: types.Location;
     transforms?: any;
+    attributes?: Record<string, string>;
+    touchPadding?: number;
+    containedElements?: Map<TElement, boolean>;
 };
 export declare class Element<TDriver, TContext, TElement, TSelector> {
     private _target;
@@ -13,7 +16,6 @@ export declare class Element<TDriver, TContext, TElement, TSelector> {
     private _index;
     private _state;
     private _originalOverflow;
-    private _touchPadding;
     private _logger;
     protected readonly _spec: types.SpecDriver<TDriver, TContext, TElement, TSelector>;
     constructor(options: {
@@ -36,21 +38,24 @@ export declare class Element<TDriver, TContext, TElement, TSelector> {
     getRegion(): Promise<types.Region>;
     getClientRegion(): Promise<types.Region>;
     getContentSize(): Promise<types.Size>;
+    isPager(): Promise<boolean>;
     isScrollable(): Promise<boolean>;
     isRoot(): Promise<boolean>;
     getTouchPadding(): Promise<number>;
     getText(): Promise<string>;
     getAttribute(name: string): Promise<string>;
     setAttribute(name: string, value: string): Promise<void>;
-    scrollTo(offset: types.Location): Promise<types.Location>;
+    scrollTo(offset: types.Location, options?: {
+        force: boolean;
+    }): Promise<types.Location>;
     translateTo(offset: types.Location): Promise<types.Location>;
     getScrollOffset(): Promise<types.Location>;
     getTranslateOffset(): Promise<types.Location>;
     getInnerOffset(): Promise<types.Location>;
     click(): Promise<void>;
     type(value: string): Promise<void>;
-    preserveState(): Promise<ElementState>;
-    restoreState(state?: ElementState): Promise<void>;
+    preserveState(): Promise<ElementState<TElement>>;
+    restoreState(state?: ElementState<TElement>): Promise<void>;
     hideScrollbars(): Promise<void>;
     restoreScrollbars(): Promise<void>;
     refresh(freshElement?: TElement): Promise<boolean>;