@applitools/driver 1.4.17-beta.2 → 1.5.2

package/dist/context.js

@@ -1,493 +1,499 @@
-"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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = void 0;
-const utils = __importStar(require("@applitools/utils"));
-const specUtils = __importStar(require("./spec-utils"));
-const element_1 = require("./element");
-const snippets = require('@applitools/snippets');
-class Context {
-    constructor(options) {
-        var _a, _b, _c;
-        this._state = {};
-        if (options.context instanceof Context)
-            return options.context;
-        this._spec = options.spec;
-        if (options.logger)
-            this._logger = options.logger;
-        if (options.context) {
-            if ((_c = (_b = (_a = this._spec).isContext) === null || _b === void 0 ? void 0 : _b.call(_a, options.context)) !== null && _c !== void 0 ? _c : this._spec.isDriver(options.context)) {
-                this._target = options.context;
-            }
-            else {
-                throw new TypeError('Context constructor called with argument of unknown type of context!');
-            }
-        }
-        if (this._isReference(options.reference)) {
-            if (options.reference instanceof Context)
-                return options.reference;
-            if (!options.parent) {
-                throw new TypeError('Cannot construct child context without reference to the parent');
-            }
-            this._reference = options.reference;
-            this._parent = options.parent;
-            this._scrollingElement = options.scrollingElement;
-            this._driver = options.driver || this._parent.driver;
-        }
-        else if (!options.reference) {
-            this._element = null;
-            this._parent = null;
-            this._scrollingElement = options.scrollingElement;
-            this._driver = options.driver;
-        }
-        else {
-            throw new TypeError('Context constructor called with argument of unknown type!');
-        }
-    }
-    _isReference(reference) {
-        return (reference instanceof Context ||
-            utils.types.isInteger(reference) ||
-            utils.types.isString(reference) ||
-            reference instanceof element_1.Element ||
-            this._spec.isElement(reference) ||
-            specUtils.isSelector(this._spec, reference));
-    }
-    get target() {
-        return this._target;
-    }
-    get driver() {
-        return this._driver;
-    }
-    get parent() {
-        var _a;
-        return (_a = this._parent) !== null && _a !== void 0 ? _a : null;
-    }
-    get main() {
-        var _a, _b;
-        return (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.main) !== null && _b !== void 0 ? _b : this;
-    }
-    get path() {
-        var _a, _b;
-        return [...((_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : []), this];
-    }
-    get isMain() {
-        return this.main === this;
-    }
-    get isCurrent() {
-        return this.driver.currentContext === this;
-    }
-    get isInitialized() {
-        return Boolean(this._element) || this.isMain;
-    }
-    get isRef() {
-        return !this._target;
-    }
-    async init() {
-        if (this.isInitialized)
-            return this;
-        if (!this._reference)
-            throw new TypeError('Cannot initialize context without a reference to the context element');
-        await this.parent.focus();
-        this._logger.log('Context initialization');
-        if (utils.types.isInteger(this._reference)) {
-            this._logger.log('Getting context element using index:', this._reference);
-            const elements = await this.parent.elements('frame, iframe');
-            if (this._reference > elements.length) {
-                throw new TypeError(`Context element with index ${this._reference} is not found`);
-            }
-            this._element = elements[this._reference];
-        }
-        else if (utils.types.isString(this._reference) || specUtils.isSelector(this._spec, this._reference)) {
-            if (utils.types.isString(this._reference)) {
-                this._logger.log('Getting context element by name or id', this._reference);
-                this._element = await this.parent
-                    .element(`iframe[name="${this._reference}"], iframe#${this._reference}`)
-                    .catch(() => null);
-            }
-            if (!this._element && specUtils.isSelector(this._spec, this._reference)) {
-                this._logger.log('Getting context element by selector', this._reference);
-                this._element = await this.parent.element(this._reference);
-            }
-            if (!this._element) {
-                throw new TypeError(`Context element with name, id, or selector ${JSON.stringify(this._reference)}' is not found`);
-            }
-        }
-        else if (this._spec.isElement(this._reference) || this._reference instanceof element_1.Element) {
-            this._logger.log('Initialize context from reference element', this._reference);
-            this._element = new element_1.Element({
-                spec: this._spec,
-                context: this.parent,
-                element: this._reference,
-                logger: this._logger,
-            });
-        }
-        else {
-            throw new TypeError('Reference type does not supported');
-        }
-        this._reference = null;
-        return this;
-    }
-    async focus() {
-        if (this.isCurrent) {
-            return this;
-        }
-        else if (this.isMain) {
-            await this.driver.switchToMainContext();
-            return this;
-        }
-        if (this.isRef) {
-            await this.init();
-        }
-        if (!this.parent.isCurrent) {
-            await this.driver.switchTo(this);
-            return this;
-        }
-        await this.parent.preserveInnerOffset();
-        if (this.parent.isMain)
-            await this.parent.preserveContextRegions();
-        await this.preserveContextRegions();
-        this._target = await this._spec.childContext(this.parent.target, this._element.target);
-        this.driver.updateCurrentContext(this);
-        return this;
-    }
-    async equals(context) {
-        if (context === this || (this.isMain && context === null))
-            return true;
-        if (!this._element)
-            return false;
-        return this._element.equals(context instanceof Context ? await context.getContextElement() : context);
-    }
-    async context(reference) {
-        if (reference instanceof Context) {
-            if (reference.parent !== this && !(await this.equals(reference.parent))) {
-                throw Error('Cannot attach a child context because it has a different parent');
-            }
-            return reference;
-        }
-        else if (this._isReference(reference)) {
-            return new Context({ spec: this._spec, parent: this, driver: this.driver, reference, logger: this._logger });
-        }
-        else if (utils.types.has(reference, 'reference')) {
-            const parent = reference.parent ? await this.context(reference.parent) : this;
-            return new Context({
-                spec: this._spec,
-                parent,
-                driver: this.driver,
-                reference: reference.reference,
-                scrollingElement: reference === null || reference === void 0 ? void 0 : reference.scrollingElement,
-                logger: this._logger,
-            });
-        }
-    }
-    async root(selector) {
-        var _a;
-        await this.focus();
-        const { contextSelectors, elementSelector } = specUtils.splitSelector(this._spec, selector);
-        let context = this;
-        for (const contextSelector of contextSelectors) {
-            try {
-                context = await context.context(contextSelector);
-                await context.focus();
-            }
-            catch (_b) {
-                return null;
-            }
-        }
-        if ((_a = this.driver.features) === null || _a === void 0 ? void 0 : _a.shadowSelector)
-            return { context, selector: elementSelector };
-        let root = null;
-        let currentSelector = elementSelector;
-        while (specUtils.isCommonSelector(this._spec, currentSelector) &&
-            specUtils.isSelector(this._spec, currentSelector.shadow)) {
-            const element = await this._spec.findElement(this.target, specUtils.transformSelector(this._spec, currentSelector, this.driver), root);
-            if (!element)
-                return null;
-            root = await this._spec.executeScript(this.target, snippets.getShadowRoot, [element]);
-            if (!root)
-                return null;
-            currentSelector = currentSelector.shadow;
-        }
-        return {
-            context,
-            shadow: root ? new element_1.Element({ spec: this._spec, context, element: root, logger: this._logger }) : null,
-            selector: currentSelector,
-        };
-    }
-    async element(elementOrSelector) {
-        var _a;
-        if (this._spec.isElement(elementOrSelector)) {
-            return new element_1.Element({ spec: this._spec, context: this, element: elementOrSelector, logger: this._logger });
-        }
-        else if (specUtils.isSelector(this._spec, elementOrSelector)) {
-            if (this.isRef) {
-                return new element_1.Element({ spec: this._spec, context: this, selector: elementOrSelector, logger: this._logger });
-            }
-            const root = await this.root(elementOrSelector);
-            if (!root)
-                return null;
-            const element = await this._spec.findElement(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), (_a = root.shadow) === null || _a === void 0 ? void 0 : _a.target);
-            // TODO root.selector is not a full selector from context root to an element, but selector inside a shadow
-            return element
-                ? new element_1.Element({ spec: this._spec, context: root.context, element, selector: root.selector, logger: this._logger })
-                : null;
-        }
-        else {
-            throw new TypeError('Cannot find element using argument of unknown type!');
-        }
-    }
-    async elements(elementOrSelector) {
-        var _a;
-        if (this._spec.isElement(elementOrSelector)) {
-            return [new element_1.Element({ spec: this._spec, context: this, element: elementOrSelector, logger: this._logger })];
-        }
-        else if (specUtils.isSelector(this._spec, elementOrSelector)) {
-            if (this.isRef) {
-                return [new element_1.Element({ spec: this._spec, context: this, selector: elementOrSelector, logger: this._logger })];
-            }
-            const root = await this.root(elementOrSelector);
-            if (!root)
-                return [];
-            const elements = await this._spec.findElements(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), (_a = root.shadow) === null || _a === void 0 ? void 0 : _a.target);
-            return elements.map((element, index) => {
-                // TODO root.selector is not a full selector from context root to an element, but selector inside a shadow
-                return new element_1.Element({
-                    spec: this._spec,
-                    context: root.context,
-                    element,
-                    selector: root.selector,
-                    index,
-                    logger: this._logger,
-                });
-            });
-        }
-        else {
-            throw new TypeError('Cannot find elements using argument of unknown type!');
-        }
-    }
-    async waitFor(selector, options) {
-        var _a, _b;
-        const root = await this.root(selector);
-        if (!root)
-            return null;
-        options = Object.assign({ state: 'exist', timeout: 10000, interval: 500 }, options);
-        if (this._spec.waitForSelector) {
-            const element = await this._spec.waitForSelector(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), (_a = root.shadow) === null || _a === void 0 ? void 0 : _a.target, options);
-            return element
-                ? new element_1.Element({ spec: this._spec, context: root.context, element, selector: root.selector, logger: this._logger })
-                : null;
-        }
-        let waiting = true;
-        const timeout = setTimeout(() => (waiting = false), options.timeout);
-        while (waiting) {
-            const element = await this._spec.findElement(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), (_b = root.shadow) === null || _b === void 0 ? void 0 : _b.target);
-            if (element) {
-                clearTimeout(timeout);
-                return new element_1.Element({
-                    spec: this._spec,
-                    context: root.context,
-                    element,
-                    selector: root.selector,
-                    logger: this._logger,
-                });
-            }
-            await utils.general.sleep(options.interval);
-        }
-        return null;
-    }
-    async execute(script, arg) {
-        await this.focus();
-        try {
-            return await this._spec.executeScript(this.target, script, serialize.call(this, arg));
-        }
-        catch (err) {
-            this._logger.warn('Error during script execution with argument', arg);
-            this._logger.error(err);
-            throw err;
-        }
-        function serialize(value) {
-            var _a, _b;
-            if (this._spec.isElement(value) || value instanceof element_1.Element) {
-                return value instanceof element_1.Element ? value.toJSON() : value;
-            }
-            else if (utils.types.isArray(value)) {
-                return value.map(value => serialize.call(this, value));
-            }
-            else if (utils.types.isObject(value)) {
-                return Object.entries((_b = (_a = value.toJSON) === null || _a === void 0 ? void 0 : _a.call(value)) !== null && _b !== void 0 ? _b : value).reduce((serialized, [key, value]) => {
-                    return Object.assign(serialized, { [key]: serialize.call(this, value) });
-                }, {});
-            }
-            else {
-                return value;
-            }
-        }
-    }
-    async getContextElement() {
-        if (this.isMain)
-            return null;
-        await this.init();
-        return this._element;
-    }
-    async getScrollingElement() {
-        if (!(this._scrollingElement instanceof element_1.Element)) {
-            await this.focus();
-            if (this._scrollingElement) {
-                this._scrollingElement = await this.element(this._scrollingElement);
-            }
-            else {
-                this._scrollingElement = await this.element(this.driver.isWeb ? { type: 'css', selector: 'html' } : { type: 'xpath', selector: '//*[@scrollable="true"]' });
-            }
-        }
-        return this._scrollingElement;
-    }
-    async setScrollingElement(scrollingElement) {
-        if (scrollingElement === undefined)
-            return;
-        else if (scrollingElement === null)
-            this._scrollingElement = null;
-        else {
-            this._scrollingElement =
-                scrollingElement instanceof element_1.Element ? scrollingElement : await this.element(scrollingElement);
-        }
-    }
-    async blurElement(element) {
-        try {
-            return await this.execute(snippets.blurElement, [element]);
-        }
-        catch (err) {
-            this._logger.warn('Cannot blur element', element);
-            this._logger.error(err);
-            return null;
-        }
-    }
-    async focusElement(element) {
-        try {
-            return await this.execute(snippets.focusElement, [element]);
-        }
-        catch (err) {
-            this._logger.warn('Cannot focus element', element);
-            this._logger.error(err);
-            return null;
-        }
-    }
-    async getRegion() {
-        var _a;
-        if (this.isMain && this.isCurrent) {
-            const viewportRegion = utils.geometry.region({ x: 0, y: 0 }, await this.driver.getViewportSize());
-            this._state.region = this._scrollingElement
-                ? utils.geometry.region({ x: 0, y: 0 }, utils.geometry.intersect(viewportRegion, await this._scrollingElement.getRegion()))
-                : viewportRegion;
-        }
-        else if ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isCurrent) {
-            await this.init();
-            this._state.region = await this._element.getRegion();
-        }
-        return this._state.region;
-    }
-    async getClientRegion() {
-        var _a;
-        if (this.isMain && this.isCurrent) {
-            const viewportRegion = utils.geometry.region({ x: 0, y: 0 }, await this.driver.getViewportSize());
-            this._state.clientRegion = this._scrollingElement
-                ? utils.geometry.region({ x: 0, y: 0 }, utils.geometry.intersect(viewportRegion, await this._scrollingElement.getClientRegion()))
-                : viewportRegion;
-        }
-        else if ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isCurrent) {
-            await this.init();
-            this._state.clientRegion = await this._element.getClientRegion();
-        }
-        return this._state.clientRegion;
-    }
-    async getScrollingRegion() {
-        if (this.isCurrent) {
-            const scrollingElement = await this.getScrollingElement();
-            this._state.scrollingRegion = await scrollingElement.getClientRegion();
-        }
-        return this._state.scrollingRegion;
-    }
-    async getContentSize() {
-        return this.execute(snippets.getDocumentSize);
-    }
-    async getInnerOffset() {
-        if (this.isCurrent) {
-            const scrollingElement = await this.getScrollingElement();
-            this._state.innerOffset = scrollingElement ? await scrollingElement.getInnerOffset() : { x: 0, y: 0 };
-        }
-        return this._state.innerOffset;
-    }
-    async getLocationInMainContext() {
-        return this.path.reduce((location, context) => {
-            return location.then(async (location) => {
-                return utils.geometry.offset(location, utils.geometry.location(await context.getClientRegion()));
-            });
-        }, Promise.resolve({ x: 0, y: 0 }));
-    }
-    async getLocationInViewport() {
-        var _a, _b;
-        let location = utils.geometry.offsetNegative({ x: 0, y: 0 }, await this.getInnerOffset());
-        if (this.isMain)
-            return location;
-        let currentContext = this;
-        while (currentContext) {
-            const contextLocation = utils.geometry.location(await currentContext.getClientRegion());
-            const parentContextInnerOffset = (_b = (await ((_a = currentContext.parent) === null || _a === void 0 ? void 0 : _a.getInnerOffset()))) !== null && _b !== void 0 ? _b : { x: 0, y: 0 };
-            location = utils.geometry.offsetNegative(utils.geometry.offset(location, contextLocation), parentContextInnerOffset);
-            currentContext = currentContext.parent;
-        }
-        return location;
-    }
-    async getRegionInViewport(region) {
-        var _a, _b;
-        let currentContext = this;
-        if (region)
-            region = utils.geometry.offsetNegative(region, await currentContext.getInnerOffset());
-        else
-            region = { x: 0, y: 0, width: Infinity, height: Infinity };
-        while (currentContext) {
-            const contextRegion = await currentContext.getClientRegion();
-            // const contextScrollingRegion = await currentContext.getScrollingRegion()
-            const parentContextInnerOffset = (_b = (await ((_a = currentContext.parent) === null || _a === void 0 ? void 0 : _a.getInnerOffset()))) !== null && _b !== void 0 ? _b : { x: 0, y: 0 };
-            region = utils.geometry.intersect(contextRegion, utils.geometry.offset(region, contextRegion));
-            // region = utils.geometry.intersect(contextScrollingRegion, region)
-            region = utils.geometry.offsetNegative(region, parentContextInnerOffset);
-            currentContext = currentContext.parent;
-        }
-        return region;
-    }
-    async getCookies() {
-        var _a, _b, _c;
-        if (this.driver.isNative)
-            return [];
-        await this.focus();
-        return (_c = (_b = (_a = this._spec).getCookies) === null || _b === void 0 ? void 0 : _b.call(_a, this.target, true)) !== null && _c !== void 0 ? _c : [];
-    }
-    async preserveInnerOffset() {
-        this._state.innerOffset = await this.getInnerOffset();
-    }
-    async preserveContextRegions() {
-        this._state.region = await this.getRegion();
-        this._state.clientRegion = await this.getClientRegion();
-    }
-    async preserveScrollingRegion() {
-        this._state.scrollingRegion = await this.getScrollingRegion();
-    }
-}
-exports.Context = Context;
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const utils = __importStar(require("@applitools/utils"));
+const specUtils = __importStar(require("./spec-utils"));
+const element_1 = require("./element");
+const snippets = require('@applitools/snippets');
+class Context {
+    constructor(options) {
+        var _a, _b, _c;
+        this._state = {};
+        if (options.context instanceof Context)
+            return options.context;
+        this._spec = options.spec;
+        if (options.logger)
+            this._logger = options.logger;
+        if (options.context) {
+            if ((_c = (_b = (_a = this._spec).isContext) === null || _b === void 0 ? void 0 : _b.call(_a, options.context)) !== null && _c !== void 0 ? _c : this._spec.isDriver(options.context)) {
+                this._target = options.context;
+            }
+            else {
+                throw new TypeError('Context constructor called with argument of unknown type of context!');
+            }
+        }
+        if (this._isReference(options.reference)) {
+            if (options.reference instanceof Context)
+                return options.reference;
+            if (!options.parent) {
+                throw new TypeError('Cannot construct child context without reference to the parent');
+            }
+            this._reference = options.reference;
+            this._parent = options.parent;
+            this._scrollingElement = options.scrollingElement;
+            this._driver = options.driver || this._parent.driver;
+        }
+        else if (!options.reference) {
+            this._element = null;
+            this._parent = null;
+            this._scrollingElement = options.scrollingElement;
+            this._driver = options.driver;
+        }
+        else {
+            throw new TypeError('Context constructor called with argument of unknown type!');
+        }
+    }
+    _isReference(reference) {
+        return (reference instanceof Context ||
+            utils.types.isInteger(reference) ||
+            utils.types.isString(reference) ||
+            reference instanceof element_1.Element ||
+            this._spec.isElement(reference) ||
+            specUtils.isSelector(this._spec, reference));
+    }
+    get target() {
+        return this._target;
+    }
+    get driver() {
+        return this._driver;
+    }
+    get parent() {
+        var _a;
+        return (_a = this._parent) !== null && _a !== void 0 ? _a : null;
+    }
+    get main() {
+        var _a, _b;
+        return (_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.main) !== null && _b !== void 0 ? _b : this;
+    }
+    get path() {
+        var _a, _b;
+        return [...((_b = (_a = this.parent) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : []), this];
+    }
+    get isMain() {
+        return this.main === this;
+    }
+    get isCurrent() {
+        return this.driver.currentContext === this;
+    }
+    get isInitialized() {
+        return Boolean(this._element) || this.isMain;
+    }
+    get isRef() {
+        return !this._target;
+    }
+    async init() {
+        if (this.isInitialized)
+            return this;
+        if (!this._reference)
+            throw new TypeError('Cannot initialize context without a reference to the context element');
+        await this.parent.focus();
+        this._logger.log('Context initialization');
+        if (utils.types.isInteger(this._reference)) {
+            this._logger.log('Getting context element using index:', this._reference);
+            const elements = await this.parent.elements('frame, iframe');
+            if (this._reference > elements.length) {
+                throw new TypeError(`Context element with index ${this._reference} is not found`);
+            }
+            this._element = elements[this._reference];
+        }
+        else if (utils.types.isString(this._reference) || specUtils.isSelector(this._spec, this._reference)) {
+            if (utils.types.isString(this._reference)) {
+                this._logger.log('Getting context element by name or id', this._reference);
+                this._element = await this.parent
+                    .element(`iframe[name="${this._reference}"], iframe#${this._reference}`)
+                    .catch(() => null);
+            }
+            if (!this._element && specUtils.isSelector(this._spec, this._reference)) {
+                this._logger.log('Getting context element by selector', this._reference);
+                this._element = await this.parent.element(this._reference);
+            }
+            if (!this._element) {
+                throw new TypeError(`Context element with name, id, or selector ${JSON.stringify(this._reference)}' is not found`);
+            }
+        }
+        else if (this._spec.isElement(this._reference) || this._reference instanceof element_1.Element) {
+            this._logger.log('Initialize context from reference element', this._reference);
+            this._element = new element_1.Element({
+                spec: this._spec,
+                context: this.parent,
+                element: this._reference,
+                logger: this._logger,
+            });
+        }
+        else {
+            throw new TypeError('Reference type does not supported');
+        }
+        this._reference = null;
+        return this;
+    }
+    async focus() {
+        if (this.isCurrent) {
+            return this;
+        }
+        else if (this.isMain) {
+            await this.driver.switchToMainContext();
+            return this;
+        }
+        if (this.isRef) {
+            await this.init();
+        }
+        if (!this.parent.isCurrent) {
+            await this.driver.switchTo(this);
+            return this;
+        }
+        await this.parent.preserveInnerOffset();
+        if (this.parent.isMain)
+            await this.parent.preserveContextRegions();
+        await this.preserveContextRegions();
+        this._target = await this._spec.childContext(this.parent.target, this._element.target);
+        this.driver.updateCurrentContext(this);
+        return this;
+    }
+    async equals(context) {
+        if (context === this || (this.isMain && context === null))
+            return true;
+        if (!this._element)
+            return false;
+        return this._element.equals(context instanceof Context ? await context.getContextElement() : context);
+    }
+    async context(reference) {
+        if (reference instanceof Context) {
+            if (reference.parent !== this && !(await this.equals(reference.parent))) {
+                throw Error('Cannot attach a child context because it has a different parent');
+            }
+            return reference;
+        }
+        else if (this._isReference(reference)) {
+            return new Context({ spec: this._spec, parent: this, driver: this.driver, reference, logger: this._logger });
+        }
+        else if (utils.types.has(reference, 'reference')) {
+            const parent = reference.parent ? await this.context(reference.parent) : this;
+            return new Context({
+                spec: this._spec,
+                parent,
+                driver: this.driver,
+                reference: reference.reference,
+                scrollingElement: reference === null || reference === void 0 ? void 0 : reference.scrollingElement,
+                logger: this._logger,
+            });
+        }
+    }
+    async root(selector) {
+        var _a;
+        await this.focus();
+        const { contextSelectors, elementSelector } = specUtils.splitSelector(this._spec, selector);
+        let context = this;
+        for (const contextSelector of contextSelectors) {
+            try {
+                context = await context.context(contextSelector);
+                await context.focus();
+            }
+            catch (_b) {
+                return null;
+            }
+        }
+        if ((_a = this.driver.features) === null || _a === void 0 ? void 0 : _a.shadowSelector)
+            return { context, selector: elementSelector };
+        let root = null;
+        let currentSelector = elementSelector;
+        while (specUtils.isCommonSelector(this._spec, currentSelector) &&
+            specUtils.isSelector(this._spec, currentSelector.shadow)) {
+            const element = await this._spec.findElement(this.target, specUtils.transformSelector(this._spec, currentSelector, this.driver), root);
+            if (!element)
+                return null;
+            root = await this._spec.executeScript(this.target, snippets.getShadowRoot, [element]);
+            if (!root)
+                return null;
+            currentSelector = currentSelector.shadow;
+        }
+        return {
+            context,
+            shadow: root ? new element_1.Element({ spec: this._spec, context, element: root, logger: this._logger }) : null,
+            selector: currentSelector,
+        };
+    }
+    async element(elementOrSelector) {
+        var _a;
+        if (this._spec.isElement(elementOrSelector)) {
+            return new element_1.Element({ spec: this._spec, context: this, element: elementOrSelector, logger: this._logger });
+        }
+        else if (specUtils.isSelector(this._spec, elementOrSelector)) {
+            if (this.isRef) {
+                return new element_1.Element({ spec: this._spec, context: this, selector: elementOrSelector, logger: this._logger });
+            }
+            const root = await this.root(elementOrSelector);
+            if (!root)
+                return null;
+            const element = await this._spec.findElement(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), (_a = root.shadow) === null || _a === void 0 ? void 0 : _a.target);
+            // TODO root.selector is not a full selector from context root to an element, but selector inside a shadow
+            return element
+                ? new element_1.Element({ spec: this._spec, context: root.context, element, selector: root.selector, logger: this._logger })
+                : null;
+        }
+        else {
+            throw new TypeError('Cannot find element using argument of unknown type!');
+        }
+    }
+    async elements(elementOrSelector) {
+        var _a;
+        if (this._spec.isElement(elementOrSelector)) {
+            return [new element_1.Element({ spec: this._spec, context: this, element: elementOrSelector, logger: this._logger })];
+        }
+        else if (specUtils.isSelector(this._spec, elementOrSelector)) {
+            if (this.isRef) {
+                return [new element_1.Element({ spec: this._spec, context: this, selector: elementOrSelector, logger: this._logger })];
+            }
+            const root = await this.root(elementOrSelector);
+            if (!root)
+                return [];
+            const elements = await this._spec.findElements(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), (_a = root.shadow) === null || _a === void 0 ? void 0 : _a.target);
+            return elements.map((element, index) => {
+                // TODO root.selector is not a full selector from context root to an element, but selector inside a shadow
+                return new element_1.Element({
+                    spec: this._spec,
+                    context: root.context,
+                    element,
+                    selector: root.selector,
+                    index,
+                    logger: this._logger,
+                });
+            });
+        }
+        else {
+            throw new TypeError('Cannot find elements using argument of unknown type!');
+        }
+    }
+    async waitFor(selector, options) {
+        var _a, _b;
+        const root = await this.root(selector);
+        if (!root)
+            return null;
+        options = Object.assign({ state: 'exist', timeout: 10000, interval: 500 }, options);
+        if (this._spec.waitForSelector) {
+            const element = await this._spec.waitForSelector(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), (_a = root.shadow) === null || _a === void 0 ? void 0 : _a.target, options);
+            return element
+                ? new element_1.Element({ spec: this._spec, context: root.context, element, selector: root.selector, logger: this._logger })
+                : null;
+        }
+        let waiting = true;
+        const timeout = setTimeout(() => (waiting = false), options.timeout);
+        while (waiting) {
+            const element = await this._spec.findElement(root.context.target, specUtils.transformSelector(this._spec, root.selector, this.driver), (_b = root.shadow) === null || _b === void 0 ? void 0 : _b.target);
+            if (element) {
+                clearTimeout(timeout);
+                return new element_1.Element({
+                    spec: this._spec,
+                    context: root.context,
+                    element,
+                    selector: root.selector,
+                    logger: this._logger,
+                });
+            }
+            await utils.general.sleep(options.interval);
+        }
+        return null;
+    }
+    async execute(script, arg) {
+        await this.focus();
+        try {
+            return await this._spec.executeScript(this.target, script, serialize.call(this, arg));
+        }
+        catch (err) {
+            this._logger.warn('Error during script execution with argument', arg);
+            this._logger.error(err);
+            throw err;
+        }
+        function serialize(value) {
+            var _a, _b;
+            if (this._spec.isElement(value) || value instanceof element_1.Element) {
+                return value instanceof element_1.Element ? value.toJSON() : value;
+            }
+            else if (utils.types.isArray(value)) {
+                return value.map(value => serialize.call(this, value));
+            }
+            else if (utils.types.isObject(value)) {
+                return Object.entries((_b = (_a = value.toJSON) === null || _a === void 0 ? void 0 : _a.call(value)) !== null && _b !== void 0 ? _b : value).reduce((serialized, [key, value]) => {
+                    return Object.assign(serialized, { [key]: serialize.call(this, value) });
+                }, {});
+            }
+            else {
+                return value;
+            }
+        }
+    }
+    async getContextElement() {
+        if (this.isMain)
+            return null;
+        await this.init();
+        return this._element;
+    }
+    async getScrollingElement() {
+        if (!(this._scrollingElement instanceof element_1.Element)) {
+            await this.focus();
+            if (this._scrollingElement) {
+                this._scrollingElement = await this.element(this._scrollingElement);
+            }
+            else if (this.driver.isWeb) {
+                const isIOS = this.driver.isIOS;
+                const selector = isIOS ? 'html' : await this.execute(snippets.getDocumentScrollingElement);
+                this._logger.log(`default SRE is ${selector}${isIOS ? ' (because Safari on iOS)' : ''}`);
+                this._scrollingElement = await this.element({ type: 'css', selector });
+            }
+            else {
+                this._scrollingElement = await this.element({ type: 'xpath', selector: '//*[@scrollable="true"]' });
+            }
+        }
+        return this._scrollingElement;
+    }
+    async setScrollingElement(scrollingElement) {
+        if (scrollingElement === undefined)
+            return;
+        else if (scrollingElement === null)
+            this._scrollingElement = null;
+        else {
+            this._scrollingElement =
+                scrollingElement instanceof element_1.Element ? scrollingElement : await this.element(scrollingElement);
+        }
+    }
+    async blurElement(element) {
+        try {
+            return await this.execute(snippets.blurElement, [element]);
+        }
+        catch (err) {
+            this._logger.warn('Cannot blur element', element);
+            this._logger.error(err);
+            return null;
+        }
+    }
+    async focusElement(element) {
+        try {
+            return await this.execute(snippets.focusElement, [element]);
+        }
+        catch (err) {
+            this._logger.warn('Cannot focus element', element);
+            this._logger.error(err);
+            return null;
+        }
+    }
+    async getRegion() {
+        var _a;
+        if (this.isMain && this.isCurrent) {
+            const viewportRegion = utils.geometry.region({ x: 0, y: 0 }, await this.driver.getViewportSize());
+            this._state.region = this._scrollingElement
+                ? utils.geometry.region({ x: 0, y: 0 }, utils.geometry.intersect(viewportRegion, await this._scrollingElement.getRegion()))
+                : viewportRegion;
+        }
+        else if ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isCurrent) {
+            await this.init();
+            this._state.region = await this._element.getRegion();
+        }
+        return this._state.region;
+    }
+    async getClientRegion() {
+        var _a;
+        if (this.isMain && this.isCurrent) {
+            const viewportRegion = utils.geometry.region({ x: 0, y: 0 }, await this.driver.getViewportSize());
+            this._state.clientRegion = this._scrollingElement
+                ? utils.geometry.region({ x: 0, y: 0 }, utils.geometry.intersect(viewportRegion, await this._scrollingElement.getClientRegion()))
+                : viewportRegion;
+        }
+        else if ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isCurrent) {
+            await this.init();
+            this._state.clientRegion = await this._element.getClientRegion();
+        }
+        return this._state.clientRegion;
+    }
+    async getScrollingRegion() {
+        if (this.isCurrent) {
+            const scrollingElement = await this.getScrollingElement();
+            this._state.scrollingRegion = await scrollingElement.getClientRegion();
+        }
+        return this._state.scrollingRegion;
+    }
+    async getContentSize() {
+        return this.execute(snippets.getDocumentSize);
+    }
+    async getInnerOffset() {
+        if (this.isCurrent) {
+            const scrollingElement = await this.getScrollingElement();
+            this._state.innerOffset = scrollingElement ? await scrollingElement.getInnerOffset() : { x: 0, y: 0 };
+        }
+        return this._state.innerOffset;
+    }
+    async getLocationInMainContext() {
+        return this.path.reduce((location, context) => {
+            return location.then(async (location) => {
+                return utils.geometry.offset(location, utils.geometry.location(await context.getClientRegion()));
+            });
+        }, Promise.resolve({ x: 0, y: 0 }));
+    }
+    async getLocationInViewport() {
+        var _a, _b;
+        let location = utils.geometry.offsetNegative({ x: 0, y: 0 }, await this.getInnerOffset());
+        if (this.isMain)
+            return location;
+        let currentContext = this;
+        while (currentContext) {
+            const contextLocation = utils.geometry.location(await currentContext.getClientRegion());
+            const parentContextInnerOffset = (_b = (await ((_a = currentContext.parent) === null || _a === void 0 ? void 0 : _a.getInnerOffset()))) !== null && _b !== void 0 ? _b : { x: 0, y: 0 };
+            location = utils.geometry.offsetNegative(utils.geometry.offset(location, contextLocation), parentContextInnerOffset);
+            currentContext = currentContext.parent;
+        }
+        return location;
+    }
+    async getRegionInViewport(region) {
+        var _a, _b;
+        let currentContext = this;
+        if (region)
+            region = utils.geometry.offsetNegative(region, await currentContext.getInnerOffset());
+        else
+            region = { x: 0, y: 0, width: Infinity, height: Infinity };
+        while (currentContext) {
+            const contextRegion = await currentContext.getClientRegion();
+            // const contextScrollingRegion = await currentContext.getScrollingRegion()
+            const parentContextInnerOffset = (_b = (await ((_a = currentContext.parent) === null || _a === void 0 ? void 0 : _a.getInnerOffset()))) !== null && _b !== void 0 ? _b : { x: 0, y: 0 };
+            region = utils.geometry.intersect(contextRegion, utils.geometry.offset(region, contextRegion));
+            // region = utils.geometry.intersect(contextScrollingRegion, region)
+            region = utils.geometry.offsetNegative(region, parentContextInnerOffset);
+            currentContext = currentContext.parent;
+        }
+        return region;
+    }
+    async getCookies() {
+        var _a, _b, _c;
+        if (this.driver.isNative)
+            return [];
+        await this.focus();
+        return (_c = (_b = (_a = this._spec).getCookies) === null || _b === void 0 ? void 0 : _b.call(_a, this.target, true)) !== null && _c !== void 0 ? _c : [];
+    }
+    async preserveInnerOffset() {
+        this._state.innerOffset = await this.getInnerOffset();
+    }
+    async preserveContextRegions() {
+        this._state.region = await this.getRegion();
+        this._state.clientRegion = await this.getClientRegion();
+    }
+    async preserveScrollingRegion() {
+        this._state.scrollingRegion = await this.getScrollingRegion();
+    }
+}
+exports.Context = Context;