webdriverio 7.16.16 → 7.17.0

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

@@ -1,54 +0,0 @@
-import type { TouchActions } from '../../types';
-/**
- *
- * The Touch Action API provides the basis of all gestures that can be automated in Appium.
- * It is currently only available to native apps and can not be used to interact with webapps.
- * At its core is the ability to chain together _ad hoc_ individual actions, which will then be
- * applied to an element in the application on the device. The basic actions that can be used are:
- *
- * - press (pass element or (x,y) or both)
- * - longPress (pass element or (x,y) or both)
- * - tap (pass element or (x,y) or both)
- * - moveTo (pass absolute x,y coordinates)
- * - wait (pass ms (as milliseconds))
- * - release (no arguments)
- *
- * <example>
-    :touchAction.js
-    it('should do a touch gesture', async () => {
-        const screen = await $('//UITextbox');
-
-        // simple touch action on element
-        await screen.touchAction('tap');
-
-        // simple touch action using selector and x y variables
-        // tap location is 30px right and 20px down relative from the center of the element
-        await screen.touchAction({
-            action: 'tap', x: 30, y:20
-        })
-
-        // multi action on an element (drag&drop)
-        await screen.touchAction([
-            'press',
-            { action: 'moveTo', x: 200, y: 300 },
-            'release'
-        ])
-
-        // drag&drop to element
-        const otherElement = await $('//UIAApplication[1]/UIAElement[2]')
-        await screen.touchAction([
-            'press',
-            { action: 'moveTo', element: otherElement },
-            'release'
-        ])
-    });
- * </example>
- *
- * @param {TouchActions} action    action to execute
- *
- * @see https://saucelabs.com/blog/appium-sauce-labs-bootcamp-chapter-2-touch-actions
- * @for android, ios
- *
- */
-export default function touchAction(this: WebdriverIO.Element, actions: TouchActions): Promise<void>;
-//# sourceMappingURL=touchAction.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"touchAction.d.ts","sourceRoot":"","sources":["../../../src/commands/element/touchAction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CAC/B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,EAAE,YAAY,iBAGxB"}

package/build/commands/element/touchAction.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const constant_1 = require("../constant");
-/**
- *
- * The Touch Action API provides the basis of all gestures that can be automated in Appium.
- * It is currently only available to native apps and can not be used to interact with webapps.
- * At its core is the ability to chain together _ad hoc_ individual actions, which will then be
- * applied to an element in the application on the device. The basic actions that can be used are:
- *
- * - press (pass element or (x,y) or both)
- * - longPress (pass element or (x,y) or both)
- * - tap (pass element or (x,y) or both)
- * - moveTo (pass absolute x,y coordinates)
- * - wait (pass ms (as milliseconds))
- * - release (no arguments)
- *
- * <example>
-    :touchAction.js
-    it('should do a touch gesture', async () => {
-        const screen = await $('//UITextbox');
-
-        // simple touch action on element
-        await screen.touchAction('tap');
-
-        // simple touch action using selector and x y variables
-        // tap location is 30px right and 20px down relative from the center of the element
-        await screen.touchAction({
-            action: 'tap', x: 30, y:20
-        })
-
-        // multi action on an element (drag&drop)
-        await screen.touchAction([
-            'press',
-            { action: 'moveTo', x: 200, y: 300 },
-            'release'
-        ])
-
-        // drag&drop to element
-        const otherElement = await $('//UIAApplication[1]/UIAElement[2]')
-        await screen.touchAction([
-            'press',
-            { action: 'moveTo', element: otherElement },
-            'release'
-        ])
-    });
- * </example>
- *
- * @param {TouchActions} action    action to execute
- *
- * @see https://saucelabs.com/blog/appium-sauce-labs-bootcamp-chapter-2-touch-actions
- * @for android, ios
- *
- */
-function touchAction(actions) {
-    return constant_1.touchAction.call(this, actions);
-}
-exports.default = touchAction;

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

