webdriverio 7.17.0 → 7.18.0

package/build/commands/browser.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = __importDefault(require("./browser/$$"));
+const _1 = __importDefault(require("./browser/$"));
+const call_1 = __importDefault(require("./browser/call"));
+const custom__1 = __importDefault(require("./browser/custom$$"));
+const custom_1 = __importDefault(require("./browser/custom$"));
+const debug_1 = __importDefault(require("./browser/debug"));
+const deleteCookies_1 = __importDefault(require("./browser/deleteCookies"));
+const execute_1 = __importDefault(require("./browser/execute"));
+const executeAsync_1 = __importDefault(require("./browser/executeAsync"));
+const getCookies_1 = __importDefault(require("./browser/getCookies"));
+const getPuppeteer_1 = __importDefault(require("./browser/getPuppeteer"));
+const getWindowSize_1 = __importDefault(require("./browser/getWindowSize"));
+const keys_1 = __importDefault(require("./browser/keys"));
+const mock_1 = __importDefault(require("./browser/mock"));
+const mockClearAll_1 = __importDefault(require("./browser/mockClearAll"));
+const mockRestoreAll_1 = __importDefault(require("./browser/mockRestoreAll"));
+const newWindow_1 = __importDefault(require("./browser/newWindow"));
+const pause_1 = __importDefault(require("./browser/pause"));
+const react__1 = __importDefault(require("./browser/react$$"));
+const react_1 = __importDefault(require("./browser/react$"));
+const reloadSession_1 = __importDefault(require("./browser/reloadSession"));
+const savePDF_1 = __importDefault(require("./browser/savePDF"));
+const saveRecordingScreen_1 = __importDefault(require("./browser/saveRecordingScreen"));
+const saveScreenshot_1 = __importDefault(require("./browser/saveScreenshot"));
+const setCookies_1 = __importDefault(require("./browser/setCookies"));
+const setTimeout_1 = __importDefault(require("./browser/setTimeout"));
+const setWindowSize_1 = __importDefault(require("./browser/setWindowSize"));
+const switchWindow_1 = __importDefault(require("./browser/switchWindow"));
+const throttle_1 = __importDefault(require("./browser/throttle"));
+const touchAction_1 = __importDefault(require("./browser/touchAction"));
+const uploadFile_1 = __importDefault(require("./browser/uploadFile"));
+const url_1 = __importDefault(require("./browser/url"));
+const waitUntil_1 = __importDefault(require("./browser/waitUntil"));
+exports.default = {
+    $$: __1.default, $: _1.default, call: call_1.default, custom$$: custom__1.default, custom$: custom_1.default, debug: debug_1.default, deleteCookies: deleteCookies_1.default, execute: execute_1.default, executeAsync: executeAsync_1.default, getCookies: getCookies_1.default,
+    getPuppeteer: getPuppeteer_1.default, getWindowSize: getWindowSize_1.default, keys: keys_1.default, mock: mock_1.default, mockClearAll: mockClearAll_1.default, mockRestoreAll: mockRestoreAll_1.default, newWindow: newWindow_1.default, pause: pause_1.default,
+    react$$: react__1.default, react$: react_1.default, reloadSession: reloadSession_1.default, savePDF: savePDF_1.default, saveRecordingScreen: saveRecordingScreen_1.default, saveScreenshot: saveScreenshot_1.default, setCookies: setCookies_1.default,
+    setTimeout: setTimeout_1.default, setWindowSize: setWindowSize_1.default, switchWindow: switchWindow_1.default, throttle: throttle_1.default, touchAction: touchAction_1.default, uploadFile: uploadFile_1.default, url: url_1.default, waitUntil: waitUntil_1.default
+};

package/build/commands/constant.d.ts

