@applitools/driver 1.3.3 → 1.4.1

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 ## Unreleased
 
 
+## 1.4.1 - 2021/12/16
+
+- updated to @applitools/snippets@2.1.8 (from 2.1.7)
+
+## 1.4.0 - 2021/12/16
+
+- improve native apps scrolling automation
+- fix ios safe area related issues
+- add helper library abstraction to cover appium edge cases
+- made `setViewportSize` more reliable in worst case scenario and faster in best case scenario
+- updated to @applitools/types@1.0.22 (from 1.0.21)
+
+## 1.3.5 - 2021/11/23
+
+- updated to @applitools/types@1.0.21 (from 1.0.20)
+
+## 1.3.4 - 2021/11/18
+
+- fix capabilities parsing for native apps
+
 ## 1.3.3 - 2021/11/14
 
 - do not throw if `getCookies` method is missed in spec driver

package/dist/capabilities.js

@@ -4,7 +4,9 @@ exports.parseCapabilities = void 0;
 function parseCapabilities(capabilities) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     const info = {
-        browserName: ((_a = capabilities.browserName) !== null && _a !== void 0 ? _a : (_b = capabilities.desired) === null || _b === void 0 ? void 0 : _b.browserName) || undefined,
+        browserName: !capabilities.app && !capabilities.bundleId
+            ? ((_a = capabilities.browserName) !== null && _a !== void 0 ? _a : (_b = capabilities.desired) === null || _b === void 0 ? void 0 : _b.browserName) || undefined
+            : undefined,
         browserVersion: ((_c = capabilities.browserVersion) !== null && _c !== void 0 ? _c : capabilities.version) || undefined,
         platformName: ((_e = (_d = capabilities.platformName) !== null && _d !== void 0 ? _d : capabilities.platform) !== null && _e !== void 0 ? _e : (_f = capabilities.desired) === null || _f === void 0 ? void 0 : _f.platformName) || undefined,
         platformVersion: capabilities.platformVersion || undefined,

package/dist/debug/check-spec-driver.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSpecDriver = void 0;
+const strict_1 = __importDefault(require("assert/strict"));
+const snippets = require('@applitools/snippets');
+async function checkSpecDriver(options) {
+    const { spec, driver } = options;
+    const context = extractContext(driver);
+    const tests = {
+        'execute script with echo snippet': async () => {
+            const arg = [1, '23', false, { a: 4, b: [5] }, null];
+            const result = await spec.executeScript(context, 'return arguments[0]', arg);
+            strict_1.default.deepEqual(result, arg, 'script returns an array of json data');
+        },
+        'execute script with functional script': async () => {
+            const arg = { a: 2, b: 1, c: 7 };
+            function script(arg) {
+                return arg;
+            }
+            const result = await spec.executeScript(context, script, arg);
+            strict_1.default.deepEqual(result, arg, 'script returns an array of json data from functional script');
+        },
+        'execute script with return value of dom element': async () => {
+            const element = await spec.executeScript(context, 'return document.documentElement');
+            const isHtmlElement = await spec.executeScript(context, 'return arguments[0] === document.documentElement', element);
+            strict_1.default.ok(isHtmlElement, 'script returns an element and could be executed with an element');
+        },
+        'execute script with nested element references': async () => {
+            const elements = await spec.executeScript(context, 'return [{html: document.documentElement, body: document.body}]');
+            const isElements = await spec.executeScript(context, 'return arguments[0][0].html === document.documentElement && arguments[0][0].html === document.documentElement', elements);
+            strict_1.default.ok(isElements, 'script returns elements inside nested structure and could be executed with a nested structure of elements');
+        },
+        'find element with string selector': async () => {
+            const selector = transformSelector('html>body>h1');
+            const element = await spec.findElement(context, selector);
+            const isWantedElement = await spec.executeScript(context, `return arguments[0] === document.querySelector("${selector}")`, element);
+            strict_1.default.ok(isWantedElement, `returns element by string selector - "${selector}"`);
+        },
+        'find element with spec selector': async () => {
+            const cssSelector = transformSelector({ type: 'css', selector: 'html>body>h1' });
+            const xpathSelector = transformSelector({ type: 'xpath', selector: '//html/body/h1' });
+            const verificationScript = `return arguments[0] === document.querySelector('html>body>h1')`;
+            const cssElement = await spec.findElement(context, cssSelector);
+            const isCssElement = await spec.executeScript(context, verificationScript, cssElement);
+            strict_1.default.ok(isCssElement, `returns element by spec selector - ${JSON.stringify(cssSelector)}`);
+            const xpathElement = await spec.findElement(context, xpathSelector);
+            const isXpathElement = await spec.executeScript(context, verificationScript, xpathElement);
+            strict_1.default.ok(isXpathElement, `returns element by spec selector - ${JSON.stringify(xpathSelector)}`);
+        },
+        'find element with unresolvable selector': async () => {
+            const selector = transformSelector('unresolvable_selector');
+            const element = await spec.findElement(context, selector);
+            strict_1.default.equal(element, null, `returns null by unresolvable selector - "${selector}"`);
+        },
+        'find elements with string selector': async () => {
+            const selector = transformSelector('html p');
+            const elements = await spec.findElements(context, selector);
+            const isExpectedElements = await spec.executeScript(context, `var expected = arguments[0]; return Array.prototype.every.call(document.querySelectorAll("${selector}"), function(element, index) { return element === expected[index] })`, elements);
+            strict_1.default.ok(isExpectedElements, `returns elements by string selector - "${selector}"`);
+        },
+        'find elements with spec selector': async () => {
+            const cssSelector = transformSelector({ type: 'css', selector: 'html p' });
+            const xpathSelector = transformSelector({ type: 'xpath', selector: '//html//p' });
+            const verificationScript = `var expected = arguments[0]; return Array.prototype.every.call(document.querySelectorAll('html p'), function(element, index) { return element === expected[index] })`;
+            const cssElements = await spec.findElements(context, cssSelector);
+            const isCssElements = await spec.executeScript(context, verificationScript, cssElements);
+            strict_1.default.ok(isCssElements, `returns elements by spec selector - ${JSON.stringify(cssSelector)}`);
+            const xpathElements = await spec.findElements(context, xpathSelector);
+            const isXpathElements = await spec.executeScript(context, verificationScript, xpathElements);
+            strict_1.default.ok(isXpathElements, `returns element by spec selector - ${JSON.stringify(xpathSelector)}`);
+        },
+        'find elements with unresolvable selector': async () => {
+            const selector = transformSelector('unresolvable_selector');
+            const element = await spec.findElements(context, selector);
+            strict_1.default.deepEqual(element, [], `returns empty array by unresolvable selector - "${selector}"`);
+        },
+        'child context': async () => {
+            const element = await spec.findElement(context, transformSelector('[name="frame1"]'));
+            const childContext = await spec.childContext(context, element);
+            const inFrame = await spec.executeScript(childContext, 'return window.frameElement.name === "frame1"');
+            strict_1.default.ok(inFrame, 'returns or switches to a child context');
+            strict_1.default.ok(typeof spec.mainContext === 'function', 'spec.mainContext also needs to be implemented in order to test spec.childContext');
+            await spec.mainContext(context);
+        },
+        'is equal elements': async () => {
+            if (!spec.isEqualElements)
+                return { skipped: true };
+            const htmlEl = await spec.findElement(context, transformSelector('html'));
+            const htmlEl2 = await spec.executeScript(context, 'return document.documentElement');
+            strict_1.default.ok(await spec.isEqualElements(context, htmlEl, htmlEl2), 'elements should be equal');
+            const bodyEl = await spec.executeScript(context, 'return document.body');
+            strict_1.default.ok(!(await spec.isEqualElements(context, htmlEl, bodyEl)), 'elements should not be equal');
+            strict_1.default.ok(!(await spec.isEqualElements(context, htmlEl, undefined)), 'isEqualElements should return false if one of the arguments is falsy');
+            strict_1.default.ok(!(await spec.isEqualElements(context, undefined, htmlEl)), 'isEqualElements should return false if one of the arguments is falsy');
+        },
+        'main context': async () => {
+            const mainDocument1 = await spec.findElement(context, transformSelector('html'));
+            const childContext1 = await spec.childContext(context, await spec.findElement(context, transformSelector('[name="frame1"]')));
+            const childContext2 = await spec.childContext(childContext1, await spec.findElement(childContext1, transformSelector('[name="frame1-1"]')));
+            const frameDocument = await spec.findElement(childContext2, transformSelector('html'));
+            strict_1.default.ok(!(await isEqualElements(childContext2, mainDocument1, frameDocument)));
+            const mainContext = await spec.mainContext(childContext2);
+            const mainDocument2 = await spec.findElement(mainContext, transformSelector('html'));
+            strict_1.default.ok(await isEqualElements(mainContext, mainDocument2, mainDocument1));
+        },
+        'parent context': async () => {
+            const parentContext1 = await spec.childContext(context, await spec.findElement(context, transformSelector('[name="frame1"]')));
+            const parentDocument1 = await spec.findElement(parentContext1, transformSelector('html'));
+            const frameContext = await spec.childContext(parentContext1, await spec.findElement(parentContext1, transformSelector('[name="frame1-1"]')));
+            const frameDocument = await spec.findElement(frameContext, transformSelector('html'));
+            strict_1.default.ok(!(await isEqualElements(frameContext, parentDocument1, frameDocument)));
+            const parentContext2 = await spec.parentContext(frameContext);
+            const parentDocument2 = await spec.findElement(parentContext2, transformSelector('html'));
+            strict_1.default.ok(await isEqualElements(parentContext2, parentDocument2, parentDocument1));
+            await spec.mainContext(context);
+        },
+        'get title': async () => {
+            const title = await spec.getTitle(driver);
+            strict_1.default.equal(title, 'Cross SDK test', 'returns title of the current page');
+        },
+        'get url': async () => {
+            const url = await spec.getUrl(driver);
+            strict_1.default.equal(url, 'https://applitools.github.io/demo/TestPages/FramesTestPage/', 'returns url of the current page');
+        },
+        'is driver': async () => {
+            strict_1.default.ok(await spec.isDriver(driver), 'driver should be considered a driver :)');
+            strict_1.default.ok(!(await spec.isDriver(undefined)), 'undefined should not be considered a driver');
+            strict_1.default.ok(!(await spec.isDriver(3)), 'number should not be considered a driver');
+            strict_1.default.ok(!(await spec.isDriver('str')), 'string should not be considered a driver');
+        },
+        'is element': async () => {
+            const el = await spec.findElement(context, transformSelector('html'));
+            strict_1.default.ok(await spec.isElement(el), 'element should be considered an element :)');
+            strict_1.default.ok(!(await spec.isElement(undefined)), 'undefined should not be considered an element');
+            strict_1.default.ok(!(await spec.isElement(3)), 'number should not be considered an element');
+            strict_1.default.ok(!(await spec.isElement('str')), 'str should not be considered an element');
+        },
+        // 'is selector': async () => {}, // hard to test this
+        // 'set window size': async () => {}, // hard to test this
+        // 'get window size': async () => {}, // hard to test this
+    };
+    const report = [];
+    await spec.visit(driver, 'https://applitools.github.io/demo/TestPages/FramesTestPage/');
+    for (const [test, check] of Object.entries(tests)) {
+        try {
+            const result = (await check()) || { success: true };
+            report.push(Object.assign({ test }, result));
+        }
+        catch (error) {
+            report.push({ test, error: { message: error.message, expected: error.expected, actual: error.actual } });
+        }
+    }
+    return report;
+    function isEqualElements(context, element1, element2) {
+        var _a, _b;
+        return ((_b = (_a = spec.isEqualElements) === null || _a === void 0 ? void 0 : _a.call(spec, context, element1, element2)) !== null && _b !== void 0 ? _b : spec.executeScript(context, snippets.isEqualElements, [element1, element2]).catch(() => false));
+    }
+    function extractContext(driver) {
+        var _a, _b;
+        return (_b = (_a = spec.extractContext) === null || _a === void 0 ? void 0 : _a.call(spec, driver)) !== null && _b !== void 0 ? _b : driver;
+    }
+    function transformSelector(selector) {
+        var _a, _b;
+        return (_b = (_a = spec.transformSelector) === null || _a === void 0 ? void 0 : _a.call(spec, selector)) !== null && _b !== void 0 ? _b : selector;
+    }
+}
+exports.checkSpecDriver = checkSpecDriver;

package/dist/debug/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./check-spec-driver"), exports);

package/dist/driver.js

@@ -22,6 +22,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Driver = void 0;
 const utils = __importStar(require("@applitools/utils"));
 const context_1 = require("./context");
+const helper_ios_1 = require("./helper-ios");
+const helper_android_1 = require("./helper-android");
 const utils_1 = require("./utils");
 const user_agent_1 = require("./user-agent");
 const capabilities_1 = require("./capabilities");
@@ -59,6 +61,9 @@ class Driver {
     get mainContext() {
         return this._mainContext;
     }
+    get helper() {
+        return this._helper;
+    }
     get features() {
         var _a;
         return (_a = this._driverInfo) === null || _a === void 0 ? void 0 : _a.features;
@@ -140,7 +145,7 @@ class Driver {
                 const userAgentInfo = user_agent_1.parseUserAgent(this._driverInfo.userAgent);
                 this._driverInfo.browserName = (_g = userAgentInfo.browserName) !== null && _g !== void 0 ? _g : this._driverInfo.browserName;
                 this._driverInfo.browserVersion = (_h = userAgentInfo.browserVersion) !== null && _h !== void 0 ? _h : this._driverInfo.browserVersion;
-                if (!this._driverInfo.isMobile) {
+                if (this._driverInfo.isMobile) {
                     (_j = (_u = this._driverInfo).platformName) !== null && _j !== void 0 ? _j : (_u.platformName = userAgentInfo.platformName);
                     (_k = (_v = this._driverInfo).platformVersion) !== null && _k !== void 0 ? _k : (_v.platformVersion = userAgentInfo.platformVersion);
                 }
@@ -153,24 +158,48 @@ class Driver {
             (_p = (_x = this._driverInfo.features).allCookies) !== null && _p !== void 0 ? _p : (_x.allCookies = /chrome/i.test(this._driverInfo.browserName) && !this._driverInfo.isMobile);
         }
         else {
-            if (this.isNative) {
-                const barsHeight = await ((_r = (_q = this._spec).getBarsHeight) === null || _r === void 0 ? void 0 : _r.call(_q, this.target).catch(() => undefined));
-                if (barsHeight) {
-                    this._driverInfo.statusBarHeight = Math.max(barsHeight.statusBarHeight, driverInfo.statusBarHeight);
-                    this._driverInfo.navigationBarHeight = Math.max(barsHeight.navigationBarHeight, driverInfo.navigationBarHeight);
-                }
-                if (this.isAndroid) {
-                    this._driverInfo.statusBarHeight /= this.pixelRatio;
-                    this._driverInfo.navigationBarHeight /= this.pixelRatio;
+            const barsHeight = await ((_r = (_q = this._spec).getBarsHeight) === null || _r === void 0 ? void 0 : _r.call(_q, this.target).catch(() => undefined));
+            const displaySize = await this.getDisplaySize();
+            // calculate status and navigation bars sizes
+            if (barsHeight) {
+                // when status bar is overlapping content on android it returns status bar height equal to viewport height
+                if (this.isAndroid && barsHeight.statusBarHeight / this.pixelRatio < displaySize.height) {
+                    this._driverInfo.statusBarHeight = Math.max(this._driverInfo.statusBarHeight, barsHeight.statusBarHeight);
                 }
+                this._driverInfo.navigationBarHeight = Math.max(this._driverInfo.navigationBarHeight, barsHeight.navigationBarHeight);
+            }
+            if (this.isAndroid) {
+                this._driverInfo.statusBarHeight /= this.pixelRatio;
+                this._driverInfo.navigationBarHeight /= this.pixelRatio;
             }
+            // calculate viewport size
             if (!this._driverInfo.viewportSize) {
-                const displaySize = await this.getDisplaySize();
                 this._driverInfo.viewportSize = {
                     width: displaySize.width,
                     height: displaySize.height - this._driverInfo.statusBarHeight,
                 };
             }
+            // calculate safe area
+            if (this.isIOS && !this._driverInfo.safeArea) {
+                this._driverInfo.safeArea = Object.assign({ x: 0, y: 0 }, displaySize);
+                const topElement = await this.element({ type: 'class name', selector: 'XCUIElementTypeNavigationBar' });
+                if (topElement) {
+                    const topRegion = await this._spec.getElementRegion(this.target, topElement.target);
+                    const topOffset = topRegion.y + topRegion.height;
+                    this._driverInfo.safeArea.y = topOffset;
+                    this._driverInfo.safeArea.height -= topOffset;
+                }
+                const bottomElement = await this.element({ type: 'class name', selector: 'XCUIElementTypeTabBar' });
+                if (bottomElement) {
+                    const bottomRegion = await this._spec.getElementRegion(this.target, bottomElement.target);
+                    const bottomOffset = bottomRegion.height;
+                    this._driverInfo.safeArea.height -= bottomOffset;
+                }
+            }
+            // init helper lib
+            this._helper = this.isIOS
+                ? await helper_ios_1.HelperIOS.make({ spec: this._spec, driver: this, logger: this._logger })
+                : await helper_android_1.HelperAndroid.make({ spec: this._spec, driver: this, logger: this._logger });
         }
         this._logger.log('Combined driver info', this._driverInfo);
         return this;
@@ -339,7 +368,13 @@ class Driver {
         if (this.isWeb || !utils.types.has(this._driverInfo, ['viewportSize', 'statusBarHeight']))
             return region;
         const scaledRegion = this.isAndroid ? utils.geometry.scale(region, 1 / this.pixelRatio) : region;
-        return utils.geometry.offsetNegative(scaledRegion, { x: 0, y: this.statusBarHeight });
+        const safeRegion = this.isIOS ? utils.geometry.intersect(scaledRegion, this._driverInfo.safeArea) : scaledRegion;
+        const offsetRegion = utils.geometry.offsetNegative(safeRegion, { x: 0, y: this.statusBarHeight });
+        if (offsetRegion.y < 0) {
+            offsetRegion.height += offsetRegion.y;
+            offsetRegion.y = 0;
+        }
+        return offsetRegion;
     }
     async getRegionInViewport(context, region) {
         await context.focus();
@@ -411,9 +446,12 @@ class Driver {
             };
             this._logger.log(`Attempt #${attempt} to set viewport size by setting window size to`, requiredWindowSize);
             await this._spec.setWindowSize(this.target, requiredWindowSize);
-            await utils.general.sleep(3000);
-            currentWindowSize = requiredWindowSize;
+            const prevViewportSize = currentViewportSize;
             currentViewportSize = await this.getViewportSize();
+            if (utils.geometry.equals(currentViewportSize, prevViewportSize)) {
+                currentViewportSize = await this.getViewportSize();
+            }
+            currentWindowSize = requiredWindowSize;
             if (utils.geometry.equals(currentViewportSize, requiredViewportSize))
                 return;
             this._logger.log(`Attempt #${attempt} to set viewport size failed. Current viewport:`, currentViewportSize);

package/dist/element.js

@@ -18,6 +18,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Element = void 0;
 const utils = __importStar(require("@applitools/utils"));
@@ -112,10 +123,7 @@ class Element {
                 return this.context.execute(snippets.getElementRect, [this, true]);
             }
             else {
-                this._logger.log('Extracting region of native element with selector', this.selector);
-                const region = await this._spec.getElementRegion(this.driver.target, this.target);
-                this._logger.log('Extracted native region', region);
-                return this.driver.normalizeRegion(region);
+                return this.getRegion();
             }
         });
         this._logger.log('Extracted client region', region);
@@ -125,7 +133,7 @@ class Element {
         if (this._state.contentSize)
             return this._state.contentSize;
         const size = await this.withRefresh(async () => {
-            var _a;
+            var _a, _b, _c;
             if (this.driver.isWeb) {
                 this._logger.log('Extracting content size of web element with selector', this.selector);
                 return this.context.execute(snippets.getElementContentSize, [this]);
@@ -133,81 +141,37 @@ class Element {
             else {
                 this._logger.log('Extracting content size of native element with selector', this.selector);
                 try {
+                    const _d = 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,
+                        };
+                    })
+                        .catch(() => {
+                        return this._spec.getElementRegion(this.driver.target, this.target);
+                    }), { touchPadding } = _d, contentRegion = __rest(_d, ["touchPadding"]);
+                    this._logger.log('Extracted native content size attribute', contentRegion);
+                    const contentSize = await ((_a = this.driver.helper) === null || _a === void 0 ? void 0 : _a.getContentSize(this));
+                    this._logger.log('Extracted native content size with helper library', contentSize);
+                    this._state.contentSize = {
+                        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;
                     if (this.driver.isAndroid) {
-                        const className = await this.getAttribute('className');
-                        if ([
-                            'android.widget.ListView',
-                            'android.widget.GridView',
-                            'android.support.v7.widget.RecyclerView',
-                            // 'androidx.recyclerview.widget.RecyclerView',
-                            'androidx.viewpager2.widget.ViewPager2',
-                        ].includes(className)) {
-                            this._logger.log('Trying to extract content size using android helper library');
-                            const helperElement = await this.driver.element({
-                                type: '-android uiautomator',
-                                selector: 'new UiSelector().description("EyesAppiumHelper")',
-                            });
-                            if (helperElement) {
-                                const elementRegion = await this._spec.getElementRegion(this.driver.target, this.target);
-                                await helperElement.click();
-                                const info = await this._spec.getElementText(this.driver.target, helperElement.target);
-                                this._state.contentSize = utils.geometry.scale({ width: elementRegion.width, height: Number(info) }, 1 / this.driver.pixelRatio);
-                            }
-                            else {
-                                this._logger.log('Helper library for android was not detected');
-                            }
-                        }
-                    }
-                    else if (this.driver.isIOS) {
-                        const type = await this.getAttribute('type');
-                        if (type === 'XCUIElementTypeScrollView') {
-                            const elementRegion = await this._spec.getElementRegion(this.driver.target, this.target);
-                            const [childElement] = await this.driver.elements({
-                                type: 'xpath',
-                                selector: '//XCUIElementTypeScrollView[1]/*', // We cannot be sure that our element is the first one
-                            });
-                            const childElementRegion = await this._spec.getElementRegion(this.driver.target, childElement.target);
-                            this._state.contentSize = {
-                                width: elementRegion.width,
-                                height: childElementRegion.y + childElementRegion.height - elementRegion.y,
-                            };
-                        }
-                        else if (type === 'XCUIElementTypeCollectionView') {
-                            this._logger.log('Trying to extract content size using ios helper library');
-                            const helperElement = await this.driver.element({
-                                type: 'name',
-                                selector: 'applitools_grab_scrollable_data_button',
-                            });
-                            if (helperElement) {
-                                const helperElementRegion = await this._spec.getElementRegion(this.driver.target, helperElement.target);
-                                await this._spec.performAction(this.driver.target, [
-                                    { action: 'tap', x: helperElementRegion.x, y: helperElementRegion.y },
-                                    { action: 'wait', ms: 1000 },
-                                    { action: 'release' },
-                                ]);
-                                const infoElement = await this.driver.element({ type: 'name', selector: 'applitools_content_size_label' });
-                                const info = await this._spec.getElementText(this.driver.target, infoElement.target);
-                                if (info) {
-                                    const [_, width, height] = info.match(/\{(\d+),\s?(\d+)\}/);
-                                    this._state.contentSize = { width: Number(width), height: Number(height) };
-                                }
-                            }
-                            else {
-                                this._logger.log('Helper library for ios was not detected');
-                            }
-                        }
+                        this._state.contentSize = utils.geometry.scale(this._state.contentSize, 1 / this.driver.pixelRatio);
                     }
-                    if (!this._state.contentSize) {
-                        const data = JSON.parse(await this.getAttribute('contentSize'));
-                        this._logger.log('Extracted native content size attribute', data);
-                        this._state.contentSize = this.driver.isIOS
-                            ? { width: data.width, height: data.scrollableOffset }
-                            : utils.geometry.scale({ width: data.width, height: data.height + data.scrollableOffset }, 1 / this.driver.pixelRatio);
-                        this._touchPadding = (_a = data.touchPadding) !== null && _a !== void 0 ? _a : this._touchPadding;
+                    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');
-                        // android has a bug when after extracting 'contentSize' attribute the element is being scrolled by undetermined number of pixels
                         const originalScrollOffset = await this.getScrollOffset();
                         this._state.scrollOffset = { x: -1, y: -1 };
                         await this.scrollTo({ x: 0, y: 0 });
@@ -260,7 +224,7 @@ class Element {
             if (this.driver.isWeb)
                 this._touchPadding = 0;
             else if (this.driver.isIOS)
-                this._touchPadding = 14;
+                this._touchPadding = 10;
             else if (this.driver.isAndroid) {
                 const { touchPadding } = JSON.parse(await this.getAttribute('contentSize'));
                 this._touchPadding = touchPadding !== null && touchPadding !== void 0 ? touchPadding : 0;
@@ -268,6 +232,19 @@ class Element {
         }
         return this._touchPadding;
     }
+    async getText() {
+        const text = await this.withRefresh(async () => {
+            if (this.driver.isWeb) {
+                return '';
+            }
+            else {
+                this._logger.log('Extracting text of native element with selector', this.selector);
+                return this._spec.getElementText(this.driver.target, this.target);
+            }
+        });
+        this._logger.log('Extracted element text', text);
+        return text;
+    }
     async getAttribute(name) {
         if (this.driver.isWeb) {
             const properties = await this.context.execute(snippets.getElementProperties, [this, [name]]);
@@ -284,7 +261,7 @@ class Element {
     }
     async scrollTo(offset) {
         return this.withRefresh(async () => {
-            offset = { x: Math.round(offset.x), y: Math.round(offset.y) };
+            offset = utils.geometry.round(offset);
             if (this.driver.isWeb) {
                 let actualOffset = await this.context.execute(snippets.scrollTo, [this, offset]);
                 // iOS has an issue when scroll offset is read immediately after it is been set it will always return the exact value that was set
@@ -297,62 +274,69 @@ class Element {
                 if (utils.geometry.equals(offset, currentScrollOffset))
                     return currentScrollOffset;
                 const contentSize = await this.getContentSize();
-                const scrollableRegion = await this._spec.getElementRegion(this.driver.target, this.target);
-                const scaledScrollableRegion = this.driver.isAndroid
-                    ? utils.geometry.scale(scrollableRegion, 1 / this.driver.pixelRatio)
+                const scrollableRegion = await this.getClientRegion();
+                const effectiveRegion = this.driver.isAndroid
+                    ? utils.geometry.scale(scrollableRegion, this.driver.pixelRatio)
                     : scrollableRegion;
                 const maxOffset = {
-                    x: Math.round(scaledScrollableRegion.width * (contentSize.width / scaledScrollableRegion.width - 1)),
-                    y: Math.round(scaledScrollableRegion.height * (contentSize.height / scaledScrollableRegion.height - 1)),
+                    x: Math.round(scrollableRegion.width * (contentSize.width / scrollableRegion.width - 1)),
+                    y: Math.round(scrollableRegion.height * (contentSize.height / scrollableRegion.height - 1)),
                 };
-                let requiredOffset;
-                let remainingOffset;
-                if (offset.x === 0 && offset.y === 0) {
-                    requiredOffset = offset;
-                    // if it has to be scrolled to the very beginning, then scroll maximum amount of pixels and a bit extra to be sure
-                    remainingOffset = { x: -(maxOffset.x + 0), y: -(maxOffset.y + 0) };
-                }
-                else {
-                    requiredOffset = { x: Math.min(offset.x, maxOffset.x), y: Math.min(offset.y, maxOffset.y) };
-                    remainingOffset = utils.geometry.offsetNegative(requiredOffset, currentScrollOffset);
-                    // if it has to be scrolled to the very end, then do a bit of extra scrolling to be sure
-                    // if (requiredOffset.x === maxOffset.x) remainingOffset.x += 100
-                    // if (requiredOffset.y === maxOffset.y) remainingOffset.y += 100
-                }
-                // if (requiredOffset.x === 0) remainingOffset.x -= 100
-                // if (requiredOffset.y === 0) remainingOffset.y -= 100
-                // if (requiredOffset.x === maxOffset.x) remainingOffset.x += 100
-                // if (requiredOffset.y === maxOffset.y) remainingOffset.y += 100
+                const requiredOffset = { x: Math.min(offset.x, maxOffset.x), y: Math.min(offset.y, maxOffset.y) };
+                let remainingOffset = offset.x === 0 && offset.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);
                 }
-                const actions = [];
-                const xPadding = Math.floor(scrollableRegion.width * 0.1);
-                const yTrack = Math.floor(scrollableRegion.y + scrollableRegion.height / 2); // center
-                const xLeft = scrollableRegion.y + xPadding;
+                const touchPadding = await this.getTouchPadding();
+                const xPadding = Math.max(Math.floor(effectiveRegion.width * 0.1), touchPadding);
+                const yTrack = Math.floor(effectiveRegion.y + effectiveRegion.height / 2); // center
+                const xLeft = effectiveRegion.y + xPadding;
                 const xDirection = remainingOffset.y > 0 ? 'right' : 'left';
+                const xGap = xDirection === 'right' ? -touchPadding : touchPadding;
                 let xRemaining = Math.abs(remainingOffset.x);
                 while (xRemaining > 0) {
-                    const xRight = scrollableRegion.x + Math.min(xRemaining + xPadding, scrollableRegion.width - xPadding);
+                    const xRight = effectiveRegion.x + Math.min(xRemaining + xPadding, effectiveRegion.width - xPadding);
                     const [xStart, xEnd] = xDirection === 'right' ? [xRight, xLeft] : [xLeft, xRight];
-                    actions.push({ action: 'press', x: xStart, y: yTrack }, { action: 'wait', ms: 1500 }, { action: 'moveTo', x: xEnd, y: yTrack }, { action: 'release' });
+                    await this._spec.performAction(this.driver.target, [
+                        { 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' },
+                    ]);
                     xRemaining -= xRight - xLeft;
                 }
-                const yPadding = Math.floor(scrollableRegion.height * 0.1);
-                const xTrack = Math.floor(scrollableRegion.x + 5); // a little bit off left border
-                const yTop = scrollableRegion.y + yPadding;
+                const yPadding = Math.max(Math.floor(effectiveRegion.height * 0.1), 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';
-                let yRemaining = Math.abs(remainingOffset.y) + (await this.getTouchPadding()) * 2;
+                const yGap = yDirection === 'down' ? -touchPadding : touchPadding;
+                let yRemaining = Math.abs(remainingOffset.y);
                 while (yRemaining > 0) {
-                    const yBottom = scrollableRegion.y + Math.min(yRemaining + yPadding, scrollableRegion.height - yPadding);
+                    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: 1500 }, { action: 'moveTo', x: xTrack, y: yEnd }, { action: 'wait', ms: 1500 }, { action: 'release' });
+                    await this._spec.performAction(this.driver.target, [
+                        { 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' },
+                    ]);
                     yRemaining -= yBottom - yTop;
                 }
-                if (actions.length > 0) {
-                    await this._spec.performAction(this.driver.target, actions);
-                }
-                this._state.scrollOffset = requiredOffset;
+                const actualScrollableRegion = await this.getClientRegion();
+                this._state.scrollOffset = utils.geometry.offsetNegative(requiredOffset, {
+                    x: scrollableRegion.x - actualScrollableRegion.x,
+                    y: scrollableRegion.y - actualScrollableRegion.y,
+                });
                 return this._state.scrollOffset;
             }
         });
@@ -394,6 +378,9 @@ class Element {
     async click() {
         await this._spec.click(this.context.target, this.target);
     }
+    async type(value) {
+        await this._spec.type(this.context.target, this.target, value);
+    }
     async preserveState() {
         if (this.driver.isNative)
             return;

package/dist/helper-android.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelperAndroid = void 0;
+class HelperAndroid {
+    constructor(options) {
+        this._spec = options.spec;
+        this._element = options.element;
+        this._legacy = options.legacy;
+        this._logger = options.logger;
+    }
+    static async make(options) {
+        const { spec, driver, logger } = options;
+        let legacy = false;
+        let element = await driver.element({
+            type: '-android uiautomator',
+            selector: 'new UiSelector().description("EyesAppiumHelperEDT")',
+        });
+        if (!element) {
+            legacy = true;
+            element = await driver.element({
+                type: '-android uiautomator',
+                selector: 'new UiSelector().description("EyesAppiumHelper")',
+            });
+        }
+        return element ? new HelperAndroid({ spec, element, legacy, logger }) : null;
+    }
+    async _getElementId(element) {
+        const resourceId = await element.getAttribute('resource-id');
+        if (!resourceId)
+            return null;
+        return resourceId.split('/')[1];
+    }
+    async getContentSize(element) {
+        let contentHeight;
+        if (this._legacy) {
+            await this._element.click();
+            contentHeight = await this._element.getText();
+        }
+        else {
+            const elementId = this._getElementId(element);
+            if (!elementId)
+                return null;
+            await this._element.type(`offset;${elementId};0;0;0`);
+            await this._element.click();
+            contentHeight = 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) };
+    }
+    async getRegion(element) {
+        if (this._legacy)
+            return null;
+        const elementId = await this._getElementId(element);
+        if (!elementId)
+            return null;
+        await this._element.type(`getRect;${elementId};0;0`);
+        await this._element.click();
+        const regionString = await this._element.getText();
+        await this._element.type('');
+        const [, x, y, height, width] = regionString.match(/\[(-?\d+(?:\.\d+)?);(-?\d+(?:\.\d+)?);(-?\d+(?:\.\d+)?);(-?\d+(?:\.\d+)?)\]/);
+        const region = { x: Number(x), y: Number(y), width: Number(width), height: Number(height) };
+        if (Number.isNaN(region.x + region.y + region.width + region.height))
+            return null;
+        return region;
+    }
+}
+exports.HelperAndroid = HelperAndroid;

package/dist/helper-ios.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelperIOS = void 0;
+class HelperIOS {
+    constructor(options) {
+        this._driver = options.driver;
+        this._element = options.element;
+        this._spec = options.spec;
+        this._logger = options.logger;
+    }
+    static async make(options) {
+        const { spec, driver, logger } = options;
+        const element = await driver.element({ type: 'name', selector: 'applitools_grab_scrollable_data_button' });
+        return element ? new HelperIOS({ driver, element, spec, logger }) : null;
+    }
+    async getContentSize(_element) {
+        await this._element.click();
+        const sizeLabel = await this._driver.element({ type: 'name', selector: 'applitools_content_size_label' });
+        const sizeString = await (sizeLabel === null || sizeLabel === void 0 ? void 0 : sizeLabel.getText());
+        if (!sizeString)
+            return null;
+        const [, width, height] = sizeString.match(/\{(-?\d+(?:\.\d+)?),\s?(-?\d+(?:\.\d+)?)\}/);
+        const contentSize = { width: Number(width), height: Number(height) };
+        if (Number.isNaN(contentSize.width + contentSize.height))
+            return null;
+        const paddingLabel = await this._driver.element({ type: 'name', selector: 'applitools_content_offset_label' });
+        const paddingString = await (paddingLabel === null || paddingLabel === void 0 ? void 0 : paddingLabel.getText());
+        if (!paddingString)
+            return contentSize;
+        const [, x, y] = paddingString.match(/\{(-?\d+(?:\.\d+)?),\s?(-?\d+(?:\.\d+)?)\}/);
+        const contentOffset = { x: Number(x), y: Number(y) };
+        if (!Number.isNaN(contentOffset.x))
+            contentSize.width -= contentOffset.x;
+        if (!Number.isNaN(contentOffset.y))
+            contentSize.height -= contentOffset.y;
+        return contentSize;
+    }
+}
+exports.HelperIOS = HelperIOS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/driver",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "description": "Applitools universal framework wrapper",
   "keywords": [
     "applitools",
@@ -34,12 +34,19 @@
     "./fake": {
       "default": "./dist/fake/index.js",
       "types": "./types/fake/index.d.ts"
+    },
+    "./debug": {
+      "default": "./dist/debug/index.js",
+      "types": "./types/debug/index.d.ts"
     }
   },
   "typesVersions": {
     "*": {
       "fake": [
         "./types/fake/index.d.ts"
+      ],
+      "debug": [
+        "./types/debug/index.d.ts"
       ]
     }
   },
@@ -62,8 +69,8 @@
     }
   },
   "dependencies": {
-    "@applitools/snippets": "2.1.7",
-    "@applitools/types": "1.0.20",
+    "@applitools/snippets": "2.1.8",
+    "@applitools/types": "1.0.22",
     "@applitools/utils": "1.2.4"
   },
   "devDependencies": {

package/types/debug/check-spec-driver.d.ts

@@ -0,0 +1,20 @@
+import type { SpecDriver } from '@applitools/types';
+export declare function checkSpecDriver<TDriver, TContext, TElement, TSelector>(options: {
+    spec: SpecDriver<TDriver, TContext, TElement, TSelector>;
+    driver: TDriver;
+}): Promise<({
+    skipped: boolean;
+    test: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    test: string;
+    error?: undefined;
+} | {
+    test: string;
+    error: {
+        message: any;
+        expected: any;
+        actual: any;
+    };
+})[]>;

package/types/debug/index.d.ts

@@ -0,0 +1 @@
+export * from './check-spec-driver';

package/types/driver.d.ts

@@ -2,6 +2,8 @@
 import type * as types from '@applitools/types';
 import { Context, ContextReference } from './context';
 import { Element } from './element';
+import { HelperIOS } from './helper-ios';
+import { HelperAndroid } from './helper-android';
 export declare class Driver<TDriver, TContext, TElement, TSelector> {
     private _target;
     private _mainContext;
@@ -9,6 +11,7 @@ export declare class Driver<TDriver, TContext, TElement, TSelector> {
     private _driverInfo;
     private _logger;
     private _utils;
+    private _helper?;
     protected readonly _spec: types.SpecDriver<TDriver, TContext, TElement, TSelector>;
     constructor(options: {
         spec: types.SpecDriver<TDriver, TContext, TElement, TSelector>;
@@ -18,6 +21,7 @@ export declare class Driver<TDriver, TContext, TElement, TSelector> {
     get target(): TDriver;
     get currentContext(): Context<TDriver, TContext, TElement, TSelector>;
     get mainContext(): Context<TDriver, TContext, TElement, TSelector>;
+    get helper(): HelperAndroid<TDriver, TContext, TElement, TSelector> | HelperIOS<TDriver, TContext, TElement, TSelector>;
     get features(): {
         shadowSelector?: boolean;
         allCookies?: boolean;

package/types/element.d.ts

@@ -37,6 +37,7 @@ export declare class Element<TDriver, TContext, TElement, TSelector> {
     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>;
@@ -45,6 +46,7 @@ export declare class Element<TDriver, TContext, TElement, TSelector> {
     getTranslateOffset(): Promise<types.Location>;
     getInnerOffset(): Promise<types.Location>;
     click(): Promise<void>;
+    type(value: string): Promise<void>;
     preserveState(): Promise<ElementState>;
     restoreState(state?: ElementState): Promise<void>;
     hideScrollbars(): Promise<void>;

package/types/fake/mock-driver.d.ts

@@ -20,7 +20,7 @@ export declare class MockDriver {
         browserVersion: any;
     };
     executeScript(script: any, args?: any[]): Promise<any>;
-    findElement(selector: any, rootElement: any): Promise<any>;
+    findElement(selector: any, rootElement?: any): Promise<any>;
     findElements(selector: any, rootElement: any): Promise<any>;
     switchToFrame(reference: any): Promise<this>;
     switchToParentFrame(): Promise<this>;

package/types/helper-android.d.ts

@@ -0,0 +1,23 @@
+import type * as types from '@applitools/types';
+import type { Driver } from './driver';
+import type { Element } from './element';
+export declare class HelperAndroid<TDriver, TContext, TElement, TSelector> {
+    static make<TDriver, TContext, TElement, TSelector>(options: {
+        spec: types.SpecDriver<TDriver, TContext, TElement, TSelector>;
+        driver: Driver<TDriver, TContext, TElement, TSelector>;
+        logger: any;
+    }): Promise<HelperAndroid<TDriver, TContext, TElement, TSelector> | null>;
+    private readonly _spec;
+    private readonly _element;
+    private readonly _legacy;
+    private _logger;
+    constructor(options: {
+        spec: types.SpecDriver<TDriver, TContext, TElement, TSelector>;
+        element: Element<TDriver, TContext, TElement, TSelector>;
+        legacy: boolean;
+        logger?: any;
+    });
+    _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>;
+}

package/types/helper-ios.d.ts

@@ -0,0 +1,21 @@
+import type * as types from '@applitools/types';
+import type { Driver } from './driver';
+import type { Element } from './element';
+export declare class HelperIOS<TDriver, TContext, TElement, TSelector> {
+    static make<TDriver, TContext, TElement, TSelector>(options: {
+        spec: types.SpecDriver<TDriver, TContext, TElement, TSelector>;
+        driver: Driver<TDriver, TContext, TElement, TSelector>;
+        logger: any;
+    }): Promise<HelperIOS<TDriver, TContext, TElement, TSelector> | null>;
+    private readonly _driver;
+    private readonly _element;
+    private readonly _spec;
+    private _logger;
+    constructor(options: {
+        driver: Driver<TDriver, TContext, TElement, TSelector>;
+        element: Element<TDriver, TContext, TElement, TSelector>;
+        spec: types.SpecDriver<TDriver, TContext, TElement, TSelector>;
+        logger?: any;
+    });
+    getContentSize(_element: Element<TDriver, TContext, TElement, TSelector>): Promise<types.Size>;
+}