@@ -1,34 +0,0 @@
-import type { WaitForOptions } from '../../types';
-/**
- * Wait for an element for the provided amount of milliseconds to be clickable or not clickable.
- *
- * :::info
- *
- * As opposed to other element commands WebdriverIO will not wait for the element to exist to execute
- * this command.
- *
- * :::
- *
- * <example>
-    :waitForClickable.js
-    it('should detect when element is clickable', async () => {
-        const elem = await $('#elem')
-        await elem.waitForClickable({ timeout: 3000 });
-    });
-    it('should detect when element is no longer clickable', async () => {
-        const elem = await $('#elem')
-        await elem.waitForClickable({ reverse: true });
-    });
- * </example>
- *
- * @alias element.waitForClickable
- * @param {WaitForOptions=}  options             waitForEnabled options (optional)
- * @param {Number=}          options.timeout     time in ms (default: 500)
- * @param {Boolean=}         options.reverse     if true it waits for the opposite (default: false)
- * @param {String=}          options.timeoutMsg  if exists it overrides the default error message
- * @param {Number=}          options.interval    interval between checks (default: `waitforInterval`)
- * @return {Boolean} `true` if element is clickable (or doesn't if flag is set)
- *
- */
-export default function waitForClickable(this: WebdriverIO.Element, { timeout, interval, reverse, timeoutMsg }?: WaitForOptions): Promise<true | void>;
-//# sourceMappingURL=waitForClickable.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"waitForClickable.d.ts","sourceRoot":"","sources":["../../../src/commands/element/waitForClickable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAA8B,gBAAgB,CAC1C,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,EACI,OAAqC,EACrC,QAAuC,EACvC,OAAe,EACf,UAAsG,EACzG,GAAE,cAAmB,wBAMzB"}