@@ -0,0 +1,19 @@
+import { TouchAction, TouchActions } from '../types';
+interface FormattedTouchAction extends Omit<TouchAction, 'element'> {
+    element?: string;
+}
+interface FormattedActions {
+    action: string;
+    options?: FormattedTouchAction;
+}
+export declare const formatArgs: (scope: WebdriverIO.Browser | WebdriverIO.Element, actions: TouchActions[]) => FormattedActions[];
+/**
+ * Make sure action has proper options before sending command to Appium.
+ *
+ * @param  {Object} params  touchAction parameters
+ * @return null
+ */
+export declare const validateParameters: (params: FormattedActions) => void;
+export declare const touchAction: (this: WebdriverIO.Browser | WebdriverIO.Element, actions: TouchActions) => Promise<void>;
+export {};
+//# sourceMappingURL=constant.d.ts.map

package/build/commands/constant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant.d.ts","sourceRoot":"","sources":["../../src/commands/constant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AASpD,UAAU,oBAAqB,SAAQ,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,UAAU,gBAAgB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,oBAAoB,CAAA;CACjC;AAED,eAAO,MAAM,UAAU,UACZ,YAAY,OAAO,GAAG,mBAAmB,WACvC,YAAY,EAAE,KACxB,gBAAgB,EAsClB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,WAAY,gBAAgB,SA8B1D,CAAA;AAED,eAAO,MAAM,WAAW,SACd,YAAY,OAAO,GAAG,mBAAmB,WACtC,YAAY,kBAgBxB,CAAA"}

package/build/commands/constant.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.touchAction = exports.validateParameters = exports.formatArgs = void 0;
+/**
+ * Constants around commands
+ */
+const TOUCH_ACTIONS = ['press', 'longPress', 'tap', 'moveTo', 'wait', 'release'];
+const POS_ACTIONS = TOUCH_ACTIONS.slice(0, 4);
+const ACCEPTED_OPTIONS = ['x', 'y', 'element'];
+const formatArgs = function (scope, actions) {
+    return actions.map((action) => {
+        if (Array.isArray(action)) {
+            return (0, exports.formatArgs)(scope, action);
+        }
+        if (typeof action === 'string') {
+            action = { action };
+        }
+        const formattedAction = {
+            action: action.action,
+            options: {}
+        };
+        /**
+         * don't propagate for actions that don't require element options
+         */
+        const actionElement = action.element && typeof action.element.elementId === 'string'
+            ? action.element.elementId
+            : scope.elementId;
+        if (POS_ACTIONS.includes(action.action) && formattedAction.options && actionElement) {
+            formattedAction.options.element = actionElement;
+        }
+        if (formattedAction.options && typeof action.x === 'number' && isFinite(action.x))
+            formattedAction.options.x = action.x;
+        if (formattedAction.options && typeof action.y === 'number' && isFinite(action.y))
+            formattedAction.options.y = action.y;
+        if (formattedAction.options && action.ms)
+            formattedAction.options.ms = action.ms;
+        /**
+         * remove options property if empty
+         */
+        if (formattedAction.options && Object.keys(formattedAction.options).length === 0) {
+            delete formattedAction.options;
+        }
+        return formattedAction;
+    });
+};
+exports.formatArgs = formatArgs;
+/**
+ * Make sure action has proper options before sending command to Appium.
+ *
+ * @param  {Object} params  touchAction parameters
+ * @return null
+ */
+const validateParameters = (params) => {
+    const options = Object.keys(params.options || {});
+    if (params.action === 'release' && options.length !== 0) {
+        throw new Error('action "release" doesn\'t accept any options ' +
+            `("${options.join('", "')}" found)`);
+    }
+    if (params.action === 'wait' &&
+        (options.includes('x') || options.includes('y'))) {
+        throw new Error('action "wait" doesn\'t accept x or y options');
+    }
+    if (POS_ACTIONS.includes(params.action)) {
+        for (const option in params.options) {
+            if (!ACCEPTED_OPTIONS.includes(option)) {
+                throw new Error(`action "${params.action}" doesn't accept "${option}" as option`);
+            }
+        }
+        if (options.length === 0) {
+            throw new Error(`Touch actions like "${params.action}" need at least some kind of ` +
+                'position information like "element", "x" or "y" options, you\'ve none given.');
+        }
+    }
+};
+exports.validateParameters = validateParameters;
+const touchAction = function (actions) {
+    if (!this.multiTouchPerform || !this.touchPerform) {
+        throw new Error('touchAction can be used with Appium only.');
+    }
+    if (!Array.isArray(actions)) {
+        actions = [actions];
+    }
+    const formattedAction = (0, exports.formatArgs)(this, actions);
+    const protocolCommand = Array.isArray(actions[0])
+        // cast old JSONWP
+        ? this.multiTouchPerform.bind(this)
+        : this.touchPerform.bind(this);
+    formattedAction.forEach((params) => (0, exports.validateParameters)(params));
+    return protocolCommand(formattedAction);
+};
+exports.touchAction = touchAction;

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

