@applitools/driver 1.11.50 → 1.11.52

package/dist/capabilities.js

@@ -28,7 +28,9 @@ function extractCapabilitiesEnvironment(capabilities) {
         if (!environment.browserName) {
             environment.isNative = true;
         }
-        else if (environment.isIOS && !/mobilesafari/i.test(capabilities.CFBundleIdentifier)) {
+        else if (environment.isIOS &&
+            capabilities.CFBundleIdentifier &&
+            !/mobilesafari/i.test(capabilities.CFBundleIdentifier)) {
             environment.browserName = undefined;
             environment.isNative = true;
         }

package/dist/context.js

@@ -41,7 +41,6 @@ class Context {
         var _a, _b, _c, _d;
         this._state = {};
         this._spec = options.spec;
-        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;
@@ -67,6 +66,9 @@ class Context {
             throw new TypeError('Context constructor called with context reference of unknown type!');
         }
     }
+    get logger() {
+        return this._driver.logger;
+    }
     get target() {
         return this._target;
     }
@@ -171,9 +173,9 @@ class Context {
             throw new TypeError('Cannot initialize context without a reference to the context element');
         }
         await this.parent.focus();
-        this._logger.log('Context initialization');
+        this.logger.log('Context initialization');
         if (utils.types.isInteger(this._reference)) {
-            this._logger.log('Getting context element using index:', 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`);
@@ -182,13 +184,13 @@ class Context {
         }
         else if (utils.types.isString(this._reference) || (0, selector_1.isSelector)(this._reference, this._spec)) {
             if (utils.types.isString(this._reference)) {
-                this._logger.log('Getting context element by name or id', 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 && (0, selector_1.isSelector)(this._reference, this._spec)) {
-                this._logger.log('Getting context element by selector', this._reference);
+                this.logger.log('Getting context element by selector', this._reference);
                 this._element = await this.parent.element(this._reference);
             }
             if (!this._element) {
@@ -196,11 +198,11 @@ class Context {
             }
         }
         else if (this._spec.isElement(this._reference) || this._reference instanceof element_1.Element) {
-            this._logger.log('Initialize context from reference element', this._reference);
+            this.logger.log('Initialize context from reference element', this._reference);
             this._element =
                 this._reference instanceof element_1.Element
                     ? this._reference
-                    : new element_1.Element({ spec: this._spec, context: this.parent, element: this._reference, logger: this._logger });
+                    : new element_1.Element({ spec: this._spec, context: this.parent, element: this._reference });
         }
         else {
             throw new TypeError('Reference type does not supported');
@@ -246,7 +248,7 @@ class Context {
             return reference;
         }
         else if (this._isReference(reference)) {
-            return new Context({ spec: this._spec, parent: this, driver: this.driver, reference, logger: this._logger });
+            return new Context({ spec: this._spec, parent: this, driver: this.driver, reference });
         }
         else if (utils.types.has(reference, 'reference')) {
             if (reference.reference instanceof Context)
@@ -258,7 +260,6 @@ class Context {
                 driver: this.driver,
                 reference: reference.reference,
                 scrollingElement: reference === null || reference === void 0 ? void 0 : reference.scrollingElement,
-                logger: this._logger,
             });
         }
         else {
@@ -267,26 +268,24 @@ class Context {
     }
     async element(elementOrSelector) {
         if (this._spec.isElement(elementOrSelector)) {
-            return new element_1.Element({ spec: this._spec, context: this, element: elementOrSelector, logger: this._logger });
+            return new element_1.Element({ spec: this._spec, context: this, element: elementOrSelector });
         }
         else if (!(0, selector_1.isSelector)(elementOrSelector, this._spec)) {
             throw new TypeError('Cannot find element using argument of unknown type!');
         }
         if (this.isRef) {
-            return new element_1.Element({ spec: this._spec, context: this, selector: elementOrSelector, logger: this._logger });
+            return new element_1.Element({ spec: this._spec, context: this, selector: elementOrSelector });
         }
-        this._logger.log('Finding element by selector: ', elementOrSelector);
+        this.logger.log('Finding element by selector: ', elementOrSelector);
         const [element] = await this._findElements(elementOrSelector, { all: false });
-        return element
-            ? new element_1.Element({ spec: this._spec, context: this, element, selector: elementOrSelector, logger: this._logger })
-            : null;
+        return element ? new element_1.Element({ spec: this._spec, context: this, element, selector: elementOrSelector }) : null;
     }
     async elements(selectorOrElement) {
         if ((0, selector_1.isSelector)(selectorOrElement, this._spec)) {
             if (this.isRef) {
-                return [new element_1.Element({ spec: this._spec, context: this, selector: selectorOrElement, logger: this._logger })];
+                return [new element_1.Element({ spec: this._spec, context: this, selector: selectorOrElement })];
             }
-            this._logger.log('Finding elements by selector: ', selectorOrElement);
+            this.logger.log('Finding elements by selector: ', selectorOrElement);
             const elements = await this._findElements(selectorOrElement, { all: true });
             return elements.map((element, index) => {
                 return new element_1.Element({
@@ -295,23 +294,22 @@ class Context {
                     element,
                     selector: selectorOrElement,
                     index,
-                    logger: this._logger,
                 });
             });
         }
         else if (this._spec.isElement(selectorOrElement)) {
-            return [new element_1.Element({ spec: this._spec, context: this, element: selectorOrElement, logger: this._logger })];
+            return [new element_1.Element({ spec: this._spec, context: this, element: selectorOrElement })];
         }
         else {
             throw new TypeError('Cannot find elements using argument of unknown type!');
         }
     }
     async waitFor(selector, options) {
-        this._logger.log('Waiting for element by selector: ', selector, 'and options', options);
+        this.logger.log('Waiting for element by selector: ', selector, 'and options', options);
         const [element] = await this._findElements(selector, {
             wait: { state: 'exist', timeout: 10000, interval: 500, ...options },
         });
-        return element ? new element_1.Element({ spec: this._spec, context: this, element, selector, logger: this._logger }) : null;
+        return element ? new element_1.Element({ spec: this._spec, context: this, element, selector }) : null;
     }
     async execute(script, arg) {
         await this.focus();
@@ -319,8 +317,8 @@ class Context {
             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);
+            this.logger.warn('Error during script execution with argument', arg);
+            this.logger.error(err);
             throw err;
         }
         function serialize(value) {
@@ -342,7 +340,7 @@ class Context {
         }
     }
     async executePoll(script, arg) {
-        this._logger.log('Executing poll script');
+        this.logger.log('Executing poll script');
         const { main: mainScript, poll: pollScript } = utils.types.isString(script) || utils.types.isFunction(script) ? { main: script, poll: script } : script;
         const { main: mainArg, poll: pollArg, executionTimeout = 60000, pollTimeout = 1000, } = !utils.types.has(arg, ['main', 'poll']) ? { main: arg, poll: arg } : arg;
         let isExecutionTimedOut = false;
@@ -365,7 +363,7 @@ class Context {
                 else if (response.status === 'WIP') {
                     await utils.general.sleep(pollTimeout);
                 }
-                this._logger.log('Polling...');
+                this.logger.log('Polling...');
                 response = deserialize(await this.execute(pollScript, pollArg));
             }
             throw new Error('Poll script execution is timed out');
@@ -402,11 +400,11 @@ class Context {
                 let selector;
                 if (environment.isIOS && !environment.isEmulation) {
                     selector = 'html';
-                    this._logger.log(`Using hardcoded default scrolling element for Safari on iOS - "${selector}"`);
+                    this.logger.log(`Using hardcoded default scrolling element for Safari on iOS - "${selector}"`);
                 }
                 else {
                     selector = await this.execute(snippets.getDocumentScrollingElement);
-                    this._logger.log(`Using dynamic default scrolling element - "${selector}"`);
+                    this.logger.log(`Using dynamic default scrolling element - "${selector}"`);
                 }
                 this._scrollingElement = await this.element({ type: 'css', selector });
             }
@@ -431,8 +429,8 @@ class Context {
             return await this.execute(snippets.blurElement, [element]);
         }
         catch (err) {
-            this._logger.warn('Cannot blur element', element);
-            this._logger.error(err);
+            this.logger.warn('Cannot blur element', element);
+            this.logger.error(err);
             return null;
         }
     }
@@ -441,8 +439,8 @@ class Context {
             return await this.execute(snippets.focusElement, [element]);
         }
         catch (err) {
-            this._logger.warn('Cannot focus element', element);
-            this._logger.error(err);
+            this.logger.warn('Cannot focus element', element);
+            this.logger.error(err);
             return null;
         }
     }
@@ -514,7 +512,7 @@ class Context {
     }
     async getRegionInViewport(region) {
         var _a, _b;
-        this._logger.log('Converting context region to viewport region', region);
+        this.logger.log('Converting context region to viewport region', region);
         if (region)
             region = utils.geometry.offsetNegative(region, await this.getInnerOffset());
         else
@@ -528,7 +526,7 @@ class Context {
             // TODO revisit
             if (environment.isWeb ||
                 (!utils.geometry.equals(contextRegion, region) && utils.geometry.contains(contextRegion, region))) {
-                this._logger.log('Intersecting context region', contextRegion, 'with context region', region);
+                this.logger.log('Intersecting context region', contextRegion, 'with context region', region);
                 region = utils.geometry.intersect(contextRegion, utils.geometry.offset(region, contextRegion));
                 // region = utils.geometry.intersect(contextScrollingRegion, region)
                 region = utils.geometry.offsetNegative(region, parentContextInnerOffset);
@@ -544,7 +542,7 @@ class Context {
             return [];
         await this.focus();
         const cookies = await ((_b = (_a = this._spec).getCookies) === null || _b === void 0 ? void 0 : _b.call(_a, this.target, true));
-        this._logger.log('Extracted context cookies', cookies);
+        this.logger.log('Extracted context cookies', cookies);
         return cookies !== null && cookies !== void 0 ? cookies : [];
     }
     async preserveInnerOffset() {

package/dist/driver.js

@@ -35,25 +35,27 @@ const utils = __importStar(require("@applitools/utils"));
 const snippets = require('@applitools/snippets');
 class Driver {
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g;
         this._state = {};
         this._customConfig = {};
+        this._logger = (0, logger_1.makeLogger)({ logger: options.logger, format: { label: 'driver' } });
         this._customConfig = (_a = options.customConfig) !== null && _a !== void 0 ? _a : {};
         this._guid = utils.general.guid();
         this._spec = options.spec;
-        this._logger = (_c = (_b = options.logger) === null || _b === void 0 ? void 0 : _b.extend({ label: 'driver' })) !== null && _c !== void 0 ? _c : (0, logger_1.makeLogger)({ label: 'driver' });
-        this._target = (_f = (_e = (_d = this._spec).transformDriver) === null || _e === void 0 ? void 0 : _e.call(_d, options.driver)) !== null && _f !== void 0 ? _f : options.driver;
+        this._target = (_d = (_c = (_b = this._spec).transformDriver) === null || _c === void 0 ? void 0 : _c.call(_b, options.driver)) !== null && _d !== void 0 ? _d : options.driver;
         if (!this._spec.isDriver(this._target)) {
             throw new TypeError('Driver constructor called with argument of unknown type!');
         }
         this._mainContext = new context_1.Context({
             spec: this._spec,
-            context: (_j = (_h = (_g = this._spec).extractContext) === null || _h === void 0 ? void 0 : _h.call(_g, this._target)) !== null && _j !== void 0 ? _j : this._target,
+            context: (_g = (_f = (_e = this._spec).extractContext) === null || _f === void 0 ? void 0 : _f.call(_e, this._target)) !== null && _g !== void 0 ? _g : this._target,
             driver: this,
-            logger: this._logger,
         });
         this._currentContext = this._mainContext;
     }
+    get logger() {
+        return this._logger;
+    }
     get target() {
         return this._target;
     }
@@ -66,9 +68,16 @@ class Driver {
     get mainContext() {
         return this._mainContext;
     }
+    updateLogger(logger) {
+        this._logger = logger.extend({ label: 'driver' });
+    }
     updateCurrentContext(context) {
         this._currentContext = context;
     }
+    async reloadPage() {
+        await this.mainContext.execute(snippets.reloadPage).catch(() => null);
+        return this.refresh();
+    }
     async refresh() {
         this._driverInfo = undefined;
         this._environment = undefined;
@@ -393,8 +402,8 @@ class Driver {
             const environment = await this.getEnvironment();
             this._logger.log(`Extracting helper for ${environment.isIOS ? 'ios' : 'android'}`);
             this._helper = environment.isIOS
-                ? await helper_ios_1.HelperIOS.make({ spec: this._spec, driver: this, logger: this._logger })
-                : await helper_android_1.HelperAndroid.make({ spec: this._spec, driver: this, logger: this._logger });
+                ? await helper_ios_1.HelperIOS.make({ spec: this._spec, driver: this })
+                : await helper_android_1.HelperAndroid.make({ spec: this._spec, driver: this });
             this._logger.log(`Extracted helper of type ${(_a = this._helper) === null || _a === void 0 ? void 0 : _a.name}`);
         }
         this._logger.log(`Returning helper for of type ${(_c = (_b = this._helper) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : null}`);
@@ -668,8 +677,8 @@ class Driver {
         let attempt = 0;
         while (attempt++ < 3) {
             const requiredWindowSize = {
-                width: currentWindowSize.width + (requiredViewportSize.width - currentViewportSize.width),
-                height: currentWindowSize.height + (requiredViewportSize.height - currentViewportSize.height),
+                width: Math.max(0, currentWindowSize.width + (requiredViewportSize.width - currentViewportSize.width)),
+                height: Math.max(0, currentWindowSize.height + (requiredViewportSize.height - currentViewportSize.height)),
             };
             this._logger.log(`Attempt #${attempt} to set viewport size by setting window size to`, requiredWindowSize);
             await this._spec.setWindowSize(this.target, requiredWindowSize);
@@ -801,6 +810,8 @@ function isDriver(driver, spec) {
 exports.isDriver = isDriver;
 async function makeDriver(options) {
     const driver = options.driver instanceof Driver ? options.driver : new Driver(options);
+    if (options.logger)
+        driver.updateLogger(options.logger);
     return driver.refresh();
 }
 exports.makeDriver = makeDriver;

package/dist/element.js

@@ -33,7 +33,6 @@ class Element {
         this._state = {};
         this._spec = options.spec;
         this._context = options.context;
-        this._logger = options.logger;
         if (utils.types.has(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;
             if (this._spec.isElement(this._target)) {
@@ -61,6 +60,9 @@ class Element {
             this._commonSelector = null;
         }
     }
+    get logger() {
+        return this._context.logger;
+    }
     get target() {
         return this._target;
     }
@@ -105,13 +107,13 @@ class Element {
             innerElement = innerElement instanceof Element ? innerElement.target : innerElement;
             const environment = await this.driver.getEnvironment();
             if (environment.isWeb) {
-                this._logger.log('Checking if web element with selector', this.selector, 'contains element', innerElement);
+                this.logger.log('Checking if web element with selector', this.selector, 'contains element', innerElement);
                 return false; // TODO implement a snipped for web
             }
             else {
                 if ((_a = this._state.containedElements) === null || _a === void 0 ? void 0 : _a.has(innerElement))
                     return this._state.containedElements.get(innerElement);
-                this._logger.log('Checking if native element with selector', this.selector, 'contains element', innerElement);
+                this.logger.log('Checking if native element with selector', this.selector, 'contains element', innerElement);
                 // appium doesn't have a way to check if an element is contained in another element, so juristic applied
                 if (await this.equals(innerElement))
                     return false;
@@ -124,12 +126,11 @@ class Element {
                 return contains;
             }
         });
-        this._logger.log('Element with selector', this.selector, contains ? 'contains' : `doesn't contain`, innerElement);
+        this.logger.log('Element with selector', this.selector, contains ? 'contains' : `doesn't contain`, innerElement);
         return contains;
     }
     async init(context) {
         this._context = context;
-        this._logger = context._logger;
         if (this._target)
             return this;
         if (this._selector) {
@@ -144,13 +145,13 @@ class Element {
         const region = await this.withRefresh(async () => {
             const environment = await this.driver.getEnvironment();
             if (environment.isWeb) {
-                this._logger.log('Extracting region of web element with selector', this.selector);
+                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);
+                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);
+                this.logger.log('Extracted native region', region);
                 const normalizedRegion = await this.driver.normalizeRegion(region);
                 // if element is a child of scrolling element, then region location should be adjusted
                 const scrollingElement = await this.context.getScrollingElement();
@@ -159,21 +160,21 @@ class Element {
                     : normalizedRegion;
             }
         });
-        this._logger.log('Extracted region', region);
+        this.logger.log('Extracted region', region);
         return region;
     }
     async getClientRegion() {
         const region = await this.withRefresh(async () => {
             const environment = await this.driver.getEnvironment();
             if (environment.isWeb) {
-                this._logger.log('Extracting region of web element with selector', this.selector);
+                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);
+        this.logger.log('Extracted client region', region);
         return region;
     }
     async getContentRegion(options = {}) {
@@ -181,10 +182,10 @@ class Element {
         const environment = await this.driver.getEnvironment();
         if (!environment.isNative)
             return null;
-        this._logger.log('Extracting content region of native element with selector', this.selector);
+        this.logger.log('Extracting content region of native element with selector', this.selector);
         const helper = await this.driver.getHelper();
         let contentRegion = await (helper === null || helper === void 0 ? void 0 : helper.getContentRegion(this, options));
-        this._logger.log('Extracted content region using helper library', contentRegion);
+        this.logger.log('Extracted content region using helper library', contentRegion);
         if (!contentRegion || !environment.isAndroid) {
             let attrContentRegion = null;
             try {
@@ -199,9 +200,9 @@ class Element {
                 };
             }
             catch (err) {
-                this._logger.warn(`Unable to get the attribute 'contentSize' due to the following error: '${err.message}'`);
+                this.logger.warn(`Unable to get the attribute 'contentSize' due to the following error: '${err.message}'`);
             }
-            this._logger.log('Extracted content region using attribute', attrContentRegion);
+            this.logger.log('Extracted content region using attribute', attrContentRegion);
             // ios workaround
             if (!attrContentRegion && environment.isIOS) {
                 try {
@@ -222,9 +223,9 @@ class Element {
                     }
                 }
                 catch (err) {
-                    this._logger.warn(`Unable to calculate content region using iOS workaround due to the following error: '${err.message}'`);
+                    this.logger.warn(`Unable to calculate content region using iOS workaround due to the following error: '${err.message}'`);
                 }
-                this._logger.log('Extracted content region using iOS workaround', attrContentRegion);
+                this.logger.log('Extracted content region using iOS workaround', attrContentRegion);
             }
             if (attrContentRegion) {
                 contentRegion = {
@@ -243,11 +244,11 @@ class Element {
         const size = await this.withRefresh(async () => {
             const environment = await this.driver.getEnvironment();
             if (environment.isWeb) {
-                this._logger.log('Extracting content size of web element with selector', this.selector);
+                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);
+                this.logger.log('Extracting content size of native element with selector', this.selector);
                 try {
                     const contentRegion = await this.getContentRegion(options);
                     this._state.contentSize = utils.geometry.size(contentRegion);
@@ -261,17 +262,17 @@ class Element {
                     return this._state.contentSize;
                 }
                 catch (err) {
-                    this._logger.warn('Failed to extract content size, extracting client size instead');
-                    this._logger.error(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);
+        this.logger.log('Extracted content size', size);
         return size;
     }
     async isPager() {
-        this._logger.log('Check if element with selector', this.selector, 'is scrollable by pages');
+        this.logger.log('Check if element with selector', this.selector, 'is scrollable by pages');
         const isPager = await this.withRefresh(async () => {
             const environment = await this.driver.getEnvironment();
             if (environment.isAndroid) {
@@ -282,11 +283,11 @@ class Element {
                 return false;
             }
         });
-        this._logger.log('Element scrollable by pages', isPager);
+        this.logger.log('Element scrollable by pages', isPager);
         return isPager;
     }
     async isScrollable() {
-        this._logger.log('Check if element with selector', this.selector, 'is scrollable');
+        this.logger.log('Check if element with selector', this.selector, 'is scrollable');
         const isScrollable = await this.withRefresh(async () => {
             const environment = await this.driver.getEnvironment();
             if (environment.isWeb) {
@@ -301,7 +302,7 @@ class Element {
                 return ['XCUIElementTypeScrollView', 'XCUIElementTypeTable', 'XCUIElementTypeCollectionView'].includes(type);
             }
         });
-        this._logger.log('Element is scrollable', isScrollable);
+        this.logger.log('Element is scrollable', isScrollable);
         return isScrollable;
     }
     async isRoot() {
@@ -336,18 +337,18 @@ class Element {
                 const helper = await this.driver.getHelper();
                 if ((helper === null || helper === void 0 ? void 0 : helper.name) === 'android') {
                     this._state.touchPadding = await helper.getTouchPadding();
-                    this._logger.log('Touch padding extracted using helper library', this._state.touchPadding);
+                    this.logger.log('Touch padding extracted using helper library', this._state.touchPadding);
                 }
                 if (!this._state.touchPadding) {
                     this._state.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.logger.warn(`Unable to get the attribute 'contentSize' when looking up 'touchPadding' due to the following error: '${err.message}'`);
                     });
-                    this._logger.log('Touch padding extracted using attribute', this._state.touchPadding);
+                    this.logger.log('Touch padding extracted using attribute', this._state.touchPadding);
                 }
                 (_a = (_b = this._state).touchPadding) !== null && _a !== void 0 ? _a : (_b.touchPadding = 20);
-                this._logger.log('Touch padding set:', this._state.touchPadding);
+                this.logger.log('Touch padding set:', this._state.touchPadding);
             }
         }
         return this._state.touchPadding;
@@ -359,11 +360,11 @@ class Element {
                 return '';
             }
             else {
-                this._logger.log('Extracting text of native element with selector', this.selector);
+                this.logger.log('Extracting text of native element with selector', this.selector);
                 return this._spec.getElementText(this.context.target, this.target);
             }
         });
-        this._logger.log('Extracted element text', text);
+        this.logger.log('Extracted element text', text);
         return text;
     }
     async getAttribute(name) {
@@ -383,7 +384,7 @@ class Element {
                 return properties[name];
             }
             else {
-                this._logger.log(`Extracting "${name}" attribute of native element with selector`, this.selector);
+                this.logger.log(`Extracting "${name}" attribute of native element with selector`, this.selector);
                 (_a = (_b = this._state).attributes) !== null && _a !== void 0 ? _a : (_b.attributes = {});
                 try {
                     this._state.attributes[name] = await this._spec.getElementAttribute(this.driver.target, this.target, name);
@@ -396,7 +397,7 @@ class Element {
                 finally {
                     if (environment.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');
+                        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);
@@ -404,7 +405,7 @@ class Element {
                 }
             }
         });
-        this._logger.log(`Extracted element "${name}" attribute:`, value);
+        this.logger.log(`Extracted element "${name}" attribute:`, value);
         return value;
     }
     async setAttribute(name, value) {
@@ -415,7 +416,7 @@ class Element {
     }
     async scrollTo(offset, options) {
         return this.withRefresh(async () => {
-            this._logger.log(`Scrolling to offset (${offset.x}, ${offset.y}) element with selector`, this.selector);
+            this.logger.log(`Scrolling to offset (${offset.x}, ${offset.y}) element with selector`, this.selector);
             offset = utils.geometry.round({ x: Math.max(offset.x, 0), y: Math.max(offset.y, 0) });
             const environment = await this.driver.getEnvironment();
             if (environment.isWeb) {
@@ -625,12 +626,12 @@ class Element {
     }
     async click() {
         var _a, _b;
-        this._logger.log(`Clicking on the element with selector`, this.selector);
+        this.logger.log(`Clicking on the element with selector`, this.selector);
         await ((_b = (_a = this._spec).click) === null || _b === void 0 ? void 0 : _b.call(_a, this.context.target, this.target));
     }
     async type(value) {
         var _a, _b;
-        this._logger.log(`Typing text "${value}" in the element with selector`, this.selector);
+        this.logger.log(`Typing text "${value}" in the element with selector`, this.selector);
         await ((_b = (_a = this._spec).setElementText) === null || _b === void 0 ? void 0 : _b.call(_a, this.context.target, this.target, value));
     }
     async preserveState() {

package/dist/helper-android.js

@@ -32,7 +32,7 @@ const gte_1 = __importDefault(require("semver/functions/gte"));
 class HelperAndroid {
     static async make(options) {
         var _a;
-        const { spec, driver, logger } = options;
+        const { spec, driver } = options;
         let legacy = false;
         let input = await driver.element({ type: 'xpath', selector: '//*[@content-desc="EyesAppiumHelperEDT"]' });
         if (!input) {
@@ -50,10 +50,10 @@ class HelperAndroid {
         return input
             ? new HelperAndroid({
                 spec,
+                driver,
                 input,
                 action,
                 legacy,
-                logger,
                 supportAsync: (0, gte_1.default)(version, '1.8.0'),
             })
             : null;
@@ -61,13 +61,16 @@ class HelperAndroid {
     constructor(options) {
         this._supportAsync = false;
         this._spec = options.spec;
+        this._driver = options.driver;
         this._input = options.input;
         this._action = options.action;
         this._legacy = options.legacy;
-        this._logger = options.logger;
         this.name = this._legacy ? 'android-legacy' : 'android';
         this._supportAsync = options.supportAsync === true;
     }
+    get logger() {
+        return this._driver.logger;
+    }
     async _getElementId(element) {
         const resourceId = await element.getAttribute('resource-id');
         if (!resourceId)
@@ -90,7 +93,7 @@ class HelperAndroid {
             text = await this._input.getText();
         }
         if (text === 'WAIT') {
-            this._logger.warn(`Helper library didn't provide a response for async command (${command}) during ${timeout}ms`);
+            this.logger.warn(`Helper library didn't provide a response for async command (${command}) during ${timeout}ms`);
             text = '';
         }
         return text;

package/dist/helper-ios.js

@@ -3,17 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HelperIOS = void 0;
 class HelperIOS {
     static async make(options) {
-        const { spec, driver, logger } = options;
+        const { spec, driver } = options;
         const element = await driver.element({ type: 'name', selector: 'applitools_grab_scrollable_data_button' });
-        return element ? new HelperIOS({ driver, element, spec, logger }) : null;
+        return element ? new HelperIOS({ driver, element, spec }) : null;
     }
     constructor(options) {
         this._driver = options.driver;
         this._element = options.element;
         this._spec = options.spec;
-        this._logger = options.logger;
         this.name = 'ios';
     }
+    get logger() {
+        return this._driver.logger;
+    }
     async getContentRegion(element) {
         var _a, _b;
         await this._element.click();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/driver",
-  "version": "1.11.50",
+  "version": "1.11.52",
   "description": "Applitools universal framework wrapper",
   "keywords": [
     "applitools",
@@ -81,9 +81,9 @@
     "postversion": "bongo postversion"
   },
   "dependencies": {
-    "@applitools/logger": "1.1.52",
-    "@applitools/snippets": "2.4.19",
-    "@applitools/utils": "1.3.35",
+    "@applitools/logger": "2.0.0",
+    "@applitools/snippets": "2.4.20",
+    "@applitools/utils": "1.3.36",
     "semver": "7.3.7"
   },
   "devDependencies": {

package/types/context.d.ts

@@ -1,6 +1,5 @@
 import type { Location, Size, Region } from '@applitools/utils';
 import type { Cookie } from './types';
-import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver, type WaitOptions } from './spec-driver';
 import { type Driver } from './driver';
 import { type Selector } from './selector';
@@ -19,7 +18,6 @@ type ContextOptions<T extends SpecType> = {
     reference?: ContextReference<T>;
     element?: Element<T>;
     scrollingElement?: Element<T>;
-    logger: Logger;
 };
 export declare class Context<T extends SpecType> {
     private _target?;
@@ -29,10 +27,10 @@ export declare class Context<T extends SpecType> {
     private _reference?;
     private _scrollingElement?;
     private _state;
-    private _logger;
     private _isReference;
     protected readonly _spec: SpecDriver<T>;
     constructor(options: ContextOptions<T>);
+    get logger(): import("@applitools/logger").Logger;
     get target(): T['driver'];
     get driver(): Driver<T>;
     get parent(): Context<T> | null;

package/types/driver.d.ts

@@ -31,11 +31,14 @@ export declare class Driver<T extends SpecType> {
     private _logger;
     protected readonly _spec: SpecDriver<T>;
     constructor(options: DriverOptions<T>);
+    get logger(): Logger;
     get target(): T['driver'];
     get guid(): string;
     get currentContext(): Context<T>;
     get mainContext(): Context<T>;
+    updateLogger(logger: Logger): void;
     updateCurrentContext(context: Context<T>): void;
+    reloadPage(): Promise<this>;
     refresh(): Promise<this>;
     getDriverInfo({ force }?: {
         force?: boolean;

package/types/element.d.ts

@@ -1,5 +1,4 @@
 import type { Location, Size, Region } from '@applitools/utils';
-import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from './spec-driver';
 import { type Context } from './context';
 import { type Selector, type CommonSelector } from './selector';
@@ -15,7 +14,6 @@ type ElementState = {
 type ElementOptions<T extends SpecType> = {
     spec: SpecDriver<T>;
     context?: Context<T>;
-    logger: Logger;
 } & ({
     element: T['element'];
     selector?: Selector<T>;
@@ -32,9 +30,9 @@ export declare class Element<T extends SpecType> {
     private _index?;
     private _state;
     private _originalOverflow;
-    private _logger;
     protected readonly _spec: SpecDriver<T>;
     constructor(options: ElementOptions<T>);
+    get logger(): import("@applitools/logger").Logger;
     get target(): NonNullable<T["element"]>;
     get selector(): Selector<T> | undefined;
     get commonSelector(): CommonSelector | null;

package/types/helper-android.d.ts

@@ -1,5 +1,4 @@
 import type { Location, Region } from '@applitools/utils';
-import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from './spec-driver';
 import { type Driver } from './driver';
 import { type Element } from './element';
@@ -7,23 +6,23 @@ export declare class HelperAndroid<T extends SpecType> {
     static make<T extends SpecType>(options: {
         spec: SpecDriver<T>;
         driver: Driver<T>;
-        logger: Logger;
     }): Promise<HelperAndroid<T> | null>;
     private readonly _spec;
+    private readonly _driver;
     private readonly _input;
     private readonly _action;
     private readonly _legacy;
     private readonly _supportAsync;
-    private _logger;
     readonly name: 'android' | 'android-legacy';
     constructor(options: {
         spec: SpecDriver<T>;
+        driver: Driver<T>;
         input: Element<T>;
         action: Element<T> | null;
         legacy: boolean;
         supportAsync: boolean;
-        logger: Logger;
     });
+    get logger(): import("@applitools/logger").Logger;
     private _getElementId;
     private _command;
     getContentRegion(element: Element<T>, options?: {

package/types/helper-ios.d.ts

@@ -1,5 +1,4 @@
 import type { Region } from '@applitools/utils';
-import { type Logger } from '@applitools/logger';
 import { type SpecType, type SpecDriver } from './spec-driver';
 import { type Driver } from './driver';
 import { type Element } from './element';
@@ -7,18 +6,16 @@ export declare class HelperIOS<T extends SpecType> {
     static make<T extends SpecType>(options: {
         spec: SpecDriver<T>;
         driver: Driver<T>;
-        logger: Logger;
     }): Promise<HelperIOS<T> | null>;
-    private readonly _driver;
     private readonly _element;
+    private readonly _driver;
     private readonly _spec;
-    private _logger;
     readonly name: 'ios';
     constructor(options: {
         driver: Driver<T>;
         element: Element<T>;
         spec: SpecDriver<T>;
-        logger: Logger;
     });
+    get logger(): import("@applitools/logger").Logger;
     getContentRegion(element: Element<T>): Promise<Region | null>;
 }