webdriverio 7.17.0 → 7.17.3

package/build/commands/element/getText.d.ts

@@ -0,0 +1,42 @@
+/**
+ *
+ * Get the text content from a DOM-element. Make sure the element
+ * you want to request the text from [is interactable](http://www.w3.org/TR/webdriver/#interactable)
+ * otherwise you will get an empty string as return value. If the element is disabled or not
+ * visible and you still want to receive the text content use [getHTML](https://webdriver.io/docs/api/element/getHTML)
+ * as a workaround.
+ *
+ * <example>
+    :index.html
+    <div id="elem">
+        Lorem ipsum <strong>dolor</strong> sit amet,<br />
+        consetetur sadipscing elitr
+    </div>
+    <span style="display: none">I am invisible</span>
+    :getText.js
+    it('should demonstrate the getText function', async () => {
+        const elem = await $('#elem');
+        console.log(await elem.getText());
+        // outputs the following:
+        // "Lorem ipsum dolor sit amet,consetetur sadipscing elitr"
+
+        const span = await $('span');
+        console.log(await span.getText());
+        // outputs "" (empty string) since element is not interactable
+    });
+    it('get content from table cell', async () => {
+        await browser.url('http://the-internet.herokuapp.com/tables');
+        const rows = await $$('#table1 tr');
+        const columns = await rows[1].$$('td'); // get columns of 2nd row
+        console.log(await columns[2].getText()); // get text of 3rd column
+    });
+ * </example>
+ *
+ * @alias element.getText
+ * @return {String} content of selected element (all HTML tags are removed)
+ * @uses protocol/elements, protocol/elementIdText
+ * @type property
+ *
+ */
+export default function getText(this: WebdriverIO.Element): Promise<string>;
+//# sourceMappingURL=getText.d.ts.map

package/build/commands/element/getText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getText.d.ts","sourceRoot":"","sources":["../../../src/commands/element/getText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,OAAO,UAAU,OAAO,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,mBAEzD"}