package/build/commands/element/waitForClickable.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Wait for an element for the provided amount of milliseconds to be clickable or not clickable.
- *
- * :::info
- *
- * As opposed to other element commands WebdriverIO will not wait for the element to exist to execute
- * this command.
- *
- * :::
- *
- * <example>
-    :waitForClickable.js
-    it('should detect when element is clickable', async () => {
-        const elem = await $('#elem')
-        await elem.waitForClickable({ timeout: 3000 });
-    });
-    it('should detect when element is no longer clickable', async () => {
-        const elem = await $('#elem')
-        await elem.waitForClickable({ reverse: true });
-    });
- * </example>
- *
- * @alias element.waitForClickable
- * @param {WaitForOptions=}  options             waitForEnabled options (optional)
- * @param {Number=}          options.timeout     time in ms (default: 500)
- * @param {Boolean=}         options.reverse     if true it waits for the opposite (default: false)
- * @param {String=}          options.timeoutMsg  if exists it overrides the default error message
- * @param {Number=}          options.interval    interval between checks (default: `waitforInterval`)
- * @return {Boolean} `true` if element is clickable (or doesn't if flag is set)
- *
- */
-async function waitForClickable({ timeout = this.options.waitforTimeout, interval = this.options.waitforInterval, reverse = false, timeoutMsg = `element ("${this.selector}") still ${reverse ? '' : 'not '}clickable after ${timeout}ms` } = {}) {
-    return this.waitUntil(async () => reverse !== await this.isClickable(), { timeout, timeoutMsg, interval });
-}
-exports.default = waitForClickable;

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

@@ -1,44 +0,0 @@
-import type { WaitForOptions } from '../../types';
-/**
- *
- * Wait for an element for the provided amount of milliseconds to be displayed or not 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="elem" style="visibility: hidden;">Hello World!</div>
-    <script type="text/javascript">
-        setTimeout(() => {
-            document.getElementById('elem').style.visibility = 'visible';
-        }, 2000);
-    </script>
-    :waitForDisplayedExample.js
-    it('should detect when element is visible', async () => {
-        const elem = await $('#elem')
-        await elem.waitForDisplayed({ timeout: 3000 });
-    });
-    it('should detect when element is no longer visible', async () => {
-        const elem = await $('#elem')
-        await elem.waitForDisplayed({ reverse: true });
-    });
- * </example>
- *
- * @alias element.waitForDisplayed
- * @param {WaitForOptions=}  options             waitForEnabled options (optional)
- * @param {Number=}          options.timeout     time in ms (default: 500)
- * @param {Boolean=}         options.reverse     if true it waits for the opposite (default: false)
- * @param {String=}          options.timeoutMsg  if exists it overrides the default error message
- * @param {Number=}          options.interval    interval between checks (default: `waitforInterval`)
- * @return {Boolean} true     if element is displayed (or doesn't if flag is set)
- * @uses utility/waitUntil, state/isDisplayed
- * @type utility
- *
- */
-export default function waitForDisplayed(this: WebdriverIO.Element, { timeout, interval, reverse, timeoutMsg }?: WaitForOptions): Promise<true | void>;
-//# sourceMappingURL=waitForDisplayed.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"waitForDisplayed.d.ts","sourceRoot":"","sources":["../../../src/commands/element/waitForDisplayed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAA8B,gBAAgB,CAC1C,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,EACI,OAAqC,EACrC,QAAuC,EACvC,OAAe,EACf,UAAsG,EACzG,GAAE,cAAmB,wBAMzB"}

package/build/commands/element/waitForDisplayed.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- *
- * Wait for an element for the provided amount of milliseconds to be displayed or not 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="elem" style="visibility: hidden;">Hello World!</div>
-    <script type="text/javascript">
-        setTimeout(() => {
-            document.getElementById('elem').style.visibility = 'visible';
-        }, 2000);
-    </script>
-    :waitForDisplayedExample.js
-    it('should detect when element is visible', async () => {
-        const elem = await $('#elem')
-        await elem.waitForDisplayed({ timeout: 3000 });
-    });
-    it('should detect when element is no longer visible', async () => {
-        const elem = await $('#elem')
-        await elem.waitForDisplayed({ reverse: true });
-    });
- * </example>
- *
- * @alias element.waitForDisplayed
- * @param {WaitForOptions=}  options             waitForEnabled options (optional)
- * @param {Number=}          options.timeout     time in ms (default: 500)
- * @param {Boolean=}         options.reverse     if true it waits for the opposite (default: false)
- * @param {String=}          options.timeoutMsg  if exists it overrides the default error message
- * @param {Number=}          options.interval    interval between checks (default: `waitforInterval`)
- * @return {Boolean} true     if element is displayed (or doesn't if flag is set)
- * @uses utility/waitUntil, state/isDisplayed
- * @type utility
- *
- */
-async function waitForDisplayed({ timeout = this.options.waitforTimeout, interval = this.options.waitforInterval, reverse = false, timeoutMsg = `element ("${this.selector}") still ${reverse ? '' : 'not '}displayed after ${timeout}ms` } = {}) {
-    return this.waitUntil(async () => reverse !== await this.isDisplayed(), { timeout, interval, timeoutMsg });
-}
-exports.default = waitForDisplayed;

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

@@ -1,46 +0,0 @@
-import type { WaitForOptions } from '../../types';
-/**
- *
- * Wait for an element (selected by css selector) for the provided amount of
- * milliseconds to be (dis/en)abled. If multiple elements get queried by given
- * selector, it returns true if at least one element is (dis/en)abled.
- *
- * :::info
- *
- * As opposed to other element commands WebdriverIO will not wait for the element
- * to exist to execute this command.
- *
- * :::
- *
- * <example>
-    :index.html
-    <input type="text" id="username" value="foobar" disabled="disabled"></input>
-    <script type="text/javascript">
-        setTimeout(() => {
-            document.getElementById('username').disabled = false
-        }, 2000);
-    </script>
-    :waitForEnabledExample.js
-    it('should detect when element is enabled', async () => {
-        await $('#username').waitForEnabled({ timeout: 3000 });
-    });
-
-    it('should detect when element is disabled', async () => {
-        elem = await $('#username');
-        await elem.waitForEnabled({ reverse: true })
-    });
- * </example>
- *
- * @alias element.waitForEnabled
- * @param {WaitForOptions=}  options             waitForEnabled options (optional)
- * @param {Number=}          options.timeout     time in ms (default: 500)
- * @param {Boolean=}         options.reverse     if true it waits for the opposite (default: false)
- * @param {String=}          options.timeoutMsg  if exists it overrides the default error message
- * @param {Number=}          options.interval    interval between checks (default: `waitforInterval`)
- * @return {Boolean} true     if element is (dis/en)abled
- * @uses utility/waitUntil, state/isEnabled
- * @type utility
- *
- */
-export default function waitForEnabled(this: WebdriverIO.Element, { timeout, interval, reverse, timeoutMsg }?: WaitForOptions): Promise<true | void>;
-//# sourceMappingURL=waitForEnabled.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"waitForEnabled.d.ts","sourceRoot":"","sources":["../../../src/commands/element/waitForEnabled.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAA8B,cAAc,CACxC,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,EACI,OAAqC,EACrC,QAAuC,EACvC,OAAe,EACf,UAAoG,EACvG,GAAE,cAAmB,wBAazB"}

package/build/commands/element/waitForEnabled.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- *
- * Wait for an element (selected by css selector) for the provided amount of
- * milliseconds to be (dis/en)abled. If multiple elements get queried by given
- * selector, it returns true if at least one element is (dis/en)abled.
- *
- * :::info
- *
- * As opposed to other element commands WebdriverIO will not wait for the element
- * to exist to execute this command.
- *
- * :::
- *
- * <example>
-    :index.html
-    <input type="text" id="username" value="foobar" disabled="disabled"></input>
-    <script type="text/javascript">
-        setTimeout(() => {
-            document.getElementById('username').disabled = false
-        }, 2000);
-    </script>
-    :waitForEnabledExample.js
-    it('should detect when element is enabled', async () => {
-        await $('#username').waitForEnabled({ timeout: 3000 });
-    });
-
-    it('should detect when element is disabled', async () => {
-        elem = await $('#username');
-        await elem.waitForEnabled({ reverse: true })
-    });
- * </example>
- *
- * @alias element.waitForEnabled
- * @param {WaitForOptions=}  options             waitForEnabled options (optional)
- * @param {Number=}          options.timeout     time in ms (default: 500)
- * @param {Boolean=}         options.reverse     if true it waits for the opposite (default: false)
- * @param {String=}          options.timeoutMsg  if exists it overrides the default error message
- * @param {Number=}          options.interval    interval between checks (default: `waitforInterval`)
- * @return {Boolean} true     if element is (dis/en)abled
- * @uses utility/waitUntil, state/isEnabled
- * @type utility
- *
- */
-async function waitForEnabled({ timeout = this.options.waitforTimeout, interval = this.options.waitforInterval, reverse = false, timeoutMsg = `element ("${this.selector}") still ${reverse ? '' : 'not '}enabled after ${timeout}ms` } = {}) {
-    /**
-     * if the element doesn't already exist, wait for it to exist
-     */
-    if (!this.elementId && !reverse) {
-        await this.waitForExist({ timeout, interval, timeoutMsg });
-    }
-    return this.waitUntil(async () => reverse !== await this.isEnabled(), { timeout, interval, timeoutMsg });
-}
-exports.default = waitForEnabled;

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

@@ -1,46 +0,0 @@
-import type { WaitForOptions } from '../../types';
-/**
- *
- * Wait for an element for the provided amount of
- * milliseconds to be present within the DOM. Returns true if the selector
- * matches at least one element that exists in the DOM, otherwise throws an
- * error. If the reverse flag is true, the command will instead return true
- * if the selector does not match any elements.
- *
- * :::info
- *
- * As opposed to other element commands WebdriverIO will not wait for the
- * element to exist to execute this command.
- *
- * :::
- *
- * <example>
-    :waitForExistSyncExample.js
-    it('should display a notification message after successful form submit', async () => {
-        const form = await $('form');
-        const notification = await $('.notification');
-        await form.$(".send").click();
-        await notification.waitForExist({ timeout: 5000 });
-        expect(await notification.getText()).to.be.equal('Data transmitted successfully!')
-    });
-    it('should remove a message after successful form submit', async () => {
-        const form = await $('form');
-        const message = await $('.message');
-        await form.$(".send").click();
-        await message.waitForExist({ reverse: true });
-    });
- * </example>
- *
- * @alias element.waitForExist
- * @param {WaitForOptions=}  options             waitForEnabled options (optional)
- * @param {Number=}          options.timeout     time in ms (default: 500)
- * @param {Boolean=}         options.reverse     if true it waits for the opposite (default: false)
- * @param {String=}          options.timeoutMsg  if exists it overrides the default error message
- * @param {Number=}          options.interval    interval between checks (default: `waitforInterval`)
- * @return {Boolean} true     if element exists (or doesn't if flag is set)
- * @uses utility/waitUntil, state/isExisting
- * @type utility
- *
- */
-export default function waitForExist(this: WebdriverIO.Element, { timeout, interval, reverse, timeoutMsg }?: WaitForOptions): Promise<true | void>;
-//# sourceMappingURL=waitForExist.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"waitForExist.d.ts","sourceRoot":"","sources":["../../../src/commands/element/waitForExist.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAChC,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,EACI,OAAqC,EACrC,QAAuC,EACvC,OAAe,EACf,UAAqG,EACxG,GAAE,cAAmB,wBAMzB"}

package/build/commands/element/waitForExist.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- *
- * Wait for an element for the provided amount of
- * milliseconds to be present within the DOM. Returns true if the selector
- * matches at least one element that exists in the DOM, otherwise throws an
- * error. If the reverse flag is true, the command will instead return true
- * if the selector does not match any elements.
- *
- * :::info
- *
- * As opposed to other element commands WebdriverIO will not wait for the
- * element to exist to execute this command.
- *
- * :::
- *
- * <example>
-    :waitForExistSyncExample.js
-    it('should display a notification message after successful form submit', async () => {
-        const form = await $('form');
-        const notification = await $('.notification');
-        await form.$(".send").click();
-        await notification.waitForExist({ timeout: 5000 });
-        expect(await notification.getText()).to.be.equal('Data transmitted successfully!')
-    });
-    it('should remove a message after successful form submit', async () => {
-        const form = await $('form');
-        const message = await $('.message');
-        await form.$(".send").click();
-        await message.waitForExist({ reverse: true });
-    });
- * </example>
- *
- * @alias element.waitForExist
- * @param {WaitForOptions=}  options             waitForEnabled options (optional)
- * @param {Number=}          options.timeout     time in ms (default: 500)
- * @param {Boolean=}         options.reverse     if true it waits for the opposite (default: false)
- * @param {String=}          options.timeoutMsg  if exists it overrides the default error message
- * @param {Number=}          options.interval    interval between checks (default: `waitforInterval`)
- * @return {Boolean} true     if element exists (or doesn't if flag is set)
- * @uses utility/waitUntil, state/isExisting
- * @type utility
- *
- */
-function waitForExist({ timeout = this.options.waitforTimeout, interval = this.options.waitforInterval, reverse = false, timeoutMsg = `element ("${this.selector}") still ${reverse ? '' : 'not '}existing after ${timeout}ms` } = {}) {
-    return this.waitUntil(async () => reverse !== await this.isExisting(), { timeout, interval, timeoutMsg });
-}
-exports.default = waitForExist;

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

@@ -1,49 +0,0 @@
-/**
- *
- * This wait command is your universal weapon if you want to wait on something. It expects a condition
- * and waits until that condition is fulfilled with a truthy value. If you use the WDIO testrunner the
- * commands within the condition are getting executed synchronously like in your test.
- *
- * :::info
- *
- * As opposed to other element commands WebdriverIO will not wait for the element to exist to execute
- * this command.
- *
- * :::
- *
- * A common example is to wait until a certain element contains a certain text (see example).
- *
- * <example>
-    :example.html
-    <div id="someText">I am some text</div>
-    <script>
-      setTimeout(() => {
-        await $('#someText').html('I am now different');
-      }, 1000);
-    </script>
-
-    :waitUntil.js
-    it('should wait until text has changed', async () => {
-        const elem = await $('#someText')
-        await elem.waitUntil(async function () {
-            return (await this.getText()) === 'I am now different'
-        }, {
-            timeout: 5000,
-            timeoutMsg: 'expected text to be different after 5s'
-        });
-    });
- * </example>
- *
- * @alias element.waitUntil
- * @param {Function#Boolean}  condition  condition to wait on
- * @param {WaitUntilOptions=} options    command options
- * @param {Number=}           options.timeout     timeout in ms (default: 5000)
- * @param {String=}           options.timeoutMsg  error message to throw when waitUntil times out
- * @param {Number=}           options.interval    interval between condition checks (default: 500)
- * @return {Boolean} true if condition is fulfilled
- * @type utility
- *
- */
-import waitUntil from '../browser/waitUntil';
-export default waitUntil;
-//# sourceMappingURL=waitUntil.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"waitUntil.d.ts","sourceRoot":"","sources":["../../../src/commands/element/waitUntil.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,OAAO,SAAS,MAAM,sBAAsB,CAAA;AAC5C,eAAe,SAAS,CAAA"}

package/build/commands/element/waitUntil.js

@@ -1,53 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- *
- * This wait command is your universal weapon if you want to wait on something. It expects a condition
- * and waits until that condition is fulfilled with a truthy value. If you use the WDIO testrunner the
- * commands within the condition are getting executed synchronously like in your test.
- *
- * :::info
- *
- * As opposed to other element commands WebdriverIO will not wait for the element to exist to execute
- * this command.
- *
- * :::
- *
- * A common example is to wait until a certain element contains a certain text (see example).
- *
- * <example>
-    :example.html
-    <div id="someText">I am some text</div>
-    <script>
-      setTimeout(() => {
-        await $('#someText').html('I am now different');
-      }, 1000);
-    </script>
-
-    :waitUntil.js
-    it('should wait until text has changed', async () => {
-        const elem = await $('#someText')
-        await elem.waitUntil(async function () {
-            return (await this.getText()) === 'I am now different'
-        }, {
-            timeout: 5000,
-            timeoutMsg: 'expected text to be different after 5s'
-        });
-    });
- * </example>
- *
- * @alias element.waitUntil
- * @param {Function#Boolean}  condition  condition to wait on
- * @param {WaitUntilOptions=} options    command options
- * @param {Number=}           options.timeout     timeout in ms (default: 5000)
- * @param {String=}           options.timeoutMsg  error message to throw when waitUntil times out
- * @param {Number=}           options.interval    interval between condition checks (default: 500)
- * @return {Boolean} true if condition is fulfilled
- * @type utility
- *
- */
-const waitUntil_1 = __importDefault(require("../browser/waitUntil"));
-exports.default = waitUntil_1.default;