expect-webdriverio 3.4.0 → 4.0.0-alpha.2

package/jest.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="expect-webdriverio/types/expect-webdriverio"/>
+/// <reference types="./types/expect-webdriverio"/>
 
 declare namespace jest {
     interface Matchers<R, T> extends ExpectWebdriverIO.Matchers<R, T> { }

package/lib/constants.js

@@ -0,0 +1,4 @@
+export const DEFAULT_OPTIONS = {
+    wait: 2000,
+    interval: 100,
+};

package/lib/index.js

@@ -1,6 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setOptions = void 0;
-const addMatchers_1 = require("./addMatchers");
-(0, addMatchers_1.addMatchers)();
-exports.setOptions = require('./options').setDefaultOptions;
+import expectLib from 'expect';
+import matchers from './matchers.js';
+import { DEFAULT_OPTIONS } from './constants.js';
+export const getConfig = () => DEFAULT_OPTIONS;
+export const setDefaultOptions = (options = {}) => {
+    Object.entries(options).forEach(([key, value]) => {
+        if (key in DEFAULT_OPTIONS) {
+            DEFAULT_OPTIONS[key] = value;
+        }
+    });
+};
+export const expect = async () => {
+    return expectLib.extend({ ...matchers });
+};
+export const setOptions = setDefaultOptions;

package/lib/jasmineUtils.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImmutableUnorderedSet = exports.isImmutableUnorderedKeyed = exports.hasProperty = exports.isUndefined = exports.fnNameFor = exports.isA = exports.equals = void 0;
-function equals(a, b, customTesters, strictCheck) {
+export function equals(a, b, customTesters, strictCheck) {
     customTesters = customTesters || [];
     return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
 }
-exports.equals = equals;
 const functionToString = Function.prototype.toString;
 function isAsymmetric(obj) {
     return !!obj && isA('Function', obj.asymmetricMatch);
@@ -144,10 +140,9 @@ function hasDefinedKey(obj, key) {
 function hasKey(obj, key) {
     return Object.prototype.hasOwnProperty.call(obj, key);
 }
-function isA(typeName, value) {
+export function isA(typeName, value) {
     return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
 }
-exports.isA = isA;
 function isDomNode(obj) {
     return (obj !== null &&
         typeof obj === 'object' &&
@@ -155,7 +150,7 @@ function isDomNode(obj) {
         typeof obj.nodeName === 'string' &&
         typeof obj.isEqualNode === 'function');
 }
-function fnNameFor(func) {
+export function fnNameFor(func) {
     if (func.name) {
         return func.name;
     }
@@ -164,11 +159,9 @@ function fnNameFor(func) {
         .match(/^(?:async)?\s*function\s*\*?\s*([\w$]+)\s*\(/);
     return matches ? matches[1] : '<anonymous>';
 }
-exports.fnNameFor = fnNameFor;
-function isUndefined(obj) {
+export function isUndefined(obj) {
     return obj === void 0;
 }
-exports.isUndefined = isUndefined;
 function getPrototype(obj) {
     if (Object.getPrototypeOf) {
         return Object.getPrototypeOf(obj);
@@ -178,7 +171,7 @@ function getPrototype(obj) {
     }
     return obj.constructor.prototype;
 }
-function hasProperty(obj, property) {
+export function hasProperty(obj, property) {
     if (!obj) {
         return false;
     }
@@ -187,19 +180,16 @@ function hasProperty(obj, property) {
     }
     return hasProperty(getPrototype(obj), property);
 }
-exports.hasProperty = hasProperty;
 const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
 const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
 const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
-function isImmutableUnorderedKeyed(maybeKeyed) {
+export function isImmutableUnorderedKeyed(maybeKeyed) {
     return !!(maybeKeyed &&
         maybeKeyed[IS_KEYED_SENTINEL] &&
         !maybeKeyed[IS_ORDERED_SENTINEL]);
 }
-exports.isImmutableUnorderedKeyed = isImmutableUnorderedKeyed;
-function isImmutableUnorderedSet(maybeSet) {
+export function isImmutableUnorderedSet(maybeSet) {
     return !!(maybeSet &&
         maybeSet[IS_SET_SENTINEL] &&
         !maybeSet[IS_ORDERED_SENTINEL]);
 }
-exports.isImmutableUnorderedSet = isImmutableUnorderedSet;

package/lib/matchers/browser/toHaveTitle.js

@@ -1,26 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveTitle = exports.toHaveTitleFn = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const utils_1 = require("../../utils");
-function toHaveTitleFn(browser, title, options = {}) {
+import { waitUntil, enhanceError, compareText } from '../../utils.js';
+export function toHaveTitle(browser, title, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'title', verb = 'have' } = this;
     return browser.call(async () => {
         let actual;
-        const pass = await (0, utils_1.waitUntil)(async () => {
+        const pass = await waitUntil(async () => {
             actual = await browser.getTitle();
-            return (0, utils_1.compareText)(actual, title, options).result;
+            return compareText(actual, title, options).result;
         }, isNot, options);
-        const message = (0, utils_1.enhanceError)('window', title, actual, this, verb, expectation, '', options);
+        const message = enhanceError('window', title, actual, this, verb, expectation, '', options);
         return {
             pass,
             message: () => message
         };
     });
 }
-exports.toHaveTitleFn = toHaveTitleFn;
-function toHaveTitle(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveTitleFn, args);
-}
-exports.toHaveTitle = toHaveTitle;

package/lib/matchers/browser/toHaveTitleContaining.js

@@ -1,15 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveTitleContaining = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveTitle_1 = require("./toHaveTitle");
-function toHaveTitleContainingFn(browser, title, options = {}) {
-    return toHaveTitle_1.toHaveTitleFn.call(this, browser, title, {
+import { toHaveTitle } from './toHaveTitle.js';
+export function toHaveTitleContaining(browser, title, options = {}) {
+    return toHaveTitle.call(this, browser, title, {
         ...options,
         containing: true
     });
 }
-function toHaveTitleContaining(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveTitleContainingFn, args);
-}
-exports.toHaveTitleContaining = toHaveTitleContaining;

package/lib/matchers/browser/toHaveUrl.js

@@ -1,26 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveUrl = exports.toHaveUrlFn = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const utils_1 = require("../../utils");
-function toHaveUrlFn(browser, url, options = {}) {
+import { waitUntil, enhanceError, compareText } from '../../utils.js';
+export function toHaveUrl(browser, url, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'url', verb = 'have' } = this;
     return browser.call(async () => {
         let actual;
-        const pass = await (0, utils_1.waitUntil)(async () => {
+        const pass = await waitUntil(async () => {
             actual = await browser.getUrl();
-            return (0, utils_1.compareText)(actual, url, options).result;
+            return compareText(actual, url, options).result;
         }, isNot, options);
-        const message = (0, utils_1.enhanceError)('window', url, actual, this, verb, expectation, '', options);
+        const message = enhanceError('window', url, actual, this, verb, expectation, '', options);
         return {
             pass,
             message: () => message
         };
     });
 }
-exports.toHaveUrlFn = toHaveUrlFn;
-function toHaveUrl(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveUrlFn, args);
-}
-exports.toHaveUrl = toHaveUrl;

package/lib/matchers/browser/toHaveUrlContaining.js

@@ -1,15 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveUrlContaining = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveUrl_1 = require("./toHaveUrl");
-function toHaveUrlContainingFn(browser, url, options = {}) {
-    return toHaveUrl_1.toHaveUrlFn.call(this, browser, url, {
+import { toHaveUrl } from './toHaveUrl.js';
+export function toHaveUrlContaining(browser, url, options = {}) {
+    return toHaveUrl.call(this, browser, url, {
         ...options,
         containing: true
     });
 }
-function toHaveUrlContaining(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveUrlContainingFn, args);
-}
-exports.toHaveUrlContaining = toHaveUrlContaining;

package/lib/matchers/element/toBeClickable.js

@@ -1,23 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeClickable = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeClickableFn(received, options = {}) {
+import { browser } from '@wdio/globals';
+import { executeCommandBe } from '../../utils.js';
+export function toBeClickable(received, options = {}) {
     this.expectation = this.expectation || 'clickable';
     return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, async (el) => {
+        const result = await executeCommandBe.call(this, received, async (el) => {
             try {
                 return el.isClickable();
             }
-            catch (_a) {
+            catch {
                 return false;
             }
         }, options);
         return result;
     });
 }
-function toBeClickable(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toBeClickableFn, args);
-}
-exports.toBeClickable = toBeClickable;

package/lib/matchers/element/toBeDisabled.js

@@ -1,16 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeDisabled = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeDisabledFn(received, options = {}) {
+import { browser } from '@wdio/globals';
+import { executeCommandBe } from '../../utils.js';
+export function toBeDisabled(received, options = {}) {
     this.expectation = this.expectation || 'disabled';
     return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, async (el) => !await el.isEnabled(), options);
+        const result = await executeCommandBe.call(this, received, async (el) => !await el.isEnabled(), options);
         return result;
     });
 }
-function toBeDisabled(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toBeDisabledFn, args);
-}
-exports.toBeDisabled = toBeDisabled;

package/lib/matchers/element/toBeDisplayed.js

@@ -1,23 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeDisplayed = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeDisplayedFn(received, options = {}) {
+import { browser } from '@wdio/globals';
+import { executeCommandBe } from '../../utils.js';
+export function toBeDisplayed(received, options = {}) {
     this.expectation = this.expectation || 'displayed';
     return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, async (el) => {
+        const result = await executeCommandBe.call(this, received, async (el) => {
             try {
                 return el.isDisplayed();
             }
-            catch (_a) {
+            catch {
                 return false;
             }
         }, options);
         return result;
     });
 }
-function toBeDisplayed(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toBeDisplayedFn, args);
-}
-exports.toBeDisplayed = toBeDisplayed;

package/lib/matchers/element/toBeDisplayedInViewport.js

@@ -1,23 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeDisplayedInViewport = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeDisplayedInViewportFn(received, options = {}) {
+import { browser } from '@wdio/globals';
+import { executeCommandBe } from '../../utils.js';
+export function toBeDisplayedInViewport(received, options = {}) {
     this.expectation = this.expectation || 'displayed in viewport';
     return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, async (el) => {
+        const result = await executeCommandBe.call(this, received, async (el) => {
             try {
                 return el.isDisplayedInViewport();
             }
-            catch (_a) {
+            catch {
                 return false;
             }
         }, options);
         return result;
     });
 }
-function toBeDisplayedInViewport(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toBeDisplayedInViewportFn, args);
-}
-exports.toBeDisplayedInViewport = toBeDisplayedInViewport;

package/lib/matchers/element/toBeEnabled.js

@@ -1,16 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeEnabled = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeEnabledFn(received, options = {}) {
+import { browser } from '@wdio/globals';
+import { executeCommandBe } from '../../utils.js';
+export function toBeEnabled(received, options = {}) {
     this.expectation = this.expectation || 'enabled';
     return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, el => el.isEnabled(), options);
+        const result = await executeCommandBe.call(this, received, el => el.isEnabled(), options);
         return result;
     });
 }
-function toBeEnabled(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toBeEnabledFn, args);
-}
-exports.toBeEnabled = toBeEnabled;

package/lib/matchers/element/toBeExisting.js

@@ -1,32 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBePresent = exports.toBeExisting = exports.toExist = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toExistFn(received, options = {}) {
+import { browser } from '@wdio/globals';
+import { executeCommandBe, aliasFn } from '../../utils.js';
+export function toExist(received, options = {}) {
     this.expectation = this.expectation || 'exist';
     this.verb = this.verb || '';
     return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, async (el) => {
+        const result = await executeCommandBe.call(this, received, async (el) => {
             try {
                 return el.isExisting();
             }
-            catch (_a) {
+            catch {
                 return false;
             }
         }, options);
         return result;
     });
 }
-function toExist(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toExistFn, args);
+export function toBeExisting(el, options) {
+    return aliasFn.call(this, toExist, { verb: 'be', expectation: 'existing' }, el, options);
 }
-exports.toExist = toExist;
-function toBeExisting(el, options) {
-    return utils_1.aliasFn.call(this, toExist, { verb: 'be', expectation: 'existing' }, el, options);
+export function toBePresent(el, options) {
+    return aliasFn.call(this, toExist, { verb: 'be', expectation: 'present' }, el, options);
 }
-exports.toBeExisting = toBeExisting;
-function toBePresent(el, options) {
-    return utils_1.aliasFn.call(this, toExist, { verb: 'be', expectation: 'present' }, el, options);
-}
-exports.toBePresent = toBePresent;

package/lib/matchers/element/toBeFocused.js

@@ -1,16 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeFocused = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeFocusedFn(received, options = {}) {
+import { browser } from '@wdio/globals';
+import { executeCommandBe } from '../../utils.js';
+export function toBeFocused(received, options = {}) {
     this.expectation = this.expectation || 'focused';
     return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, el => el.isFocused(), options);
+        const result = await executeCommandBe.call(this, received, el => el.isFocused(), options);
         return result;
     });
 }
-function toBeFocused(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toBeFocusedFn, args);
-}
-exports.toBeFocused = toBeFocused;

package/lib/matchers/element/toBeSelected.js

@@ -1,22 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBeChecked = exports.toBeSelected = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
-function toBeSelectedFn(received, options = {}) {
+import { browser } from '@wdio/globals';
+import { executeCommandBe } from '../../utils.js';
+export function toBeSelected(received, options = {}) {
     this.expectation = this.expectation || 'selected';
     return browser.call(async () => {
-        const result = await utils_1.executeCommandBe.call(this, received, el => el.isSelected(), options);
+        const result = await executeCommandBe.call(this, received, el => el.isSelected(), options);
         return result;
     });
 }
-function toBeSelected(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toBeSelectedFn, args);
+export function toBeChecked(el, options) {
+    this.expectation = 'checked';
+    return toBeSelected.call(this, el, options);
 }
-exports.toBeSelected = toBeSelected;
-function toBeChecked(el, options) {
-    const context = (0, expectAdapter_1.getContext)(this);
-    context.expectation = 'checked';
-    return toBeSelected.call(context, el, options);
-}
-exports.toBeChecked = toBeChecked;

package/lib/matchers/element/toHaveAttribute.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveAttr = exports.toHaveAttribute = exports.toHaveAttributeFn = exports.toHaveAttributeAndValueFn = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
+import { browser } from '@wdio/globals';
+import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
 async function conditionAttr(el, attribute) {
     const attr = await el.getAttribute(attribute);
     if (typeof attr !== 'string') {
@@ -17,56 +14,53 @@ async function conditionAttrAndValue(el, attribute, value, options) {
     if (typeof attr !== 'string') {
         return { result: false, value: attr };
     }
-    return (0, utils_1.compareText)(attr, value, options);
+    return compareText(attr, value, options);
 }
-function toHaveAttributeAndValueFn(received, attribute, value, options = {}) {
+export function toHaveAttributeAndValueFn(received, attribute, value, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'attribute', verb = 'have' } = this;
     return browser.call(async () => {
         let el = await received;
         let attr;
-        const pass = await (0, utils_1.waitUntil)(async () => {
-            const result = await utils_1.executeCommand.call(this, el, conditionAttrAndValue, options, [attribute, value, options]);
+        const pass = await waitUntil(async () => {
+            const result = await executeCommand.call(this, el, conditionAttrAndValue, options, [attribute, value, options]);
             el = result.el;
             attr = result.values;
             return result.success;
         }, isNot, options);
-        (0, utils_1.updateElementsArray)(pass, received, el);
-        const expected = (0, utils_1.wrapExpectedWithArray)(el, attr, value);
-        const message = (0, utils_1.enhanceError)(el, expected, attr, this, verb, expectation, attribute, options);
+        updateElementsArray(pass, received, el);
+        const expected = wrapExpectedWithArray(el, attr, value);
+        const message = enhanceError(el, expected, attr, this, verb, expectation, attribute, options);
         return {
             pass,
             message: () => message
         };
     });
 }
-exports.toHaveAttributeAndValueFn = toHaveAttributeAndValueFn;
-function toHaveAttributeFn(received, attribute) {
+export function toHaveAttributeFn(received, attribute) {
     const isNot = this.isNot;
     const { expectation = 'attribute', verb = 'have' } = this;
     return browser.call(async () => {
         let el = await received;
-        const pass = await (0, utils_1.waitUntil)(async () => {
-            const result = await utils_1.executeCommand.call(this, el, conditionAttr, {}, [attribute]);
+        const pass = await waitUntil(async () => {
+            const result = await executeCommand.call(this, el, conditionAttr, {}, [attribute]);
             el = result.el;
             return result.success;
         }, isNot, {});
-        (0, utils_1.updateElementsArray)(pass, received, el);
-        const message = (0, utils_1.enhanceError)(el, !isNot, pass, this, verb, expectation, attribute, {});
+        updateElementsArray(pass, received, el);
+        const message = enhanceError(el, !isNot, pass, this, verb, expectation, attribute, {});
         return {
             pass,
             message: () => message
         };
     });
 }
-exports.toHaveAttributeFn = toHaveAttributeFn;
-function toHaveAttribute(...args) {
+export function toHaveAttribute(...args) {
     if (args.length === 3 || args.length === 4) {
-        return expectAdapter_1.runExpect.call(this || {}, toHaveAttributeAndValueFn, args);
+        return toHaveAttributeAndValueFn.call(this, ...args);
     }
     else {
-        return expectAdapter_1.runExpect.call(this || {}, toHaveAttributeFn, args);
+        return toHaveAttributeFn.call(this, ...args);
     }
 }
-exports.toHaveAttribute = toHaveAttribute;
-exports.toHaveAttr = toHaveAttribute;
+export const toHaveAttr = toHaveAttribute;

package/lib/matchers/element/toHaveAttributeContaining.js

@@ -1,16 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveAttrContaining = exports.toHaveAttributeContaining = void 0;
-const expectAdapter_1 = require("../../util/expectAdapter");
-const toHaveAttribute_1 = require("./toHaveAttribute");
-function toHaveAttributeContainingFn(el, attribute, value, options = {}) {
-    return toHaveAttribute_1.toHaveAttributeAndValueFn.call(this, el, attribute, value, {
+import { toHaveAttributeAndValueFn } from './toHaveAttribute.js';
+export function toHaveAttributeContaining(el, attribute, value, options = {}) {
+    return toHaveAttributeAndValueFn.call(this, el, attribute, value, {
         ...options,
         containing: true
     });
 }
-function toHaveAttributeContaining(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveAttributeContainingFn, args);
-}
-exports.toHaveAttributeContaining = toHaveAttributeContaining;
-exports.toHaveAttrContaining = toHaveAttributeContaining;
+export const toHaveAttrContaining = toHaveAttributeContaining;

package/lib/matchers/element/toHaveChildren.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHaveChildren = void 0;
-const utils_1 = require("../../utils");
-const expectAdapter_1 = require("../../util/expectAdapter");
+import { browser } from '@wdio/globals';
+import { waitUntil, enhanceError, compareNumbers, numberError, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
 async function condition(el, options) {
     const children = await el.$$('./*');
     if (typeof options.lte !== 'number' &&
@@ -10,15 +7,15 @@ async function condition(el, options) {
         typeof options.eq !== 'number') {
         return {
             result: children.length > 0,
-            value: children === null || children === void 0 ? void 0 : children.length
+            value: children?.length
         };
     }
     return {
-        result: (0, utils_1.compareNumbers)(children === null || children === void 0 ? void 0 : children.length, options),
-        value: children === null || children === void 0 ? void 0 : children.length
+        result: compareNumbers(children?.length, options),
+        value: children?.length
     };
 }
-function toHaveChildrenFn(received, expected, options = {}) {
+export function toHaveChildren(received, expected, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'children', verb = 'have' } = this;
     let numberOptions;
@@ -31,23 +28,19 @@ function toHaveChildrenFn(received, expected, options = {}) {
     return browser.call(async () => {
         let el = await received;
         let children;
-        const pass = await (0, utils_1.waitUntil)(async () => {
-            const result = await utils_1.executeCommand.call(this, el, condition, numberOptions, [numberOptions]);
+        const pass = await waitUntil(async () => {
+            const result = await executeCommand.call(this, el, condition, numberOptions, [numberOptions]);
             el = result.el;
             children = result.values;
             return result.success;
         }, isNot, { ...numberOptions, ...options });
-        (0, utils_1.updateElementsArray)(pass, received, el);
-        const error = (0, utils_1.numberError)(numberOptions);
-        const expected = (0, utils_1.wrapExpectedWithArray)(el, children, error);
-        const message = (0, utils_1.enhanceError)(el, expected, children, this, verb, expectation, '', numberOptions);
+        updateElementsArray(pass, received, el);
+        const error = numberError(numberOptions);
+        const expected = wrapExpectedWithArray(el, children, error);
+        const message = enhanceError(el, expected, children, this, verb, expectation, '', numberOptions);
         return {
             pass,
             message: () => message
         };
     });
 }
-function toHaveChildren(...args) {
-    return expectAdapter_1.runExpect.call(this || {}, toHaveChildrenFn, args);
-}
-exports.toHaveChildren = toHaveChildren;