webdriverio 7.21.0 → 8.0.0-alpha.239

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

@@ -67,6 +67,6 @@
  * @type utility
  *
  */
-import $ from '../browser/$';
+import $ from '../browser/$.js';
 export default $;
 //# sourceMappingURL=$.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"$.d.ts","sourceRoot":"","sources":["../../../src/commands/element/$.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,OAAO,CAAC,MAAM,iBAAiB,CAAA;AAC/B,eAAe,CAAC,CAAA"}

package/build/commands/element/$.js

@@ -1,8 +1,3 @@
-"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
@@ -72,5 +67,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @type utility
  *
  */
-const _1 = __importDefault(require("../browser/$"));
-exports.default = _1.default;
+import $ from '../browser/$.js';
+export default $;

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

@@ -1,15 +1,13 @@
-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.
+ * Add a value to an input or textarea element found by given selector.
+ *
+ * :::info
+ *
+ * If you like to use special characters, e.g. to copy and paste a value from one input to another, use the
+ * [`keys`](/docs/api/browser/keys) command.
+ *
+ * :::
  *
  * <example>
     :addValue.js
@@ -24,10 +22,8 @@ export declare type Value = string | number;
  * </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
+ * @param {string | number}  value  value to be added
  *
  */
-export default function addValue(this: WebdriverIO.Element, value: Value | Value[], { translateToUnicode }?: CommandOptions): Promise<void>;
+export default function addValue(this: WebdriverIO.Element, value: string | number): Promise<void>;
 //# sourceMappingURL=addValue.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"addValue.d.ts","sourceRoot":"","sources":["../../../src/commands/element/addValue.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC5B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,MAAM,GAAG,MAAM,iBAoBzB"}

package/build/commands/element/addValue.js