package/build/commands/element/getText.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ *
+ * Get the text content from a DOM-element. Make sure the element
+ * you want to request the text from [is interactable](http://www.w3.org/TR/webdriver/#interactable)
+ * otherwise you will get an empty string as return value. If the element is disabled or not
+ * visible and you still want to receive the text content use [getHTML](https://webdriver.io/docs/api/element/getHTML)
+ * as a workaround.
+ *
+ * <example>
+    :index.html
+    <div id="elem">
+        Lorem ipsum <strong>dolor</strong> sit amet,<br />
+        consetetur sadipscing elitr
+    </div>
+    <span style="display: none">I am invisible</span>
+    :getText.js
+    it('should demonstrate the getText function', async () => {
+        const elem = await $('#elem');
+        console.log(await elem.getText());
+        // outputs the following:
+        // "Lorem ipsum dolor sit amet,consetetur sadipscing elitr"
+
+        const span = await $('span');
+        console.log(await span.getText());
+        // outputs "" (empty string) since element is not interactable
+    });
+    it('get content from table cell', async () => {
+        await browser.url('http://the-internet.herokuapp.com/tables');
+        const rows = await $$('#table1 tr');
+        const columns = await rows[1].$$('td'); // get columns of 2nd row
+        console.log(await columns[2].getText()); // get text of 3rd column
+    });
+ * </example>
+ *
+ * @alias element.getText
+ * @return {String} content of selected element (all HTML tags are removed)
+ * @uses protocol/elements, protocol/elementIdText
+ * @type property
+ *
+ */
+function getText() {
+    return this.getElementText(this.elementId);
+}
+exports.default = getText;

package/build/commands/element/getValue.d.ts

@@ -0,0 +1,25 @@
+/**
+ *
+ * Get the value of a `<textarea>`, `<select>` or text `<input>` found by given selector.
+ * If multiple elements are found via the given selector, an array of values is returned instead.
+ * For input with checkbox or radio type use isSelected.
+ *
+ * <example>
+    :index.html
+    <input type="text" value="John Doe" id="username">
+    :getValue.js
+    it('should demonstrate the getValue command', async () => {
+        const inputUser = await $('#username');
+        const value = await inputUser.getValue();
+        console.log(value); // outputs: "John Doe"
+    });
+ * </example>
+ *
+ * @alias element.getValue
+ * @return {String}  requested element(s) value
+ * @uses protocol/elements, protocol/elementIdProperty
+ * @type property
+ *
+ */
+export default function getValue(this: WebdriverIO.Element): Promise<string>;
+//# sourceMappingURL=getValue.d.ts.map

package/build/commands/element/getValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getValue.d.ts","sourceRoot":"","sources":["../../../src/commands/element/getValue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,mBAO1D"}

package/build/commands/element/getValue.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ *
+ * Get the value of a `<textarea>`, `<select>` or text `<input>` found by given selector.
+ * If multiple elements are found via the given selector, an array of values is returned instead.
+ * For input with checkbox or radio type use isSelected.
+ *
+ * <example>
+    :index.html
+    <input type="text" value="John Doe" id="username">
+    :getValue.js
+    it('should demonstrate the getValue command', async () => {
+        const inputUser = await $('#username');
+        const value = await inputUser.getValue();
+        console.log(value); // outputs: "John Doe"
+    });
+ * </example>
+ *
+ * @alias element.getValue
+ * @return {String}  requested element(s) value
+ * @uses protocol/elements, protocol/elementIdProperty
+ * @type property
+ *
+ */
+function getValue() {
+    // `!this.isMobile` added to workaround https://github.com/appium/appium/issues/12218
+    if (this.isW3C && !this.isMobile) {
+        return this.getElementProperty(this.elementId, 'value');
+    }
+    return this.getElementAttribute(this.elementId, 'value');
+}
+exports.default = getValue;

package/build/commands/element/isClickable.d.ts

@@ -0,0 +1,40 @@
+/**
+ *
+ * Return true if the selected DOM-element:
+ *
+ * - exists
+ * - is visible
+ * - is within viewport (if not try scroll to it)
+ * - its center is not overlapped with another element
+ * - is not disabled
+ *
+ * otherwise return false.
+ *
+ * :::info
+ *
+ * Please note that `isClickable` works only in web browser and in mobile webviews,
+ * it doesn't work in mobile app native context. Also, As opposed to other element
+ * commands WebdriverIO will not wait for the element to exist to execute this command.
+ *
+ * :::
+ *
+ * <example>
+    :isClickable.js
+    it('should detect if an element is clickable', async () => {
+        const el = await $('#el')
+        let clickable = await el.isClickable();
+        console.log(clickable); // outputs: true or false
+
+        // wait for element to be clickable
+        await browser.waitUntil(() => el.isClickable())
+    });
+ * </example>
+ *
+ * @alias element.isClickable
+ * @return {Boolean}            true if element is clickable
+ * @uses protocol/selectorExecute, protocol/timeoutsAsyncScript
+ * @type state
+ *
+ */
+export default function isClickable(this: WebdriverIO.Element): Promise<boolean>;
+//# sourceMappingURL=isClickable.d.ts.map

package/build/commands/element/isClickable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isClickable.d.ts","sourceRoot":"","sources":["../../../src/commands/element/isClickable.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAA8B,WAAW,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,oBAUnE"}

package/build/commands/element/isClickable.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const utils_1 = require("../../utils");
+const isElementClickable_1 = __importDefault(require("../../scripts/isElementClickable"));
+/**
+ *
+ * Return true if the selected DOM-element:
+ *
+ * - exists
+ * - is visible
+ * - is within viewport (if not try scroll to it)
+ * - its center is not overlapped with another element
+ * - is not disabled
+ *
+ * otherwise return false.
+ *
+ * :::info
+ *
+ * Please note that `isClickable` works only in web browser and in mobile webviews,
+ * it doesn't work in mobile app native context. Also, As opposed to other element
+ * commands WebdriverIO will not wait for the element to exist to execute this command.
+ *
+ * :::
+ *
+ * <example>
+    :isClickable.js
+    it('should detect if an element is clickable', async () => {
+        const el = await $('#el')
+        let clickable = await el.isClickable();
+        console.log(clickable); // outputs: true or false
+
+        // wait for element to be clickable
+        await browser.waitUntil(() => el.isClickable())
+    });
+ * </example>
+ *
+ * @alias element.isClickable
+ * @return {Boolean}            true if element is clickable
+ * @uses protocol/selectorExecute, protocol/timeoutsAsyncScript
+ * @type state
+ *
+ */
+async function isClickable() {
+    if (!await this.isDisplayed()) {
+        return false;
+    }
+    const browser = (0, utils_1.getBrowserObject)(this);
+    return browser.execute(isElementClickable_1.default, {
+        [constants_1.ELEMENT_KEY]: this.elementId,
+        ELEMENT: this.elementId // jsonwp compatible
+    });
+}
+exports.default = isClickable;

package/build/commands/element/isDisplayed.d.ts

@@ -0,0 +1,50 @@
+/**
+ *
+ * Return true if the selected DOM-element is displayed.
+ *
+ * :::info
+ *
+ * As opposed to other element commands WebdriverIO will not wait for the element
+ * to exist to execute this command.
+ *
+ * :::
+ *
+ * <example>
+    :index.html
+    <div id="notDisplayed" style="display: none"></div>
+    <div id="notVisible" style="visibility: hidden"></div>
+    <div id="notInViewport" style="position:absolute; left: 9999999"></div>
+    <div id="zeroOpacity" style="opacity: 0"></div>
+    :isDisplayed.js
+    it('should detect if an element is displayed', async () => {
+        let elem = await $('#notDisplayed');
+        let isDisplayed = await elem.isDisplayed();
+        console.log(isDisplayed); // outputs: false
+
+        elem = await $('#notVisible');
+
+        isDisplayed = await elem.isDisplayed();
+        console.log(isDisplayed); // outputs: false
+
+        elem = await $('#notExisting');
+        isDisplayed = await elem.isDisplayed();
+        console.log(isDisplayed); // outputs: false
+
+        elem = await $('#notInViewport');
+        isDisplayed = await elem.isDisplayed();
+        console.log(isDisplayed); // outputs: true
+
+        elem = await $('#zeroOpacity');
+        isDisplayed = await elem.isDisplayed();
+        console.log(isDisplayed); // outputs: true
+    });
+ * </example>
+ *
+ * @alias element.isDisplayed
+ * @return {Boolean} true if element is displayed
+ * @uses protocol/elements, protocol/elementIdDisplayed
+ * @type state
+ *
+ */
+export default function isDisplayed(this: WebdriverIO.Element): Promise<boolean>;
+//# sourceMappingURL=isDisplayed.d.ts.map

package/build/commands/element/isDisplayed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDisplayed.d.ts","sourceRoot":"","sources":["../../../src/commands/element/isDisplayed.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAA8B,WAAW,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,oBAgCnE"}

package/build/commands/element/isDisplayed.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const utils_1 = require("../../utils");
+const isElementDisplayed_1 = __importDefault(require("../../scripts/isElementDisplayed"));
+const noW3CEndpoint = ['microsoftedge', 'msedge', 'safari', 'chrome', 'safari technology preview'];
+/**
+ *
+ * Return true if the selected DOM-element is displayed.
+ *
+ * :::info
+ *
+ * As opposed to other element commands WebdriverIO will not wait for the element
+ * to exist to execute this command.
+ *
+ * :::
+ *
+ * <example>
+    :index.html
+    <div id="notDisplayed" style="display: none"></div>
+    <div id="notVisible" style="visibility: hidden"></div>
+    <div id="notInViewport" style="position:absolute; left: 9999999"></div>
+    <div id="zeroOpacity" style="opacity: 0"></div>
+    :isDisplayed.js
+    it('should detect if an element is displayed', async () => {
+        let elem = await $('#notDisplayed');
+        let isDisplayed = await elem.isDisplayed();
+        console.log(isDisplayed); // outputs: false
+
+        elem = await $('#notVisible');
+
+        isDisplayed = await elem.isDisplayed();
+        console.log(isDisplayed); // outputs: false
+
+        elem = await $('#notExisting');
+        isDisplayed = await elem.isDisplayed();
+        console.log(isDisplayed); // outputs: false
+
+        elem = await $('#notInViewport');
+        isDisplayed = await elem.isDisplayed();
+        console.log(isDisplayed); // outputs: true
+
+        elem = await $('#zeroOpacity');
+        isDisplayed = await elem.isDisplayed();
+        console.log(isDisplayed); // outputs: true
+    });
+ * </example>
+ *
+ * @alias element.isDisplayed
+ * @return {Boolean} true if element is displayed
+ * @uses protocol/elements, protocol/elementIdDisplayed
+ * @type state
+ *
+ */
+async function isDisplayed() {
+    var _a;
+    const browser = (0, utils_1.getBrowserObject)(this);
+    if (!await (0, utils_1.hasElementId)(this)) {
+        return false;
+    }
+    /*
+     * https://www.w3.org/TR/webdriver/#element-displayedness
+     * Certain drivers have decided to remove the endpoint as the spec
+     * no longer dictates it. In those instances, we pass the element through a script
+     * that was provided by Brian Burg, maintainer of Safaridriver.
+     *
+     * 6th of May 2019 APPIUM response (mykola-mokhnach) :
+     * - Appium didn't enable W3C mode for mobile drivers.
+     * - Safari and Chrome work in jsonwp mode and Appium just rewrites W3C requests from upstream to jsonwp if needed
+     */
+    const useAtom = (await browser.isDevTools ||
+        (await browser.isW3C &&
+            !browser.isMobile &&
+            noW3CEndpoint.includes((_a = browser.capabilities.browserName) === null || _a === void 0 ? void 0 : _a.toLowerCase())));
+    return useAtom
+        ? await browser.execute(isElementDisplayed_1.default, {
+            [constants_1.ELEMENT_KEY]: this.elementId,
+            ELEMENT: this.elementId // jsonwp compatible
+        }) :
+        await this.isElementDisplayed(this.elementId);
+}
+exports.default = isDisplayed;

package/build/commands/element/isDisplayedInViewport.d.ts

@@ -0,0 +1,38 @@
+/**
+ *
+ * Return true if the selected DOM-element found by given selector is partially visible and within the viewport.
+ *
+ * <example>
+    :index.html
+    <div id="notDisplayed" style="display: none"></div>
+    <div id="notVisible" style="visibility: hidden"></div>
+    <div id="notInViewport" style="position:absolute; left: 9999999"></div>
+    <div id="zeroOpacity" style="opacity: 0"></div>
+    :isDisplayedInViewport.js
+    :isDisplayed.js
+    it('should detect if an element is visible', async () => {
+        let isDisplayedInViewport = await $('#notDisplayed').isDisplayedInViewport();
+        console.log(isDisplayedInViewport); // outputs: false
+
+        isDisplayedInViewport = await $('#notVisible').isDisplayedInViewport();
+        console.log(isDisplayedInViewport); // outputs: false
+
+        isDisplayedInViewport = await $('#notExisting').isDisplayedInViewport();
+        console.log(isDisplayedInViewport); // outputs: false
+
+        isDisplayedInViewport = await $('#notInViewport').isDisplayedInViewport();
+        console.log(isDisplayedInViewport); // outputs: false
+
+        isDisplayedInViewport = await $('#zeroOpacity').isDisplayedInViewport();
+        console.log(isDisplayedInViewport); // outputs: false
+    });
+ * </example>
+ *
+ * @alias element.isDisplayedInViewport
+ * @return {Boolean}            true if element(s)* [is|are] displayed
+ * @uses protocol/selectorExecute, protocol/timeoutsAsyncScript
+ * @type state
+ *
+ */
+export default function isDisplayedInViewport(this: WebdriverIO.Element): Promise<boolean>;
+//# sourceMappingURL=isDisplayedInViewport.d.ts.map

package/build/commands/element/isDisplayedInViewport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDisplayedInViewport.d.ts","sourceRoot":"","sources":["../../../src/commands/element/isDisplayedInViewport.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAA8B,qBAAqB,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,oBAU7E"}

package/build/commands/element/isDisplayedInViewport.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const utils_1 = require("../../utils");
+const isElementInViewport_1 = __importDefault(require("../../scripts/isElementInViewport"));
+/**
+ *
+ * Return true if the selected DOM-element found by given selector is partially visible and within the viewport.
+ *
+ * <example>
+    :index.html
+    <div id="notDisplayed" style="display: none"></div>
+    <div id="notVisible" style="visibility: hidden"></div>
+    <div id="notInViewport" style="position:absolute; left: 9999999"></div>
+    <div id="zeroOpacity" style="opacity: 0"></div>
+    :isDisplayedInViewport.js
+    :isDisplayed.js
+    it('should detect if an element is visible', async () => {
+        let isDisplayedInViewport = await $('#notDisplayed').isDisplayedInViewport();
+        console.log(isDisplayedInViewport); // outputs: false
+
+        isDisplayedInViewport = await $('#notVisible').isDisplayedInViewport();
+        console.log(isDisplayedInViewport); // outputs: false
+
+        isDisplayedInViewport = await $('#notExisting').isDisplayedInViewport();
+        console.log(isDisplayedInViewport); // outputs: false
+
+        isDisplayedInViewport = await $('#notInViewport').isDisplayedInViewport();
+        console.log(isDisplayedInViewport); // outputs: false
+
+        isDisplayedInViewport = await $('#zeroOpacity').isDisplayedInViewport();
+        console.log(isDisplayedInViewport); // outputs: false
+    });
+ * </example>
+ *
+ * @alias element.isDisplayedInViewport
+ * @return {Boolean}            true if element(s)* [is|are] displayed
+ * @uses protocol/selectorExecute, protocol/timeoutsAsyncScript
+ * @type state
+ *
+ */
+async function isDisplayedInViewport() {
+    if (!await this.isDisplayed()) {
+        return false;
+    }
+    const browser = (0, utils_1.getBrowserObject)(this);
+    return browser.execute(isElementInViewport_1.default, {
+        [constants_1.ELEMENT_KEY]: this.elementId,
+        ELEMENT: this.elementId // jsonwp compatible
+    });
+}
+exports.default = isDisplayedInViewport;

package/build/commands/element/isEnabled.d.ts

@@ -0,0 +1,34 @@
+/**
+ *
+ * Return true or false if the selected DOM-element is enabled.
+ *
+ * <example>
+    :index.html
+    <input type="text" name="inputField" class="input1">
+    <input type="text" name="inputField" class="input2" disabled>
+    <input type="text" name="inputField" class="input3" disabled="disabled">
+
+    :isEnabled.js
+    it('should detect if an element is enabled', async () => {
+        let elem = await $('.input1')
+        let isEnabled = await elem.isEnabled();
+        console.log(isEnabled); // outputs: true
+
+        elem = await $('.input2')
+        isEnabled = await elem.isEnabled();
+        console.log(isEnabled2); // outputs: false
+
+        elem = await $('.input3')
+        isEnabled = await elem.isEnabled();
+        console.log(isEnabled3); // outputs: false
+    });
+ * </example>
+ *
+ * @alias element.isEnabled
+ * @return {Boolean} true if element(s)* (is|are) enabled
+ * @uses protocol/elements, protocol/elementIdEnabled
+ * @type state
+ *
+ */
+export default function isEnabled(this: WebdriverIO.Element): Promise<boolean>;
+//# sourceMappingURL=isEnabled.d.ts.map

package/build/commands/element/isEnabled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEnabled.d.ts","sourceRoot":"","sources":["../../../src/commands/element/isEnabled.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,oBAE3D"}

package/build/commands/element/isEnabled.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ *
+ * Return true or false if the selected DOM-element is enabled.
+ *
+ * <example>
+    :index.html
+    <input type="text" name="inputField" class="input1">
+    <input type="text" name="inputField" class="input2" disabled>
+    <input type="text" name="inputField" class="input3" disabled="disabled">
+
+    :isEnabled.js
+    it('should detect if an element is enabled', async () => {
+        let elem = await $('.input1')
+        let isEnabled = await elem.isEnabled();
+        console.log(isEnabled); // outputs: true
+
+        elem = await $('.input2')
+        isEnabled = await elem.isEnabled();
+        console.log(isEnabled2); // outputs: false
+
+        elem = await $('.input3')
+        isEnabled = await elem.isEnabled();
+        console.log(isEnabled3); // outputs: false
+    });
+ * </example>
+ *
+ * @alias element.isEnabled
+ * @return {Boolean} true if element(s)* (is|are) enabled
+ * @uses protocol/elements, protocol/elementIdEnabled
+ * @type state
+ *
+ */
+function isEnabled() {
+    return this.isElementEnabled(this.elementId);
+}
+exports.default = isEnabled;

package/build/commands/element/isEqual.d.ts

@@ -0,0 +1,24 @@
+/**
+ *
+ * Return true if the selected element matches with the provided one.
+ *
+ * <example>
+    :isEqual.js
+    it('should detect if an element is clickable', async () => {
+        const el = await $('#el')
+        const sameEl = await $('#el')
+        const anotherEl = await $('#anotherEl')
+
+        el.isEqual(sameEl) // outputs: true
+
+        el.isEqual(anotherEl) // outputs: false
+    });
+ * </example>
+ *
+ * @alias element.isEqual
+ * @param   {Element}   el element to compare with
+ * @return  {Boolean}   true if elements are equal
+ *
+ */
+export default function isEqual(this: WebdriverIO.Element, el: WebdriverIO.Element): Promise<boolean>;
+//# sourceMappingURL=isEqual.d.ts.map

package/build/commands/element/isEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEqual.d.ts","sourceRoot":"","sources":["../../../src/commands/element/isEqual.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAA8B,OAAO,CACjC,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,EAAE,EAAE,WAAW,CAAC,OAAO,oBAwB1B"}

package/build/commands/element/isEqual.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const utils_1 = require("../../utils");
+const getWebElement = (el) => ({
+    [constants_1.ELEMENT_KEY]: el.elementId,
+    ELEMENT: el.elementId // jsonwp compatible
+});
+/**
+ *
+ * Return true if the selected element matches with the provided one.
+ *
+ * <example>
+    :isEqual.js
+    it('should detect if an element is clickable', async () => {
+        const el = await $('#el')
+        const sameEl = await $('#el')
+        const anotherEl = await $('#anotherEl')
+
+        el.isEqual(sameEl) // outputs: true
+
+        el.isEqual(anotherEl) // outputs: false
+    });
+ * </example>
+ *
+ * @alias element.isEqual
+ * @param   {Element}   el element to compare with
+ * @return  {Boolean}   true if elements are equal
+ *
+ */
+async function isEqual(el) {
+    const browser = (0, utils_1.getBrowserObject)(this);
+    // mobile native
+    if (browser.isMobile) {
+        const context = await browser.getContext();
+        if (context === null || context === void 0 ? void 0 : context.toLowerCase().includes('native')) {
+            return this.elementId === el.elementId;
+        }
+    }
+    // browser or webview
+    let result;
+    try {
+        result = await browser.execute(
+        /* istanbul ignore next */
+        (el1, el2) => el1 === el2, getWebElement(this), getWebElement(el));
+    }
+    catch (err) {
+        result = false;
+    }
+    return result;
+}
+exports.default = isEqual;