@applitools/driver 1.4.17-beta.2 → 1.5.2

package/dist/element.js

@@ -1,483 +1,483 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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"));
-const specUtils = __importStar(require("./spec-utils"));
-const snippets = require('@applitools/snippets');
-class Element {
-    constructor(options) {
-        var _a, _b, _c, _d, _e, _f;
-        this._state = {};
-        if (options.element instanceof Element)
-            return options.element;
-        this._spec = options.spec;
-        if (options.context)
-            this._context = options.context;
-        if (options.logger)
-            this._logger = options.logger;
-        if (this._spec.isElement(options.element)) {
-            this._target = (_c = (_b = (_a = this._spec).transformElement) === null || _b === void 0 ? void 0 : _b.call(_a, options.element)) !== null && _c !== void 0 ? _c : options.element;
-            // Some frameworks contains information about the selector inside an element
-            this._selector = (_d = options.selector) !== null && _d !== void 0 ? _d : (_f = (_e = this._spec).extractSelector) === null || _f === void 0 ? void 0 : _f.call(_e, options.element);
-            this._index = options.index;
-        }
-        else if (specUtils.isSelector(this._spec, options.selector)) {
-            this._selector = options.selector;
-        }
-        else {
-            throw new TypeError('Element constructor called with argument of unknown type!');
-        }
-    }
-    get target() {
-        return this._target;
-    }
-    get selector() {
-        return this._selector;
-    }
-    get context() {
-        return this._context;
-    }
-    get driver() {
-        return this.context.driver;
-    }
-    get isRef() {
-        return this.context.isRef || !this.target;
-    }
-    async equals(element) {
-        if (this.isRef)
-            return false;
-        element = element instanceof Element ? element.target : element;
-        if (this.driver.isWeb) {
-            return this._spec
-                .executeScript(this.context.target, snippets.isEqualElements, [this.target, element])
-                .catch(() => false);
-        }
-        else {
-            return this._spec.isEqualElements(this.context.target, this.target, element);
-        }
-    }
-    async init(context) {
-        this._context = context;
-        this._logger = context._logger;
-        if (this._target)
-            return this;
-        if (this._selector) {
-            const element = await this._context.element(this._selector);
-            if (!element)
-                throw new Error(`Cannot find element with selector ${JSON.stringify(this._selector)}`);
-            this._target = element.target;
-            return this;
-        }
-    }
-    async getRegion() {
-        const region = await this.withRefresh(async () => {
-            if (this.driver.isWeb) {
-                this._logger.log('Extracting region of web element with selector', this.selector);
-                return this.context.execute(snippets.getElementRect, [this, false]);
-            }
-            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);
-            }
-        });
-        this._logger.log('Extracted region', region);
-        return region;
-    }
-    async getClientRegion() {
-        const region = await this.withRefresh(async () => {
-            if (this.driver.isWeb) {
-                this._logger.log('Extracting region of web element with selector', this.selector);
-                return this.context.execute(snippets.getElementRect, [this, true]);
-            }
-            else {
-                return this.getRegion();
-            }
-        });
-        this._logger.log('Extracted client region', region);
-        return region;
-    }
-    async getContentSize() {
-        if (this._state.contentSize)
-            return this._state.contentSize;
-        const size = await this.withRefresh(async () => {
-            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]);
-            }
-            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) {
-                        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) {
-                    this._logger.warn('Failed to extract content size, extracting client size instead');
-                    this._logger.error(err);
-                    return utils.geometry.size(await this.getClientRegion());
-                }
-            }
-        });
-        this._logger.log('Extracted content size', size);
-        return size;
-    }
-    async isScrollable() {
-        this._logger.log('Check is element with selector', this.selector, 'is scrollable');
-        const isScrollable = await this.withRefresh(async () => {
-            if (this.driver.isWeb) {
-                return this.context.execute(snippets.isElementScrollable, [this]);
-            }
-            else if (this.driver.isAndroid) {
-                const data = JSON.parse(await this.getAttribute('scrollable'));
-                return Boolean(data) || false;
-            }
-            else if (this.driver.isIOS) {
-                const type = await this.getAttribute('type');
-                return ['XCUIElementTypeScrollView', 'XCUIElementTypeTable', 'XCUIElementTypeCollectionView'].includes(type);
-            }
-        });
-        this._logger.log('Element is scrollable', isScrollable);
-        return isScrollable;
-    }
-    async isRoot() {
-        // TODO replace with snippet
-        return this.withRefresh(async () => {
-            if (this.driver.isWeb) {
-                const rootElement = await this.context.element({ type: 'css', selector: 'html' });
-                return this.equals(rootElement);
-            }
-            else {
-                return false;
-            }
-        });
-    }
-    async getTouchPadding() {
-        var _a;
-        if (this._touchPadding == null) {
-            if (this.driver.isWeb)
-                this._touchPadding = 0;
-            else if (this.driver.isIOS)
-                this._touchPadding = 10;
-            else if (this.driver.isAndroid) {
-                const data = await this.getAttribute('contentSize')
-                    .then(JSON.parse)
-                    .catch(() => null);
-                this._touchPadding = (_a = data === null || data === void 0 ? void 0 : data.touchPadding) !== null && _a !== void 0 ? _a : 24;
-            }
-        }
-        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]]);
-            return properties[name];
-        }
-        else {
-            return this._spec.getElementAttribute(this.driver.target, this.target, name);
-        }
-    }
-    async setAttribute(name, value) {
-        if (this.driver.isWeb) {
-            await this.context.execute(snippets.setElementAttributes, [this, { [name]: value }]);
-        }
-    }
-    async scrollTo(offset) {
-        return this.withRefresh(async () => {
-            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
-                if (this.driver.isIOS)
-                    actualOffset = await this.getScrollOffset();
-                return actualOffset;
-            }
-            else {
-                const currentScrollOffset = await this.getScrollOffset();
-                if (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
-                    ? { 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 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 = 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' },
-                    ]);
-                    xRemaining -= xRight - xLeft;
-                }
-                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';
-                const yGap = yDirection === 'down' ? -touchPadding : touchPadding;
-                let yRemaining = Math.abs(remainingOffset.y);
-                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' },
-                    ]);
-                    yRemaining -= yBottom - yTop;
-                }
-                // ios actions should be executed one-by-one sequentially, otherwise the result isn't stable
-                if (this.driver.isIOS) {
-                    for (const action of actions) {
-                        await this._spec.performAction(this.driver.target, action);
-                    }
-                }
-                else {
-                    await this._spec.performAction(this.driver.target, [].concat(...actions));
-                }
-                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;
-            }
-        });
-    }
-    async translateTo(offset) {
-        offset = { x: Math.round(offset.x), y: Math.round(offset.y) };
-        if (this.driver.isWeb) {
-            return this.withRefresh(async () => this.context.execute(snippets.translateTo, [this, offset]));
-        }
-        else {
-            throw new Error('Cannot apply css translate scrolling on non-web element');
-        }
-    }
-    async getScrollOffset() {
-        var _a;
-        if (this.driver.isWeb) {
-            return this.withRefresh(() => this.context.execute(snippets.getElementScrollOffset, [this]));
-        }
-        else {
-            return (_a = this._state.scrollOffset) !== null && _a !== void 0 ? _a : { x: 0, y: 0 };
-        }
-    }
-    async getTranslateOffset() {
-        if (this.driver.isWeb) {
-            return this.withRefresh(() => this.context.execute(snippets.getElementTranslateOffset, [this]));
-        }
-        else {
-            throw new Error('Cannot apply css translate scrolling on non-web element');
-        }
-    }
-    async getInnerOffset() {
-        if (this.driver.isWeb) {
-            return this.withRefresh(() => this.context.execute(snippets.getElementInnerOffset, [this]));
-        }
-        else {
-            return this.getScrollOffset();
-        }
-    }
-    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;
-        // TODO create single js snippet
-        const scrollOffset = await this.getScrollOffset();
-        const transforms = await this.context.execute(snippets.getElementStyleProperties, [
-            this,
-            ['transform', '-webkit-transform'],
-        ]);
-        if (!utils.types.has(this._state, ['scrollOffset', 'transforms'])) {
-            this._state.scrollOffset = scrollOffset;
-            this._state.transforms = transforms;
-        }
-        return { scrollOffset, transforms };
-    }
-    async restoreState(state = this._state) {
-        if (this.driver.isNative)
-            return;
-        if (state.scrollOffset)
-            await this.scrollTo(state.scrollOffset);
-        if (state.transforms)
-            await this.context.execute(snippets.setElementStyleProperties, [this, state.transforms]);
-        if (state === this._state) {
-            this._state.scrollOffset = null;
-            this._state.transforms = null;
-        }
-    }
-    async hideScrollbars() {
-        if (this.driver.isNative)
-            return;
-        if (this._originalOverflow)
-            return;
-        return this.withRefresh(async () => {
-            const { overflow } = await this.context.execute(snippets.setElementStyleProperties, [this, { overflow: 'hidden' }]);
-            this._originalOverflow = overflow;
-        });
-    }
-    async restoreScrollbars() {
-        if (this.driver.isNative)
-            return;
-        if (!this._originalOverflow)
-            return;
-        return this.withRefresh(async () => {
-            await this.context.execute(snippets.setElementStyleProperties, [this, { overflow: this._originalOverflow }]);
-            this._originalOverflow = null;
-        });
-    }
-    async refresh(freshElement) {
-        if (this._spec.isElement(freshElement)) {
-            this._target = freshElement;
-            return true;
-        }
-        if (!this._selector)
-            return false;
-        const element = this._index > 0
-            ? await this.context.elements(this._selector).then(elements => elements[this._index])
-            : await this.context.element(this._selector);
-        if (element) {
-            this._target = element.target;
-        }
-        return Boolean(element);
-    }
-    async withRefresh(operation) {
-        if (!this._spec.isStaleElementError)
-            return operation();
-        try {
-            const result = await operation();
-            // Some frameworks could handle stale element reference error by itself or doesn't throw an error
-            if (this._spec.isStaleElementError(result, this.selector)) {
-                await this.refresh();
-                return operation();
-            }
-            return result;
-        }
-        catch (err) {
-            if (this._spec.isStaleElementError(err)) {
-                const refreshed = await this.refresh();
-                if (refreshed)
-                    return operation();
-            }
-            throw err;
-        }
-    }
-    toJSON() {
-        return this.target;
-    }
-}
-exports.Element = Element;
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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"));
+const specUtils = __importStar(require("./spec-utils"));
+const snippets = require('@applitools/snippets');
+class Element {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f;
+        this._state = {};
+        if (options.element instanceof Element)
+            return options.element;
+        this._spec = options.spec;
+        if (options.context)
+            this._context = options.context;
+        if (options.logger)
+            this._logger = options.logger;
+        if (this._spec.isElement(options.element)) {
+            this._target = (_c = (_b = (_a = this._spec).transformElement) === null || _b === void 0 ? void 0 : _b.call(_a, options.element)) !== null && _c !== void 0 ? _c : options.element;
+            // Some frameworks contains information about the selector inside an element
+            this._selector = (_d = options.selector) !== null && _d !== void 0 ? _d : (_f = (_e = this._spec).extractSelector) === null || _f === void 0 ? void 0 : _f.call(_e, options.element);
+            this._index = options.index;
+        }
+        else if (specUtils.isSelector(this._spec, options.selector)) {
+            this._selector = options.selector;
+        }
+        else {
+            throw new TypeError('Element constructor called with argument of unknown type!');
+        }
+    }
+    get target() {
+        return this._target;
+    }
+    get selector() {
+        return this._selector;
+    }
+    get context() {
+        return this._context;
+    }
+    get driver() {
+        return this.context.driver;
+    }
+    get isRef() {
+        return this.context.isRef || !this.target;
+    }
+    async equals(element) {
+        if (this.isRef)
+            return false;
+        element = element instanceof Element ? element.target : element;
+        if (this.driver.isWeb) {
+            return this._spec
+                .executeScript(this.context.target, snippets.isEqualElements, [this.target, element])
+                .catch(() => false);
+        }
+        else {
+            return this._spec.isEqualElements(this.context.target, this.target, element);
+        }
+    }
+    async init(context) {
+        this._context = context;
+        this._logger = context._logger;
+        if (this._target)
+            return this;
+        if (this._selector) {
+            const element = await this._context.element(this._selector);
+            if (!element)
+                throw new Error(`Cannot find element with selector ${JSON.stringify(this._selector)}`);
+            this._target = element.target;
+            return this;
+        }
+    }
+    async getRegion() {
+        const region = await this.withRefresh(async () => {
+            if (this.driver.isWeb) {
+                this._logger.log('Extracting region of web element with selector', this.selector);
+                return this.context.execute(snippets.getElementRect, [this, false]);
+            }
+            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);
+            }
+        });
+        this._logger.log('Extracted region', region);
+        return region;
+    }
+    async getClientRegion() {
+        const region = await this.withRefresh(async () => {
+            if (this.driver.isWeb) {
+                this._logger.log('Extracting region of web element with selector', this.selector);
+                return this.context.execute(snippets.getElementRect, [this, true]);
+            }
+            else {
+                return this.getRegion();
+            }
+        });
+        this._logger.log('Extracted client region', region);
+        return region;
+    }
+    async getContentSize() {
+        if (this._state.contentSize)
+            return this._state.contentSize;
+        const size = await this.withRefresh(async () => {
+            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]);
+            }
+            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) {
+                        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) {
+                    this._logger.warn('Failed to extract content size, extracting client size instead');
+                    this._logger.error(err);
+                    return utils.geometry.size(await this.getClientRegion());
+                }
+            }
+        });
+        this._logger.log('Extracted content size', size);
+        return size;
+    }
+    async isScrollable() {
+        this._logger.log('Check is element with selector', this.selector, 'is scrollable');
+        const isScrollable = await this.withRefresh(async () => {
+            if (this.driver.isWeb) {
+                return this.context.execute(snippets.isElementScrollable, [this]);
+            }
+            else if (this.driver.isAndroid) {
+                const data = JSON.parse(await this.getAttribute('scrollable'));
+                return Boolean(data) || false;
+            }
+            else if (this.driver.isIOS) {
+                const type = await this.getAttribute('type');
+                return ['XCUIElementTypeScrollView', 'XCUIElementTypeTable', 'XCUIElementTypeCollectionView'].includes(type);
+            }
+        });
+        this._logger.log('Element is scrollable', isScrollable);
+        return isScrollable;
+    }
+    async isRoot() {
+        // TODO replace with snippet
+        return this.withRefresh(async () => {
+            if (this.driver.isWeb) {
+                const rootElement = await this.context.element({ type: 'css', selector: 'html' });
+                return this.equals(rootElement);
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    async getTouchPadding() {
+        var _a;
+        if (this._touchPadding == null) {
+            if (this.driver.isWeb)
+                this._touchPadding = 0;
+            else if (this.driver.isIOS)
+                this._touchPadding = 10;
+            else if (this.driver.isAndroid) {
+                const data = await this.getAttribute('contentSize')
+                    .then(JSON.parse)
+                    .catch(() => null);
+                this._touchPadding = (_a = data === null || data === void 0 ? void 0 : data.touchPadding) !== null && _a !== void 0 ? _a : 24;
+            }
+        }
+        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]]);
+            return properties[name];
+        }
+        else {
+            return this._spec.getElementAttribute(this.driver.target, this.target, name);
+        }
+    }
+    async setAttribute(name, value) {
+        if (this.driver.isWeb) {
+            await this.context.execute(snippets.setElementAttributes, [this, { [name]: value }]);
+        }
+    }
+    async scrollTo(offset) {
+        return this.withRefresh(async () => {
+            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
+                if (this.driver.isIOS)
+                    actualOffset = await this.getScrollOffset();
+                return actualOffset;
+            }
+            else {
+                const currentScrollOffset = await this.getScrollOffset();
+                if (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
+                    ? { 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 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 = 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' },
+                    ]);
+                    xRemaining -= xRight - xLeft;
+                }
+                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';
+                const yGap = yDirection === 'down' ? -touchPadding : touchPadding;
+                let yRemaining = Math.abs(remainingOffset.y);
+                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' },
+                    ]);
+                    yRemaining -= yBottom - yTop;
+                }
+                // ios actions should be executed one-by-one sequentially, otherwise the result isn't stable
+                if (this.driver.isIOS) {
+                    for (const action of actions) {
+                        await this._spec.performAction(this.driver.target, action);
+                    }
+                }
+                else {
+                    await this._spec.performAction(this.driver.target, [].concat(...actions));
+                }
+                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;
+            }
+        });
+    }
+    async translateTo(offset) {
+        offset = { x: Math.round(offset.x), y: Math.round(offset.y) };
+        if (this.driver.isWeb) {
+            return this.withRefresh(async () => this.context.execute(snippets.translateTo, [this, offset]));
+        }
+        else {
+            throw new Error('Cannot apply css translate scrolling on non-web element');
+        }
+    }
+    async getScrollOffset() {
+        var _a;
+        if (this.driver.isWeb) {
+            return this.withRefresh(() => this.context.execute(snippets.getElementScrollOffset, [this]));
+        }
+        else {
+            return (_a = this._state.scrollOffset) !== null && _a !== void 0 ? _a : { x: 0, y: 0 };
+        }
+    }
+    async getTranslateOffset() {
+        if (this.driver.isWeb) {
+            return this.withRefresh(() => this.context.execute(snippets.getElementTranslateOffset, [this]));
+        }
+        else {
+            throw new Error('Cannot apply css translate scrolling on non-web element');
+        }
+    }
+    async getInnerOffset() {
+        if (this.driver.isWeb) {
+            return this.withRefresh(() => this.context.execute(snippets.getElementInnerOffset, [this]));
+        }
+        else {
+            return this.getScrollOffset();
+        }
+    }
+    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;
+        // TODO create single js snippet
+        const scrollOffset = await this.getScrollOffset();
+        const transforms = await this.context.execute(snippets.getElementStyleProperties, [
+            this,
+            ['transform', '-webkit-transform'],
+        ]);
+        if (!utils.types.has(this._state, ['scrollOffset', 'transforms'])) {
+            this._state.scrollOffset = scrollOffset;
+            this._state.transforms = transforms;
+        }
+        return { scrollOffset, transforms };
+    }
+    async restoreState(state = this._state) {
+        if (this.driver.isNative)
+            return;
+        if (state.scrollOffset)
+            await this.scrollTo(state.scrollOffset);
+        if (state.transforms)
+            await this.context.execute(snippets.setElementStyleProperties, [this, state.transforms]);
+        if (state === this._state) {
+            this._state.scrollOffset = null;
+            this._state.transforms = null;
+        }
+    }
+    async hideScrollbars() {
+        if (this.driver.isNative)
+            return;
+        if (this._originalOverflow)
+            return;
+        return this.withRefresh(async () => {
+            const { overflow } = await this.context.execute(snippets.setElementStyleProperties, [this, { overflow: 'hidden' }]);
+            this._originalOverflow = overflow;
+        });
+    }
+    async restoreScrollbars() {
+        if (this.driver.isNative)
+            return;
+        if (!this._originalOverflow)
+            return;
+        return this.withRefresh(async () => {
+            await this.context.execute(snippets.setElementStyleProperties, [this, { overflow: this._originalOverflow }]);
+            this._originalOverflow = null;
+        });
+    }
+    async refresh(freshElement) {
+        if (this._spec.isElement(freshElement)) {
+            this._target = freshElement;
+            return true;
+        }
+        if (!this._selector)
+            return false;
+        const element = this._index > 0
+            ? await this.context.elements(this._selector).then(elements => elements[this._index])
+            : await this.context.element(this._selector);
+        if (element) {
+            this._target = element.target;
+        }
+        return Boolean(element);
+    }
+    async withRefresh(operation) {
+        if (!this._spec.isStaleElementError)
+            return operation();
+        try {
+            const result = await operation();
+            // Some frameworks could handle stale element reference error by itself or doesn't throw an error
+            if (this._spec.isStaleElementError(result, this.selector)) {
+                await this.refresh();
+                return operation();
+            }
+            return result;
+        }
+        catch (err) {
+            if (this._spec.isStaleElementError(err)) {
+                const refreshed = await this.refresh();
+                if (refreshed)
+                    return operation();
+            }
+            throw err;
+        }
+    }
+    toJSON() {
+        return this.target;
+    }
+}
+exports.Element = Element;