@@ -1,22 +1,14 @@
-"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)));
+const VALID_TYPES = ['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.
+ * Add a value to an input or textarea element found by given selector.
+ *
+ * :::info
+ *
+ * If you like to use special characters, e.g. to copy and paste a value from one input to another, use the
+ * [`keys`](/docs/api/browser/keys) command.
+ *
+ * :::
  *
  * <example>
     :addValue.js
@@ -31,18 +23,22 @@ const isValidType = (value) => (isNumberOrString(value) ||
  * </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
+ * @param {string | number}  value  value to be added
  *
  */
-function addValue(value, { translateToUnicode = true } = {}) {
-    if (!isValidType(value)) {
-        log.warn('@deprecated: support for type "string", "number" or "Array<string | number>" is deprecated');
+export default function addValue(value) {
+    /**
+     * The JSONWireProtocol allowed array values and use of special characters when adding a value to an input.
+     * With the W3C protocol this was not possible anymore. This is a type check to ensure users are aware of
+     * this transition.
+     */
+    if (!VALID_TYPES.includes(typeof value)) {
+        throw new Error('The setValue/addValue command only take string or number values. ' +
+            'If you like to use special characters, use the "keys" command.');
     }
-    if (!this.isW3C) {
-        return this.elementSendKeys(this.elementId, (0, utils_1.transformToCharString)(value, translateToUnicode));
+    if (this.isW3C) {
+        return this.elementSendKeys(this.elementId, value.toString());
     }
-    return this.elementSendKeys(this.elementId, (0, utils_1.transformToCharString)(value, translateToUnicode).join(''));
+    // @ts-expect-error command is not typed as JWP command
+    return this.elementSendKeys(this.elementId, [value.toString()]);
 }
-exports.default = addValue;

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

@@ -1,6 +1,6 @@
 /**
  *
- * Clear a `<textarea>` or text `<input>` element’s value. Make sure you can interact with the
+ * Clear the value of an input or textarea element. 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.
  *

package/build/commands/element/clearValue.js

@@ -1,7 +1,6 @@
-"use strict";
 /**
  *
- * Clear a `<textarea>` or text `<input>` element’s value. Make sure you can interact with the
+ * Clear the value of an input or textarea element. 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.
  *
@@ -25,8 +24,6 @@
  * @type action
  *
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-function clearValue() {
+export default function clearValue() {
     return this.elementClear(this.elementId);
 }
-exports.default = clearValue;

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

@@ -1,4 +1,4 @@
-import { ClickOptions } from '../../types';
+import type { ClickOptions } from '../../types';
 /**
  *
  * Click on an element.

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,wBAA8B,KAAK,CAC/B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,CAAC,EAAE,YAAY,iBAoEzB"}
+{"version":3,"file":"click.d.ts","sourceRoot":"","sources":["../../../src/commands/element/click.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,wBAA8B,KAAK,CAC/B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,CAAC,EAAE,YAAY,iBAyDzB"}

package/build/commands/element/click.js

@@ -1,10 +1,4 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = __importDefault(require("@wdio/logger"));
-const log = (0, logger_1.default)('webdriverio/click');
+import { getBrowserObject } from '../../utils/index.js';
 /**
  *
  * Click on an element.
@@ -84,58 +78,49 @@ const log = (0, logger_1.default)('webdriverio/click');
  * @param {number=}           options.y      Number (optional)
  * @param {number=}           options.skipRelease         Boolean (optional)
  */
-async function click(options) {
+export default async function click(options) {
     if (typeof options === 'undefined') {
         return this.elementClick(this.elementId);
     }
     if (typeof options !== 'object' || Array.isArray(options)) {
         throw new TypeError('Options must be an object');
     }
-    let { button = 0, x: xoffset = 0, y: yoffset = 0, skipRelease = false } = options || {};
+    let button = (options.button || 0);
+    let { x: xoffset = 0, y: yoffset = 0, skipRelease = false } = options || {};
     if (typeof xoffset !== 'number'
         || typeof yoffset !== 'number'
         || !Number.isInteger(xoffset)
         || !Number.isInteger(yoffset)) {
         throw new TypeError('Coordinates must be integers');
     }
-    if (button === 'left') {
+    if (options.button === 'left') {
         button = 0;
     }
-    if (button === 'middle') {
+    if (options.button === 'middle') {
         button = 1;
     }
-    if (button === 'right') {
+    if (options.button === 'right') {
         button = 2;
     }
     if (![0, 1, 2].includes(button)) {
         throw new Error('Button type not supported.');
     }
     if (this.isW3C) {
-        await this.performActions([{
-                type: 'pointer',
-                id: 'pointer1',
-                parameters: {
-                    pointerType: 'mouse'
-                },
-                actions: [{
-                        type: 'pointerMove',
-                        origin: this,
-                        x: xoffset,
-                        y: yoffset
-                    }, {
-                        type: 'pointerDown',
-                        button
-                    }, {
-                        type: 'pointerUp',
-                        button
-                    }]
-            }]);
-        if (!skipRelease)
-            await this.releaseActions().then(() => null, (err) => log.warn(`Failed to call "releaseAction" command due to: ${err.message}, ignoring!`));
+        const browser = getBrowserObject(this);
+        await browser.action('pointer', {
+            parameters: { pointerType: 'mouse' }
+        })
+            .move({
+            origin: this,
+            x: xoffset,
+            y: yoffset
+        })
+            .down({ button })
+            .up({ button })
+            .perform(skipRelease);
         return;
     }
     const { width, height } = await this.getElementSize(this.elementId);
     await this.moveToElement(this.elementId, xoffset + (width / 2), yoffset + (height / 2));
     return this.positionClick(button);
 }
-exports.default = click;

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

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const getElementObject_1 = require("../../utils/getElementObject");
-const utils_1 = require("../../utils");
-const constants_1 = require("../../constants");
+import { getElements } from '../../utils/getElementObject.js';
+import { getBrowserObject, enhanceElementsArray } from '../../utils/index.js';
+import { ELEMENT_KEY } from '../../constants.js';
 /**
  *
  * The `customs$$` allows you to use a custom strategy declared by using `browser.addLocatorStrategy`
@@ -28,7 +26,7 @@ const constants_1 = require("../../constants");
  * @return {ElementArray}
  */
 async function custom$$(strategyName, ...strategyArguments) {
-    const browserObject = (0, utils_1.getBrowserObject)(this);
+    const browserObject = getBrowserObject(this);
     const strategy = browserObject.strategies.get(strategyName);
     if (!strategy) {
         /* istanbul ignore next */
@@ -42,7 +40,7 @@ async function custom$$(strategyName, ...strategyArguments) {
         throw Error(`Can't call custom$ on element with selector "${this.selector}" because element wasn't found`);
     }
     const strategyRef = { strategy, strategyName, strategyArguments: [...strategyArguments, this] };
-    let res = await this.execute(strategy, ...strategyArguments, this);
+    let res = await browserObject.execute(strategy, ...strategyArguments, this);
     /**
      * if the user's script return just one element
      * then we convert it to an array as this method
@@ -51,8 +49,8 @@ async function custom$$(strategyName, ...strategyArguments) {
     if (!Array.isArray(res)) {
         res = [res];
     }
-    res = res.filter((el) => !!el && typeof el[constants_1.ELEMENT_KEY] === 'string');
-    const elements = res.length ? await getElementObject_1.getElements.call(this, strategyRef, res) : [];
-    return (0, utils_1.enhanceElementsArray)(elements, this, strategyName, 'custom$$', strategyArguments);
+    res = res.filter((el) => !!el && typeof el[ELEMENT_KEY] === 'string');
+    const elements = res.length ? await getElements.call(this, strategyRef, res) : [];
+    return enhanceElementsArray(elements, this, strategyName, 'custom$$', strategyArguments);
 }
-exports.default = custom$$;
+export default custom$$;

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

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const getElementObject_1 = require("../../utils/getElementObject");
-const utils_1 = require("../../utils");
-const constants_1 = require("../../constants");
+import { getElement } from '../../utils/getElementObject.js';
+import { getBrowserObject } from '../../utils/index.js';
+import { ELEMENT_KEY } from '../../constants.js';
 /**
  *
  * The `custom$` allows you to use a custom strategy declared by using `browser.addLocatorStrategy`
@@ -28,7 +26,7 @@ const constants_1 = require("../../constants");
  * @return {Element}
  */
 async function custom$(strategyName, ...strategyArguments) {
-    const browserObject = (0, utils_1.getBrowserObject)(this);
+    const browserObject = getBrowserObject(this);
     const strategy = browserObject.strategies.get(strategyName);
     if (!strategy) {
         throw Error('No strategy found for ' + strategyName);
@@ -41,7 +39,7 @@ async function custom$(strategyName, ...strategyArguments) {
         throw Error(`Can't call custom$ on element with selector "${this.selector}" because element wasn't found`);
     }
     const strategyRef = { strategy, strategyName, strategyArguments: [...strategyArguments, this] };
-    let res = await this.execute(strategy, ...strategyArguments, this);
+    let res = await browserObject.execute(strategy, ...strategyArguments, this);
     /**
      * if the user's script returns multiple elements
      * then we just return the first one as this method
@@ -50,9 +48,9 @@ async function custom$(strategyName, ...strategyArguments) {
     if (Array.isArray(res)) {
         res = res[0];
     }
-    if (res && typeof res[constants_1.ELEMENT_KEY] === 'string') {
-        return await getElementObject_1.getElement.call(this, strategyRef, res);
+    if (res && typeof res[ELEMENT_KEY] === 'string') {
+        return await getElement.call(this, strategyRef, res);
     }
     throw Error('Your locator strategy script must return an element');
 }
-exports.default = custom$;
+export default custom$;

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

@@ -1 +1 @@
-{"version":3,"file":"doubleClick.d.ts","sourceRoot":"","sources":["../../../src/commands/element/doubleClick.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAA8B,WAAW,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,iBAyBnE"}
+{"version":3,"file":"doubleClick.d.ts","sourceRoot":"","sources":["../../../src/commands/element/doubleClick.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAA8B,WAAW,CAAE,IAAI,EAAE,WAAW,CAAC,OAAO,iBAqBnE"}

package/build/commands/element/doubleClick.js

@@ -1,5 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+import { getBrowserObject } from '../../utils/index.js';
 /**
  *
  * Double-click on an element.
@@ -23,7 +22,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @type action
  *
  */
-async function doubleClick() {
+export default async function doubleClick() {
     /**
      * move to element
      */
@@ -34,18 +33,13 @@ async function doubleClick() {
     /**
      * W3C way of handle the double click actions
      */
-    return this.performActions([{
-            type: 'pointer',
-            id: 'pointer1',
-            parameters: { pointerType: 'mouse' },
-            actions: [
-                { type: 'pointerMove', origin: this, x: 0, y: 0 },
-                { type: 'pointerDown', button: 0 },
-                { type: 'pointerUp', button: 0 },
-                { type: 'pause', duration: 10 },
-                { type: 'pointerDown', button: 0 },
-                { type: 'pointerUp', button: 0 }
-            ]
-        }]);
+    const browser = getBrowserObject(this);
+    return browser.action('pointer', { parameters: { pointerType: 'mouse' } })
+        .move({ origin: this })
+        .down()
+        .up()
+        .pause(10)
+        .down()
+        .up()
+        .perform();
 }
-exports.default = doubleClick;

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

@@ -1 +1 @@
-{"version":3,"file":"dragAndDrop.d.ts","sourceRoot":"","sources":["../../../src/commands/element/dragAndDrop.ts"],"names":[],"mappings":"AAOA,aAAK,kBAAkB,GAAG;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,aAAK,kBAAkB,GAAG;IACtB,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,CAAC,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAA8B,WAAW,CACrC,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,MAAM,EAAE,WAAW,CAAC,OAAO,GAAG,kBAAkB,EAChD,EAAE,QAAa,EAAE,GAAE,kBAAuB,iBAyE7C"}
+{"version":3,"file":"dragAndDrop.d.ts","sourceRoot":"","sources":["../../../src/commands/element/dragAndDrop.ts"],"names":[],"mappings":"AAQA,aAAK,kBAAkB,GAAG;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,aAAK,kBAAkB,GAAG;IACtB,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,CAAC,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAA8B,WAAW,CACrC,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,MAAM,EAAE,WAAW,CAAC,OAAO,GAAG,kBAAkB,EAChD,EAAE,QAAa,EAAE,GAAE,kBAAuB,iBAqE7C"}

package/build/commands/element/dragAndDrop.js

@@ -1,6 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../../constants");
+import { ELEMENT_KEY } from '../../constants.js';
+import { getBrowserObject } from '../../utils/index.js';
 const ACTION_BUTTON = 0;
 const sleep = (time = 0) => new Promise((resolve) => setTimeout(resolve, time));
 /**
@@ -34,7 +33,7 @@ const sleep = (time = 0) => new Promise((resolve) => setTimeout(resolve, time));
  * @param {DragAndDropOptions=} options           dragAndDrop command options
  * @param {Number=}             options.duration  how long the drag should take place
  */
-async function dragAndDrop(target, { duration = 10 } = {}) {
+export default async function dragAndDrop(target, { duration = 10 } = {}) {
     const moveToCoordinates = target;
     const moveToElement = target;
     /**
@@ -73,8 +72,8 @@ async function dragAndDrop(target, { duration = 10 } = {}) {
         await sleep(duration);
         return this.buttonUp(ACTION_BUTTON);
     }
-    const sourceRef = { [constants_1.ELEMENT_KEY]: this[constants_1.ELEMENT_KEY] };
-    const targetRef = { [constants_1.ELEMENT_KEY]: moveToElement[constants_1.ELEMENT_KEY] };
+    const sourceRef = { [ELEMENT_KEY]: this[ELEMENT_KEY] };
+    const targetRef = { [ELEMENT_KEY]: moveToElement[ELEMENT_KEY] };
     const origin = sourceRef;
     const targetOrigin = isMovingToElement ? targetRef : 'pointer';
     const targetX = isMovingToElement ? 0 : moveToCoordinates.x;
@@ -82,17 +81,12 @@ async function dragAndDrop(target, { duration = 10 } = {}) {
     /**
      * W3C way of handle the drag and drop action
      */
-    return this.performActions([{
-            type: 'pointer',
-            id: 'finger1',
-            parameters: { pointerType: 'mouse' },
-            actions: [
-                { type: 'pointerMove', duration: 0, origin, x: 0, y: 0 },
-                { type: 'pointerDown', button: ACTION_BUTTON },
-                { type: 'pause', duration: 10 },
-                { type: 'pointerMove', duration, origin: targetOrigin, x: targetX, y: targetY },
-                { type: 'pointerUp', button: ACTION_BUTTON }
-            ]
-        }]).then(() => this.releaseActions());
+    const browser = getBrowserObject(this);
+    return browser.action('pointer')
+        .move({ duration: 0, origin, x: 0, y: 0 })
+        .down({ button: ACTION_BUTTON })
+        .pause(10)
+        .move({ duration, origin: targetOrigin, x: targetX, y: targetY })
+        .up({ button: ACTION_BUTTON })
+        .perform();
 }
-exports.default = dragAndDrop;

package/build/commands/element/getAttribute.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  *
  * Get an attribute from a DOM-element based on the attribute name.
@@ -26,7 +24,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @type property
  *
  */
-function getAttribute(attributeName) {
+export default function getAttribute(attributeName) {
     return this.getElementAttribute(this.elementId, attributeName);
 }
-exports.default = getAttribute;

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

@@ -67,5 +67,5 @@
  * @return {CSSProperty}             The specified css of the element
  *
  */
-export default function getCSSProperty(this: WebdriverIO.Element, cssProperty: string): Promise<import("../..").ParsedCSSValue>;
+export default function getCSSProperty(this: WebdriverIO.Element, cssProperty: string): Promise<import("../../types.js").ParsedCSSValue>;
 //# sourceMappingURL=getCSSProperty.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getCSSProperty.d.ts","sourceRoot":"","sources":["../../../src/commands/element/getCSSProperty.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAA8B,cAAc,CACxC,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,WAAW,EAAE,MAAM,2CAsCtB"}
+{"version":3,"file":"getCSSProperty.d.ts","sourceRoot":"","sources":["../../../src/commands/element/getCSSProperty.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAA8B,cAAc,CACxC,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,WAAW,EAAE,MAAM,oDAsCtB"}

package/build/commands/element/getCSSProperty.js

@@ -1,10 +1,5 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const css_shorthand_properties_1 = __importDefault(require("css-shorthand-properties"));
-const utils_1 = require("../../utils");
+import cssShorthandProps from 'css-shorthand-properties';
+import { parseCSS } from '../../utils/index.js';
 /**
  *
  * Get a css property from a DOM-element selected by given selector. The return value
@@ -74,18 +69,18 @@ const utils_1 = require("../../utils");
  * @return {CSSProperty}             The specified css of the element
  *
  */
-async function getCSSProperty(cssProperty) {
+export default async function getCSSProperty(cssProperty) {
     /**
      * Getting the css value of a shorthand property results in different results
      * given that the behavior of `getComputedStyle` is not defined in this case.
      * Therefore if we don't deal with a shorthand property run `getElementCSSValue`
      * otherwise expand it and run the command for each longhand property.
      */
-    if (!css_shorthand_properties_1.default.isShorthand(cssProperty)) {
+    if (!cssShorthandProps.isShorthand(cssProperty)) {
         const cssValue = await this.getElementCSSValue(this.elementId, cssProperty);
-        return (0, utils_1.parseCSS)(cssValue, cssProperty);
+        return parseCSS(cssValue, cssProperty);
     }
-    const properties = css_shorthand_properties_1.default.expand(cssProperty);
+    const properties = cssShorthandProps.expand(cssProperty);
     let cssValues = await Promise.all(properties.map((prop) => this.getElementCSSValue(this.elementId, prop)));
     /**
      * merge equal symmetrical values
@@ -103,6 +98,5 @@ async function getCSSProperty(cssProperty) {
         }
         cssValues = cssValues.slice(0, cssValues.length / 2);
     }
-    return (0, utils_1.parseCSS)(cssValues.join(' '), cssProperty);
+    return parseCSS(cssValues.join(' '), cssProperty);
 }
-exports.default = getCSSProperty;

package/build/commands/element/getComputedLabel.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  *
  * Get the computed WAI-ARIA label of an element.
@@ -18,7 +16,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @type property
  *
  */
-function getComputedLabel() {
+export default function getComputedLabel() {
     return this.getElementComputedLabel(this.elementId);
 }
-exports.default = getComputedLabel;

package/build/commands/element/getComputedRole.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  *
  * Get the computed WAI-ARIA label of an element.
@@ -18,7 +16,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @type property
  *
  */
-function getComputedRole() {
+export default function getComputedRole() {
     return this.getElementComputedRole(this.elementId);
 }
-exports.default = getComputedRole;

package/build/commands/element/getHTML.js

@@ -1,11 +1,6 @@
-"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 getHTML_1 = __importDefault(require("../../scripts/getHTML"));
+import { ELEMENT_KEY } from '../../constants.js';
+import { getBrowserObject } from '../../utils/index.js';
+import getHTMLScript from '../../scripts/getHTML.js';
 /**
  *
  * Get source code of specified DOM element by selector.
@@ -36,11 +31,10 @@ const getHTML_1 = __importDefault(require("../../scripts/getHTML"));
  * @type property
  *
  */
-function getHTML(includeSelectorTag = true) {
-    const browser = (0, utils_1.getBrowserObject)(this);
-    return browser.execute(getHTML_1.default, {
-        [constants_1.ELEMENT_KEY]: this.elementId,
+export default function getHTML(includeSelectorTag = true) {
+    const browser = getBrowserObject(this);
+    return browser.execute(getHTMLScript, {
+        [ELEMENT_KEY]: this.elementId,
         ELEMENT: this.elementId // jsonwp compatible
     }, includeSelectorTag);
 }
-exports.default = getHTML;

package/build/commands/element/getLocation.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../../utils");
+import { getElementRect } from '../../utils/index.js';
 /**
  *
  * Determine an element’s location on the page. The point (0, 0) refers to
@@ -31,7 +29,7 @@ const utils_1 = require("../../utils");
 async function getLocation(prop) {
     let location = {};
     if (this.isW3C) {
-        location = await (0, utils_1.getElementRect)(this);
+        location = await getElementRect(this);
         delete location.width;
         delete location.height;
     }
@@ -43,4 +41,4 @@ async function getLocation(prop) {
     }
     return location;
 }
-exports.default = getLocation;
+export default getLocation;