@@ -0,0 +1,46 @@
+/**
+ * The `$$` command is a short way to call the [`findElements`](/docs/api/webdriver#findelements) command in order
+ * to fetch multiple elements on the page similar to the `$$` command from the browser scope. The difference when calling
+ * it from an element scope is that the driver will look within the children of that element.
+ *
+ * :::info
+ *
+ * For more information on how to select specific elements, check out the [Selectors](/docs/selectors) guide.
+ *
+ * :::
+ *
+ * <example>
+    :index.html
+    <ul id="menu">
+        <li><a href="/">Home</a></li>
+        <li><a href="/">Developer Guide</a></li>
+        <li><a href="/">API</a></li>
+        <li><a href="/">Contribute</a></li>
+    </ul>
+    :$.js
+    it('should get text a menu link', async () => {
+        const text = await $('#menu');
+        console.log(await text.$$('li')[2].$('a').getText()); // outputs: "API"
+    });
+
+    it('should get text a menu link - JS Function', async () => {
+        const text = await $('#menu');
+        console.log(await text.$$(function() { // Arrow function is not allowed here.
+            // this is Element https://developer.mozilla.org/en-US/docs/Web/API/Element
+            // in this particular example it is HTMLUListElement
+            // TypeScript users may do something like this
+            // return (this as Element).querySelectorAll('li')
+            return this.querySelectorAll('li'); // Element[]
+        })[2].$('a').getText()); // outputs: "API"
+    });
+ * </example>
+ *
+ * @alias $$
+ * @param {String|Function|Matcher} selector  selector, JS Function, or Matcher object to fetch multiple elements
+ * @return {ElementArray}
+ * @type utility
+ *
+ */
+import $$ from '../browser/$$';
+export default $$;
+//# sourceMappingURL=$$.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"$$.d.ts","sourceRoot":"","sources":["../../../src/commands/element/$$.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,OAAO,EAAE,MAAM,eAAe,CAAA;AAC9B,eAAe,EAAE,CAAA"}

