@applitools/driver 1.9.1 → 1.9.4

package/dist/driver.js

@@ -175,13 +175,14 @@ class Driver {
             // 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();
             if (this.isAndroid) {
                 // bar sizes could be extracted only on android
                 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 ((await this.getOrientation()) === 'landscape')
+                    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._driverInfo.displaySize.height) {
@@ -201,10 +202,18 @@ class Driver {
             // calculate viewport size
             if (!this._driverInfo.viewportSize) {
                 if (this.navigationBarHeight > 1) {
-                    this._driverInfo.viewportSize = {
-                        width: this._driverInfo.displaySize.width,
-                        height: this._driverInfo.displaySize.height - this.statusBarHeight - this.navigationBarHeight,
-                    };
+                    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 = {
@@ -454,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');
@@ -520,11 +523,14 @@ class Driver {
         var _a;
         if (this.isWeb && !this.isMobile)
             return;
-        if ((_a = this._driverInfo) === null || _a === void 0 ? void 0 : _a.viewportSize) {
+        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;
         }
-        const size = await this._spec.getWindowSize(this.target);
+        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

@@ -278,18 +278,24 @@ class Element {
         });
     }
     async getTouchPadding() {
+        var _a, _b;
         if (this._state.touchPadding == null) {
             if (this.driver.isWeb)
                 this._state.touchPadding = 0;
             else if (this.driver.isIOS)
                 this._state.touchPadding = 10;
             else if (this.driver.isAndroid) {
-                const touchPadding = await this.getAttribute('contentSize')
-                    .then(data => JSON.parse(data).touchPadding)
-                    .catch(err => {
-                    this._logger.warn(`Unable to get the attribute 'contentSize' when looking up 'touchPadding' due to the following error: '${err.message}'`);
-                });
-                this._state.touchPadding = touchPadding !== null && touchPadding !== void 0 ? touchPadding : 20;
+                if (((_a = this.driver.helper) === null || _a === void 0 ? void 0 : _a.name) === 'android') {
+                    this._state.touchPadding = await ((_b = this.driver.helper) === null || _b === void 0 ? void 0 : _b.getTouchPadding());
+                }
+                else {
+                    const touchPadding = await this.getAttribute('contentSize')
+                        .then(data => JSON.parse(data).touchPadding)
+                        .catch(err => {
+                        this._logger.warn(`Unable to get the attribute 'contentSize' when looking up 'touchPadding' due to the following error: '${err.message}'`);
+                    });
+                    this._state.touchPadding = touchPadding !== null && touchPadding !== void 0 ? touchPadding : 20;
+                }
                 this._logger.log('Touch padding set:', this._state.touchPadding);
             }
         }
@@ -311,8 +317,11 @@ class Element {
     async getAttribute(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])
+        if ((_a = this._state.attributes) === null || _a === void 0 ? void 0 : _a[name]) {
+            if (this._state.attributes[name] instanceof Error)
+                throw this._state.attributes[name];
             return this._state.attributes[name];
+        }
         const value = await this.withRefresh(async () => {
             var _a;
             var _b;
@@ -322,17 +331,24 @@ class Element {
             }
             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);
+                try {
+                    this._state.attributes[name] = await this._spec.getElementAttribute(this.driver.target, this.target, name);
+                    return this._state.attributes[name];
+                }
+                catch (err) {
+                    this._state.attributes[name] = err;
+                    throw err;
+                }
+                finally {
+                    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);
@@ -345,6 +361,7 @@ class Element {
     }
     async scrollTo(offset, options) {
         return this.withRefresh(async () => {
+            var _a;
             offset = utils.geometry.round({ x: Math.max(offset.x, 0), y: Math.max(offset.y, 0) });
             if (this.driver.isWeb) {
                 let actualOffset = await this.context.execute(snippets.scrollTo, [this, offset]);
@@ -364,17 +381,23 @@ class Element {
                     y: Math.round(scrollableRegion.height * (contentSize.height / scrollableRegion.height - 1)),
                 };
                 const requiredOffset = { x: Math.min(offset.x, maxOffset.x), y: Math.min(offset.y, maxOffset.y) };
+                if (((_a = this.driver.helper) === null || _a === void 0 ? void 0 : _a.name) === 'android' && utils.geometry.equals(requiredOffset, { x: 0, y: 0 })) {
+                    await this.driver.helper.scrollToTop(this);
+                    this._state.scrollOffset = requiredOffset;
+                    return this._state.scrollOffset;
+                }
                 let effectiveRegion = scrollableRegion;
                 let remainingOffset = utils.geometry.equals(requiredOffset, { x: 0, y: 0 })
                     ? { x: -maxOffset.x, y: -maxOffset.y } // if it has to be scrolled to the very beginning, then scroll maximum amount of pixels
                     : utils.geometry.offsetNegative(requiredOffset, currentScrollOffset);
                 if (this.driver.isAndroid) {
-                    remainingOffset = utils.geometry.scale(remainingOffset, this.driver.pixelRatio);
-                    effectiveRegion = utils.geometry.scale(scrollableRegion, this.driver.pixelRatio);
+                    remainingOffset = utils.geometry.round(utils.geometry.scale(remainingOffset, this.driver.pixelRatio));
+                    effectiveRegion = utils.geometry.round(utils.geometry.scale(effectiveRegion, this.driver.pixelRatio));
                 }
                 const actions = [];
-                const touchPadding = await this.getTouchPadding();
                 const isPager = await this.isPager();
+                const touchPadding = await this.getTouchPadding();
+                // horizontal scrolling
                 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;
@@ -414,6 +437,7 @@ class Element {
                     }
                     xRemaining -= xRight - xLeft;
                 }
+                // vertical scrolling
                 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;
@@ -464,10 +488,10 @@ class Element {
                     await this._spec.performAction(this.driver.target, [].concat(...actions));
                 }
                 const actualScrollableRegion = await this.getClientRegion();
-                this._state.scrollOffset = utils.geometry.offsetNegative(requiredOffset, {
+                this._state.scrollOffset = utils.geometry.round(utils.geometry.offsetNegative(requiredOffset, {
                     x: scrollableRegion.x - actualScrollableRegion.x,
                     y: scrollableRegion.y - actualScrollableRegion.y,
-                });
+                }));
                 return this._state.scrollOffset;
             }
         });

package/dist/helper-android.js

@@ -7,6 +7,7 @@ class HelperAndroid {
         this._element = options.element;
         this._legacy = options.legacy;
         this._logger = options.logger;
+        this.name = this._legacy ? 'android-legacy' : 'android';
     }
     static async make(options) {
         const { spec, driver, logger } = options;
@@ -64,5 +65,34 @@ class HelperAndroid {
             return null;
         return region;
     }
+    async scrollToTop(element) {
+        if (this._legacy)
+            return null;
+        const elementId = await this._getElementId(element);
+        if (!elementId)
+            return null;
+        await this._element.type(`moveToTop;${elementId};0;0`);
+        await this._element.click();
+        await this._element.type('');
+    }
+    async scrollBy(element, offset) {
+        if (this._legacy)
+            return null;
+        const elementId = await this._getElementId(element);
+        if (!elementId)
+            return null;
+        await this._element.type(`scroll;${elementId};${offset.y};0;0`);
+        await this._element.click();
+        await this._element.type('');
+    }
+    async getTouchPadding() {
+        if (this._legacy)
+            return null;
+        await this._element.type(`getTouchPadding;0;0;0;0`);
+        await this._element.click();
+        const touchPaddingString = await this._element.getText();
+        await this._element.type('');
+        return Number(touchPaddingString);
+    }
 }
 exports.HelperAndroid = HelperAndroid;

package/dist/helper-ios.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/driver",
-  "version": "1.9.1",
+  "version": "1.9.4",
   "description": "Applitools universal framework wrapper",
   "keywords": [
     "applitools",
@@ -24,6 +24,9 @@
     "name": "Applitools Team",
     "email": "team@applitools.com"
   },
+  "aliases": [
+    "driver"
+  ],
   "exports": {
     ".": {
       "types": "./types/index.d.ts",
@@ -73,13 +76,13 @@
     }
   },
   "dependencies": {
-    "@applitools/logger": "1.1.10",
-    "@applitools/snippets": "2.2.3",
-    "@applitools/types": "1.4.7",
-    "@applitools/utils": "1.3.6"
+    "@applitools/logger": "1.1.12",
+    "@applitools/snippets": "2.4.2",
+    "@applitools/types": "1.5.3",
+    "@applitools/utils": "1.3.8"
   },
   "devDependencies": {
-    "@applitools/bongo": "^2.1.4",
+    "@applitools/bongo": "^2.1.5",
     "@types/mocha": "^9.1.1",
     "@types/node": "^17.0.31",
     "@typescript-eslint/eslint-plugin": "^5.22.0",

package/types/element.d.ts

@@ -5,7 +5,7 @@ export declare type ElementState<TElement> = {
     contentSize?: types.Size;
     scrollOffset?: types.Location;
     transforms?: any;
-    attributes?: Record<string, string>;
+    attributes?: Record<string, string | Error>;
     touchPadding?: number;
     containedElements?: Map<TElement, boolean>;
 };

package/types/helper-android.d.ts

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

package/types/helper-ios.d.ts

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