package/build/commands/element/$$.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * The `$$` command is a short way to call the [`findElements`](/docs/api/webdriver#findelements) command in order
+ * to fetch multiple elements on the page similar to the `$$` command from the browser scope. The difference when calling
+ * it from an element scope is that the driver will look within the children of that element.
+ *
+ * :::info
+ *
+ * For more information on how to select specific elements, check out the [Selectors](/docs/selectors) guide.
+ *
+ * :::
+ *
+ * <example>
+    :index.html
+    <ul id="menu">
+        <li><a href="/">Home</a></li>
+        <li><a href="/">Developer Guide</a></li>
+        <li><a href="/">API</a></li>
+        <li><a href="/">Contribute</a></li>
+    </ul>
+    :$.js
+    it('should get text a menu link', async () => {
+        const text = await $('#menu');
+        console.log(await text.$$('li')[2].$('a').getText()); // outputs: "API"
+    });
+
+    it('should get text a menu link - JS Function', async () => {
+        const text = await $('#menu');
+        console.log(await text.$$(function() { // Arrow function is not allowed here.
+            // this is Element https://developer.mozilla.org/en-US/docs/Web/API/Element
+            // in this particular example it is HTMLUListElement
+            // TypeScript users may do something like this
+            // return (this as Element).querySelectorAll('li')
+            return this.querySelectorAll('li'); // Element[]
+        })[2].$('a').getText()); // outputs: "API"
+    });
+ * </example>
+ *
+ * @alias $$
+ * @param {String|Function|Matcher} selector  selector, JS Function, or Matcher object to fetch multiple elements
+ * @return {ElementArray}
+ * @type utility
+ *
+ */
+const __1 = __importDefault(require("../browser/$$"));
+exports.default = __1.default;

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

@@ -0,0 +1,72 @@
+/**
+ * The `$` command is a short way to call the [`findElement`](/docs/api/webdriver#findelement) command in order
+ * to fetch a single element on the page similar to the `$` command from the browser scope. The difference when calling
+ * it from an element scope is that the driver will look within the children of that element. You can also pass in an object as selector
+ * where the object contains a property `element-6066-11e4-a52e-4f735466cecf` with the value of a reference
+ * to an element. The command will then transform the reference to an extended WebdriverIO element.
+ *
+ * Note: chaining `$` and `$$` commands only make sense when you use multiple selector strategies. You will otherwise
+ * make unnecessary requests that slow down the test (e.g. `$('body').$('div')` will trigger two request whereas
+ * `$('body div')` does literally the same with just one request)
+ *
+ * :::info
+ *
+ * For more information on how to select specific elements, check out the [Selectors](/docs/selectors) guide.
+ *
+ * :::
+ *
+ * <example>
+    :index.html
+    <ul id="menu">
+        <li><a href="/">Home</a></li>
+        <li><a href="/">Developer Guide</a></li>
+        <li><a href="/">API</a></li>
+        <li><a href="/">Contribute</a></li>
+    </ul>
+    :$.js
+    it('should get text a menu link', async () => {
+        const text = await $('#menu');
+        console.log(await text.$$('li')[2].$('a').getText()); // outputs: "API"
+    });
+
+    it('should get text a menu link - JS Function', async () => {
+        const text = await $('#menu');
+        console.log(await text.$$('li')[2].$(function() { // Arrow function is not allowed here.
+            // this is Element https://developer.mozilla.org/en-US/docs/Web/API/Element
+            // in this particular example it is HTMLLIElement
+            // TypeScript users may do something like this
+            // return (this as Element).querySelector('a')
+            return this.querySelector('a'); // Element
+        }).getText()); // outputs: "API"
+    });
+
+    it('should allow to convert protocol result of an element into a WebdriverIO element', async () => {
+        const activeElement = await browser.getActiveElement();
+        console.log(await $(activeElement).getTagName()); // outputs active element
+    });
+
+    it('should use Androids DataMatcher or ViewMatcher selector', async () => {
+        const menuItem = await $({
+            "name": "hasEntry",
+            "args": ["title", "ViewTitle"],
+            "class": "androidx.test.espresso.matcher.ViewMatchers"
+        });
+        await menuItem.click();
+
+        const menuItem = await $({
+            "name": "hasEntry",
+            "args": ["title", "ViewTitle"]
+        });
+        await menuItem.click();
+    });
+ * </example>
+ *
+ * @alias $
+ * @param {String|Function|Matcher} selector  selector, JS Function, or Matcher object to fetch a certain element
+ * @return {Element}
+ * @type utility
+ *
+ */
+import $ from '../browser/$';
+export default $;
+//# sourceMappingURL=$.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"$.d.ts","sourceRoot":"","sources":["../../../src/commands/element/$.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,OAAO,CAAC,MAAM,cAAc,CAAA;AAC5B,eAAe,CAAC,CAAA"}

package/build/commands/element/$.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * The `$` command is a short way to call the [`findElement`](/docs/api/webdriver#findelement) command in order
+ * to fetch a single element on the page similar to the `$` command from the browser scope. The difference when calling
+ * it from an element scope is that the driver will look within the children of that element. You can also pass in an object as selector
+ * where the object contains a property `element-6066-11e4-a52e-4f735466cecf` with the value of a reference
+ * to an element. The command will then transform the reference to an extended WebdriverIO element.
+ *
+ * Note: chaining `$` and `$$` commands only make sense when you use multiple selector strategies. You will otherwise
+ * make unnecessary requests that slow down the test (e.g. `$('body').$('div')` will trigger two request whereas
+ * `$('body div')` does literally the same with just one request)
+ *
+ * :::info
+ *
+ * For more information on how to select specific elements, check out the [Selectors](/docs/selectors) guide.
+ *
+ * :::
+ *
+ * <example>
+    :index.html
+    <ul id="menu">
+        <li><a href="/">Home</a></li>
+        <li><a href="/">Developer Guide</a></li>
+        <li><a href="/">API</a></li>
+        <li><a href="/">Contribute</a></li>
+    </ul>
+    :$.js
+    it('should get text a menu link', async () => {
+        const text = await $('#menu');
+        console.log(await text.$$('li')[2].$('a').getText()); // outputs: "API"
+    });
+
+    it('should get text a menu link - JS Function', async () => {
+        const text = await $('#menu');
+        console.log(await text.$$('li')[2].$(function() { // Arrow function is not allowed here.
+            // this is Element https://developer.mozilla.org/en-US/docs/Web/API/Element
+            // in this particular example it is HTMLLIElement
+            // TypeScript users may do something like this
+            // return (this as Element).querySelector('a')
+            return this.querySelector('a'); // Element
+        }).getText()); // outputs: "API"
+    });
+
+    it('should allow to convert protocol result of an element into a WebdriverIO element', async () => {
+        const activeElement = await browser.getActiveElement();
+        console.log(await $(activeElement).getTagName()); // outputs active element
+    });
+
+    it('should use Androids DataMatcher or ViewMatcher selector', async () => {
+        const menuItem = await $({
+            "name": "hasEntry",
+            "args": ["title", "ViewTitle"],
+            "class": "androidx.test.espresso.matcher.ViewMatchers"
+        });
+        await menuItem.click();
+
+        const menuItem = await $({
+            "name": "hasEntry",
+            "args": ["title", "ViewTitle"]
+        });
+        await menuItem.click();
+    });
+ * </example>
+ *
+ * @alias $
+ * @param {String|Function|Matcher} selector  selector, JS Function, or Matcher object to fetch a certain element
+ * @return {Element}
+ * @type utility
+ *
+ */
+const _1 = __importDefault(require("../browser/$"));
+exports.default = _1.default;

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

@@ -0,0 +1,33 @@
+export declare type CommandOptions = {
+    translateToUnicode?: boolean;
+};
+export declare type Value = string | number;
+/**
+ *
+ * Add a value to an object found by given selector. You can also use unicode
+ * characters like Left arrow or Back space. WebdriverIO will take care of
+ * translating them into unicode characters. You’ll find all supported characters
+ * [here](https://w3c.github.io/webdriver/webdriver-spec.html#keyboard-actions).
+ * To do that, the value has to correspond to a key from the table. It can be disabled
+ * by setting `translateToUnicode` optional parameter to false.
+ *
+ * <example>
+    :addValue.js
+    it('should demonstrate the addValue command', async () => {
+        let input = await $('.input')
+        await input.addValue('test')
+        await input.addValue(123)
+
+        value = await input.getValue()
+        assert(value === 'test123') // true
+    })
+ * </example>
+ *
+ * @alias element.addValue
+ * @param {string | number | Array<string | number>}        value                       value to be added
+ * @param {CommandOptions=}                                 options                     command options (optional)
+ * @param {boolean}                                         options.translateToUnicode  enable translation string to unicode value automatically
+ *
+ */
+export default function addValue(this: WebdriverIO.Element, value: Value | Value[], { translateToUnicode }?: CommandOptions): Promise<void>;
+//# sourceMappingURL=addValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addValue.d.ts","sourceRoot":"","sources":["../../../src/commands/element/addValue.ts"],"names":[],"mappings":"AAKA,oBAAY,cAAc,GAAG;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC/B,CAAA;AAED,oBAAY,KAAK,GAAG,MAAM,GAAG,MAAM,CAAA;AASnC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC5B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,KAAK,GAAG,KAAK,EAAE,EACtB,EAAE,kBAAyB,EAAE,GAAE,cAAmB,iBAWrD"}

package/build/commands/element/addValue.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const logger_1 = __importDefault(require("@wdio/logger"));
+const log = (0, logger_1.default)('addValue');
+const isNumberOrString = (input) => typeof input === 'string' || typeof input === 'number';
+const isValidType = (value) => (isNumberOrString(value) ||
+    Array.isArray(value) && value.every((item) => isNumberOrString(item)));
+/**
+ *
+ * Add a value to an object found by given selector. You can also use unicode
+ * characters like Left arrow or Back space. WebdriverIO will take care of
+ * translating them into unicode characters. You’ll find all supported characters
+ * [here](https://w3c.github.io/webdriver/webdriver-spec.html#keyboard-actions).
+ * To do that, the value has to correspond to a key from the table. It can be disabled
+ * by setting `translateToUnicode` optional parameter to false.
+ *
+ * <example>
+    :addValue.js
+    it('should demonstrate the addValue command', async () => {
+        let input = await $('.input')
+        await input.addValue('test')
+        await input.addValue(123)
+
+        value = await input.getValue()
+        assert(value === 'test123') // true
+    })
+ * </example>
+ *
+ * @alias element.addValue
+ * @param {string | number | Array<string | number>}        value                       value to be added
+ * @param {CommandOptions=}                                 options                     command options (optional)
+ * @param {boolean}                                         options.translateToUnicode  enable translation string to unicode value automatically
+ *
+ */
+function addValue(value, { translateToUnicode = true } = {}) {
+    if (!isValidType(value)) {
+        log.warn('@deprecated: support for type "string", "number" or "Array<string | number>" is deprecated');
+    }
+    if (!this.isW3C) {
+        return this.elementSendKeys(this.elementId, (0, utils_1.transformToCharString)(value, translateToUnicode));
+    }
+    return this.elementSendKeys(this.elementId, (0, utils_1.transformToCharString)(value, translateToUnicode).join(''));
+}
+exports.default = addValue;

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

@@ -0,0 +1,28 @@
+/**
+ *
+ * Clear a `<textarea>` or text `<input>` element’s value. Make sure you can interact with the
+ * element before using this command. You can't clear an input element that is disabled or in
+ * readonly mode.
+ *
+ * <example>
+    :clearValue.js
+    it('should demonstrate the clearValue command', async () => {
+        const elem = await $('.input')
+        await elem.setValue('test123')
+
+        const value = await elem.getValue()
+        console.log(value) // returns 'test123'
+
+        await elem.clearValue()
+        value = await elem.getValue()
+        assert(value === ''); // true
+    })
+ * </example>
+ *
+ * @alias element.clearValue
+ * @uses protocol/elements, protocol/elementIdClear
+ * @type action
+ *
+ */
+export default function clearValue(this: WebdriverIO.Element): Promise<void>;
+//# sourceMappingURL=clearValue.d.ts.map

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

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

package/build/commands/element/clearValue.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ *
+ * Clear a `<textarea>` or text `<input>` element’s value. Make sure you can interact with the
+ * element before using this command. You can't clear an input element that is disabled or in
+ * readonly mode.
+ *
+ * <example>
+    :clearValue.js
+    it('should demonstrate the clearValue command', async () => {
+        const elem = await $('.input')
+        await elem.setValue('test123')
+
+        const value = await elem.getValue()
+        console.log(value) // returns 'test123'
+
+        await elem.clearValue()
+        value = await elem.getValue()
+        assert(value === ''); // true
+    })
+ * </example>
+ *
+ * @alias element.clearValue
+ * @uses protocol/elements, protocol/elementIdClear
+ * @type action
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function clearValue() {
+    return this.elementClear(this.elementId);
+}
+exports.default = clearValue;

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

@@ -0,0 +1,73 @@
+import { ClickOptions } from '../../types';
+/**
+ *
+ * Click on an element.
+ *
+ * Note: This issues a WebDriver `click` command for the selected element, which generally scrolls to and then clicks the
+ * selected element. However, if you have fixed-position elements (such as a fixed header or footer) that cover up the
+ * selected element after it is scrolled within the viewport, the click will be issued at the given coordinates, but will
+ * be received by your fixed (overlaying) element. In these cased the following error is thrown:
+ *
+ * ```
+ * Element is not clickable at point (x, x). Other element would receive the click: ..."
+ * ```
+ *
+ * To work around this, try to find the overlaying element and remove it via `execute` command so it doesn't interfere
+ * the click. You also can try to scroll to the element yourself using `scroll` with an offset appropriate for your
+ * scenario.
+ *
+ * <example>
+    :example.html
+    <button id="myButton" onclick="document.getElementById('someText').innerHTML='I was clicked'">Click me</button>
+    <div id="someText">I was not clicked</div>
+    :click.js
+    it('should demonstrate the click command', async () => {
+        const myButton = await $('#myButton')
+        await myButton.click()
+        const myText = await $('#someText')
+        const text = await myText.getText()
+        assert(text === 'I was clicked') // true
+    })
+    :example.js
+    it('should fetch menu links and visit each page', async () => {
+        const links = await $$('#menu a')
+        await links.forEach(async (link) => {
+            await link.click()
+        })
+    })
+ * </example>
+ *
+ * <example>
+    :example.html
+    <button id="myButton">Click me</button>
+    :example.js
+    it('should demonstrate a click using an offset', async () => {
+        const myButton = await $('#myButton')
+        await myButton.click({ x: 30 }) // clicks 30 horizontal pixels away from location of the button (from center point of element)
+    })
+ * </example>
+ *
+ * <example>
+    :example.html
+    <button id="myButton">Click me</button>
+    :example.js
+    it('should demonstrate a right click passed as string', async () => {
+        const myButton = await $('#myButton')
+        await myButton.click({ button: 'right' }) // opens the contextmenu at the location of the button
+    })
+    it('should demonstrate a right click passed as number while adding an offset', async () => {
+        const myButton = await $('#myButton')
+        await myButton.click({ button: 2, x: 30, y: 40 }) // opens the contextmenu 30 horizontal and 40 vertical pixels away from location of the button (from the center of element)
+    })
+ * </example>
+ *
+ * @alias element.click
+ * @uses protocol/element, protocol/elementIdClick, protocol/performActions, protocol/positionClick
+ * @type action
+ * @param {ClickOptions=}     options        click options (optional)
+ * @param {string= | number=} options.button can be one of [0, "left", 1, "middle", 2, "right"] (optional)
+ * @param {number=}           options.x      Number (optional)
+ * @param {number=}           options.y      Number (optional)
+ */
+export default function click(this: WebdriverIO.Element, options?: ClickOptions): Promise<void>;
+//# sourceMappingURL=click.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"click.d.ts","sourceRoot":"","sources":["../../../src/commands/element/click.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAI1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,wBAA8B,KAAK,CAC/B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,CAAC,EAAE,YAAY,iBAuEzB"}