expect-webdriverio 5.6.9 → 6.0.0

package/lib/matchers/element/toHaveSize.js

@@ -1,32 +1,34 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareObject, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray, } from '../../utils.js';
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { compareObject, enhanceError, waitUntil, wrapExpectedWithArray, } from '../../utils.js';
 async function condition(el, size) {
     const actualSize = await el.getSize();
     return compareObject(actualSize, size);
 }
 export async function toHaveSize(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'size', verb = 'have' } = this;
+    const { expectation = 'size', verb = 'have', isNot, matcherName = 'toHaveSize' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveSize',
+        matcherName,
         expectedValue,
         options,
     });
-    let el = await received?.getElement();
-    let actualSize;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
-        el = result.el;
-        actualSize = result.values;
-        return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualSize, expectedValue), actualSize, this, verb, expectation, '', options);
+    const { success: pass, actual: actualSize, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, expectedSize) => condition(element, expectedSize),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: false }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualSize, expectedValue), actualSize, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveSize',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toHaveStyle.js

@@ -1,31 +1,37 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareStyle, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { compareStyle, enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, style, options) {
+    if (style === undefined) {
+        return { success: false, actual: undefined };
+    }
     return compareStyle(el, style, options);
 }
 export async function toHaveStyle(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'style', verb = 'have' } = this;
+    const { expectation = 'style', verb = 'have', isNot, matcherName = 'toHaveStyle' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveStyle',
+        matcherName,
         expectedValue,
         options,
     });
-    let el = await received?.getElement();
-    let actualStyle;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
-        el = result.el;
-        actualStyle = result.values;
-        return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualStyle, expectedValue), actualStyle, this, verb, expectation, '', options);
+    const { success: pass, actual: actualStyle, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, expectedValues) => condition(element, expectedValues, options),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: false }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const expected = wrapExpectedWithArray(el, actualStyle, expectedValue);
+    const message = enhanceError(el, expected, actualStyle, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveStyle',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toHaveText.js

@@ -1,59 +1,41 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, text, options) {
-    const actualTextArray = [];
-    const resultArray = [];
-    let checkAllValuesMatchCondition;
-    if (Array.isArray(el)) {
-        for (const element of el) {
-            const actualText = await element.getText();
-            actualTextArray.push(actualText);
-            const result = Array.isArray(text)
-                ? compareTextWithArray(actualText, text, options).result
-                : compareText(actualText, text, options).result;
-            resultArray.push(result);
-        }
-        checkAllValuesMatchCondition = resultArray.every(Boolean);
-    }
-    else {
-        const actualText = await el.getText();
-        actualTextArray.push(actualText);
-        checkAllValuesMatchCondition = Array.isArray(text)
-            ? compareTextWithArray(actualText, text, options).result
-            : compareText(actualText, text, options).result;
-    }
-    return {
-        value: actualTextArray.length === 1 ? actualTextArray[0] : actualTextArray,
-        result: checkAllValuesMatchCondition
-    };
+import { compareTextOrArray, enhanceError, getFeatureFlagValue, waitUntil, } from '../../utils.js';
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { fillSingleExpectedForElementArray } from '../../util/elementsUtil.js';
+import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
+async function compareElement(el, expectedText, options) {
+    const actualText = await el.getText();
+    return compareTextOrArray(actualText, expectedText, options);
 }
 export async function toHaveText(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'text', verb = 'have' } = this;
+    const { expectation = 'text', verb = 'have', isNot, matcherName = 'toHaveText' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveText',
+        matcherName,
         expectedValue,
         options,
     });
-    let el = 'getElement' in received
-        ? await received?.getElement()
-        : 'getElements' in received
-            ? await received?.getElements()
-            : received;
-    let actualText;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
-        el = result.el;
-        actualText = result.values;
-        return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualText, expectedValue), actualText, this, verb, expectation, '', options);
+    expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
+    const isNewStrictCompare = getFeatureFlagValue(options, 'useToHaveTextStrictMultiElementsCompareStrategy');
+    const { success: pass, actual: actualText, subject: subject, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, values) => {
+                return compareElement(element, values, options);
+            },
+            context: { isNot, iteration },
+            strategy: isNewStrictCompare ? 'NewStrictMultipleElements' : 'LegacyLooseMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: true }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const expected = fillSingleExpectedForElementArray(subject, expectedValue);
+    const message = enhanceError(subject, expected, actualText, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveText',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toHaveWidth.js

@@ -1,46 +1,41 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareNumbers, enhanceError, executeCommand, numberError, waitUntil, } from '../../utils.js';
-async function condition(el, width, options) {
+import { wrapExpectedWithArray } from '../../util/elementsUtil.js';
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { validateNumberArrayAndExtractOptions } from '../../util/numberOptionsUtil.js';
+import { enhanceError, waitUntil, } from '../../utils.js';
+async function condition(el, expectedNumber) {
     const actualWidth = await el.getSize('width');
     return {
-        result: compareNumbers(actualWidth, options),
-        value: actualWidth
+        success: expectedNumber?.asymmetricMatch(actualWidth) ?? false,
+        actual: actualWidth
     };
 }
 export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'width', verb = 'have' } = this;
+    const { expectation = 'width', verb = 'have', isNot, matcherName = 'toHaveWidth' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveWidth',
+        matcherName,
         expectedValue,
         options,
     });
-    let numberOptions;
-    if (typeof expectedValue === 'number') {
-        numberOptions = { eq: expectedValue };
-    }
-    else if (!expectedValue || (typeof expectedValue.eq !== 'number' && typeof expectedValue.gte !== 'number' && typeof expectedValue.lte !== 'number')) {
-        throw new Error('Invalid params passed to toHaveHeight.');
-    }
-    else {
-        numberOptions = expectedValue;
-    }
-    let el = await received?.getElement();
-    let actualWidth;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, numberOptions, [expectedValue, numberOptions]);
-        el = result.el;
-        actualWidth = result.values;
-        return result.success;
-    }, isNot, { ...numberOptions, ...options });
-    const error = numberError(numberOptions);
-    const message = enhanceError(el, error, actualWidth, this, verb, expectation, '', options);
+    const { numberMatcher: expectedNumber, commandOptions } = validateNumberArrayAndExtractOptions(expectedValue, options);
+    const { success: pass, actual: actualWidth, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedNumber,
+            singleElementCompare: (element, expectedNumber) => condition(element, expectedNumber),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: false }
+        });
+    }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+    const expectedValues = wrapExpectedWithArray(elements, actualWidth, expectedNumber);
+    const message = enhanceError(elements, expectedValues, actualWidth, { isNot, isSome }, verb, expectation, '', commandOptions);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveWidth',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -1,47 +1,42 @@
-import { waitUntil, enhanceError, compareNumbers, numberError } from '../../utils.js';
-import { refetchElements } from '../../util/refetchElements.js';
+import { waitUntil, enhanceError, } from '../../utils.js';
+import { refetchElements, syncronizeElements } from '../../util/refetchElements.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { validateNumberAndExtractOptions } from '../../util/numberOptionsUtil.js';
+import { awaitElementArray, isStrictlyElementArray } from '../../util/elementsUtil.js';
 export async function toBeElementsArrayOfSize(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'elements array of size', verb = 'be' } = this;
+    const { expectation = 'elements array of size', verb = 'be', isNot, matcherName = 'toBeElementsArrayOfSize' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeElementsArrayOfSize',
+        matcherName,
         expectedValue,
         options,
     });
-    let numberOptions;
-    if (typeof expectedValue === 'number') {
-        numberOptions = { eq: expectedValue };
-    }
-    else if (!expectedValue || (typeof expectedValue.eq !== 'number' && typeof expectedValue.gte !== 'number' && typeof expectedValue.lte !== 'number')) {
-        throw new Error('Invalid params passed to toBeElementsArrayOfSize.');
-    }
-    else {
-        numberOptions = expectedValue;
-    }
-    let elements = await received;
-    const originalLength = elements.length;
-    const pass = await waitUntil(async () => {
-        const isPassing = compareNumbers(elements.length, numberOptions);
-        if (isPassing) {
-            return isPassing;
+    const { numberMatcher: expectedNumber, commandOptions } = validateNumberAndExtractOptions(expectedValue, options);
+    let { elements, other } = await awaitElementArray(received);
+    const originalLength = elements ? elements.length : undefined;
+    const { success: pass } = await waitUntil(async (iteration) => {
+        if (!elements) {
+            return { success: false, subject: elements, actual: undefined, abort: true };
+        }
+        else if (iteration > 0) {
+            elements = await refetchElements(elements);
         }
-        elements = await refetchElements(elements, numberOptions.wait, true);
-        return false;
-    }, isNot, { ...numberOptions, ...options });
-    if (Array.isArray(received) && pass) {
-        for (let index = originalLength; index < elements.length; index++) {
-            received.push(elements[index]);
+        const isPassing = expectedNumber.asymmetricMatch(elements.length);
+        if (isPassing) {
+            return { success: isPassing, subject: elements, actual: elements.length };
         }
+        return { success: false, subject: elements, actual: elements.length };
+    }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+    if (pass && originalLength !== undefined && elements !== received && (isStrictlyElementArray(received) || received instanceof Promise) && isStrictlyElementArray(elements)) {
+        await syncronizeElements(received, elements);
     }
-    const error = numberError(numberOptions);
-    const message = enhanceError(elements, error, originalLength, this, verb, expectation, '', numberOptions);
+    const actual = originalLength;
+    const message = enhanceError(elements ?? other, expectedNumber, actual, this, verb, expectation, '', commandOptions);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toBeElementsArrayOfSize',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/mock/toBeRequestedTimes.js

@@ -1,30 +1,25 @@
-import { waitUntil, enhanceError, compareNumbers } from '../../utils.js';
-import { numberError } from '../../util/formatMessage.js';
+import { waitUntil, enhanceError } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
-export async function toBeRequestedTimes(received, expectedValue = {}, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot || false;
-    const { expectation = `called${typeof expectedValue === 'number' ? ' ' + expectedValue : ''} time${expectedValue !== 1 ? 's' : ''}`, verb = 'be' } = this;
+import { validateNumberAndExtractOptions } from '../../util/numberOptionsUtil.js';
+export async function toBeRequestedTimes(received, expectedValue, options = DEFAULT_OPTIONS) {
+    const { verb = 'be', isNot, matcherName = 'toBeRequestedTimes', expectation = `called${typeof expectedValue === 'number' ? ' ' + expectedValue : ''} time${expectedValue !== 1 ? 's' : ''}`, } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeRequestedTimes',
+        matcherName,
         expectedValue,
         options,
     });
-    const numberOptions = typeof expectedValue === 'number'
-        ? { eq: expectedValue }
-        : expectedValue || {};
-    let actual;
-    const pass = await waitUntil(async () => {
-        actual = received.calls.length;
-        return compareNumbers(actual, numberOptions);
-    }, isNot, { ...numberOptions, ...options });
-    const error = numberError(numberOptions);
-    const message = enhanceError('mock', error, actual, this, verb, expectation, '', numberOptions);
+    const { numberMatcher: expectedNumber, commandOptions } = validateNumberAndExtractOptions(expectedValue, options);
+    const { success: pass, actual } = await waitUntil(async () => {
+        const actual = received.calls.length;
+        return { success: expectedNumber.asymmetricMatch(actual), subject: received, actual };
+    }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+    const message = enhanceError('mock', expectedNumber, actual, this, verb, expectation, '', commandOptions);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toBeRequestedTimes',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/mock/toBeRequestedWith.js

@@ -1,4 +1,4 @@
-import { waitUntil, enhanceError } from '../../utils.js';
+import { waitUntil, enhanceError, isAsymmetricMatcher, getAsymmetricMatcherValue } from '../../utils.js';
 import { equals } from '../../jasmineUtils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 const STR_LIMIT = 80;
@@ -10,26 +10,25 @@ function reduceHeaders(headers) {
     }, {});
 }
 export async function toBeRequestedWith(received, expectedValue = {}, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot || false;
-    const { expectation = 'called with', verb = 'be' } = this;
+    const { expectation = 'called with', verb = 'be', isNot, matcherName = 'toBeRequestedWith' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeRequestedWith',
+        matcherName,
         expectedValue,
         options,
     });
-    let actual;
-    const pass = await waitUntil(async () => {
+    const { success: pass, actual } = await waitUntil(async () => {
+        let lastCall;
         for (const call of received.calls) {
-            actual = call;
+            lastCall = call;
             if (methodMatcher(call.request.method, expectedValue.method) &&
                 statusCodeMatcher(call.response.status, expectedValue.statusCode) &&
                 urlMatcher(call.request.url, expectedValue.url) &&
                 headersMatcher(reduceHeaders(call.request.headers), expectedValue.requestHeaders) &&
                 headersMatcher(reduceHeaders(call.response.headers), expectedValue.responseHeaders)) {
-                return true;
+                return { success: true, subject: call, actual: call };
             }
         }
-        return false;
+        return { success: false, subject: lastCall, actual: lastCall };
     }, isNot, { ...options, wait: isNot ? 0 : options.wait });
     const message = enhanceError('mock', minifyRequestedWith(expectedValue), minifyRequestMock(actual, expectedValue) || 'was not called', this, verb, expectation, '', options);
     const result = {
@@ -37,7 +36,7 @@ export async function toBeRequestedWith(received, expectedValue = {}, options =
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toBeRequestedWith',
+        matcherName,
         expectedValue,
         options,
         result
@@ -88,15 +87,6 @@ const headersMatcher = (headers, expected) => {
     }
     return equals(headers, expected);
 };
-const isMatcher = (filter) => {
-    const proto = Object.getPrototypeOf(filter);
-    return (typeof filter === 'object' &&
-        filter !== null &&
-        typeof proto === 'object' &&
-        proto &&
-        'asymmetricMatch' in proto &&
-        typeof proto.asymmetricMatch === 'function');
-};
 const minifyRequestMock = (requestMock, requestedWith) => {
     if (requestMock === undefined) {
         return requestMock;
@@ -129,10 +119,10 @@ const requestedWithParamToString = (param, transformFn) => {
     if (typeof param === 'function') {
         param = param.toString();
     }
-    else if (isMatcher(param)) {
-        return (param.constructor.name +
-            ' ' +
-            (JSON.stringify(param.sample) || ''));
+    else if (isAsymmetricMatcher(param)) {
+        const sample = getAsymmetricMatcherValue(param);
+        const sampleString = typeof sample === 'string' ? sample : sample instanceof RegExp ? sample.toString() : JSON.stringify(sample) || sample?.toString();
+        return `${param.constructor.name} ${sampleString || ''}`;
     }
     else if (transformFn && typeof param === 'object' && param !== null) {
         param = transformFn(param);

package/lib/matchers/modifiers/some.js

@@ -0,0 +1,15 @@
+const SOME_TAG = 'expect-webdriverio.some';
+const SOME_SYMBOL = Symbol.for(SOME_TAG);
+export class SomeElementsWrapper {
+    elements;
+    [SOME_SYMBOL] = true;
+    constructor(elements) {
+        this.elements = elements;
+    }
+}
+export function some(elements) {
+    return new SomeElementsWrapper(elements);
+}
+export function isSomeWrapper(value) {
+    return value instanceof SomeElementsWrapper;
+}

package/lib/matchers.js

@@ -12,9 +12,9 @@ export * from './matchers/element/toBeFocused.js';
 export * from './matchers/element/toBeSelected.js';
 export * from './matchers/element/toHaveAttribute.js';
 export * from './matchers/element/toHaveChildren.js';
-export * from './matchers/element/toHaveClass.js';
 export * from './matchers/element/toHaveComputedLabel.js';
 export * from './matchers/element/toHaveComputedRole.js';
+export * from './matchers/element/toHaveElementClass.js';
 export * from './matchers/element/toHaveElementProperty.js';
 export * from './matchers/element/toHaveHeight.js';
 export * from './matchers/element/toHaveHref.js';

package/lib/tsconfig.build.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/constants.ts","../src/index.ts","../src/jasmineUtils.ts","../src/matchers.ts","../src/snapshot.ts","../src/softAssert.ts","../src/softAssertService.ts","../src/softExpect.ts","../src/types.ts","../src/utils.ts","../src/matchers/snapshot.ts","../src/matchers/browser/toHaveClipboardText.ts","../src/matchers/browser/toHaveLocalStorageItem.ts","../src/matchers/browser/toHaveTitle.ts","../src/matchers/browser/toHaveUrl.ts","../src/matchers/element/toBeClickable.ts","../src/matchers/element/toBeDisabled.ts","../src/matchers/element/toBeDisplayed.ts","../src/matchers/element/toBeDisplayedInViewport.ts","../src/matchers/element/toBeEnabled.ts","../src/matchers/element/toBeExisting.ts","../src/matchers/element/toBeFocused.ts","../src/matchers/element/toBeSelected.ts","../src/matchers/element/toHaveAttribute.ts","../src/matchers/element/toHaveChildren.ts","../src/matchers/element/toHaveClass.ts","../src/matchers/element/toHaveComputedLabel.ts","../src/matchers/element/toHaveComputedRole.ts","../src/matchers/element/toHaveElementProperty.ts","../src/matchers/element/toHaveHTML.ts","../src/matchers/element/toHaveHeight.ts","../src/matchers/element/toHaveHref.ts","../src/matchers/element/toHaveId.ts","../src/matchers/element/toHaveSize.ts","../src/matchers/element/toHaveStyle.ts","../src/matchers/element/toHaveText.ts","../src/matchers/element/toHaveValue.ts","../src/matchers/element/toHaveWidth.ts","../src/matchers/elements/toBeElementsArrayOfSize.ts","../src/matchers/mock/toBeRequested.ts","../src/matchers/mock/toBeRequestedTimes.ts","../src/matchers/mock/toBeRequestedWith.ts","../src/util/elementsUtil.ts","../src/util/executeCommand.ts","../src/util/formatMessage.ts","../src/util/refetchElements.ts"],"version":"5.9.3"}
+{"root":["../src/constants.ts","../src/index.ts","../src/jasmineUtils.ts","../src/matchers.ts","../src/snapshot.ts","../src/softAssert.ts","../src/softAssertService.ts","../src/softExpect.ts","../src/types.ts","../src/utils.ts","../src/matchers/snapshot.ts","../src/matchers/asymmetrics/asymmetricsUtils.ts","../src/matchers/asymmetrics/oneOf.ts","../src/matchers/browser/toHaveClipboardText.ts","../src/matchers/browser/toHaveLocalStorageItem.ts","../src/matchers/browser/toHaveTitle.ts","../src/matchers/browser/toHaveUrl.ts","../src/matchers/element/toBeClickable.ts","../src/matchers/element/toBeDisabled.ts","../src/matchers/element/toBeDisplayed.ts","../src/matchers/element/toBeDisplayedInViewport.ts","../src/matchers/element/toBeEnabled.ts","../src/matchers/element/toBeExisting.ts","../src/matchers/element/toBeFocused.ts","../src/matchers/element/toBeSelected.ts","../src/matchers/element/toHaveAttribute.ts","../src/matchers/element/toHaveChildren.ts","../src/matchers/element/toHaveComputedLabel.ts","../src/matchers/element/toHaveComputedRole.ts","../src/matchers/element/toHaveElementClass.ts","../src/matchers/element/toHaveElementProperty.ts","../src/matchers/element/toHaveHTML.ts","../src/matchers/element/toHaveHeight.ts","../src/matchers/element/toHaveHref.ts","../src/matchers/element/toHaveId.ts","../src/matchers/element/toHaveSize.ts","../src/matchers/element/toHaveStyle.ts","../src/matchers/element/toHaveText.ts","../src/matchers/element/toHaveValue.ts","../src/matchers/element/toHaveWidth.ts","../src/matchers/elements/toBeElementsArrayOfSize.ts","../src/matchers/mock/toBeRequested.ts","../src/matchers/mock/toBeRequestedTimes.ts","../src/matchers/mock/toBeRequestedWith.ts","../src/matchers/modifiers/some.ts","../src/util/commandOptionsUtils.ts","../src/util/elementsUtil.ts","../src/util/executeCommand.ts","../src/util/formatMessage.ts","../src/util/numberOptionsUtil.ts","../src/util/refetchElements.ts","../src/util/stringUtil.ts","../src/util/waitUntil.ts"],"version":"5.9.3"}

package/lib/util/commandOptionsUtils.js

@@ -0,0 +1,6 @@
+export const isDefinedPlainObject = (obj) => {
+    if (typeof obj === 'object' && obj !== null && !Array.isArray(obj)) {
+        return true;
+    }
+    return false;
+};

package/lib/util/elementsUtil.js

@@ -1,9 +1,79 @@
-export const wrapExpectedWithArray = (el, actual, expected) => {
-    if (Array.isArray(el) && el.length > 1 && Array.isArray(actual)) {
-        expected = [expected];
+export const wrapExpectedWithArray = (elements, actual, expected) => {
+    if (Array.isArray(elements) && Array.isArray(actual) && !Array.isArray(expected)) {
+        expected = Array(actual.length).fill(expected);
     }
     return expected;
 };
+export const fillSingleExpectedForElementArray = (subject, value) => {
+    if (isElementArrayLike(subject) && !Array.isArray(value)) {
+        const fillerlength = subject.length > 0 ? subject.length : 1;
+        return Array(fillerlength).fill(value);
+    }
+    return value;
+};
+export const isArray = (obj) => {
+    return Array.isArray(obj);
+};
+export const isSelector = (obj) => {
+    return !!obj
+        && typeof obj === 'object'
+        && 'selector' in obj
+        && 'parent' in obj;
+};
 export const isElementArray = (obj) => {
-    return obj !== null && typeof obj === 'object' && 'selector' in obj && 'foundWith' in obj && 'parent' in obj;
+    return isSelector(obj)
+        && 'foundWith' in obj;
+};
+export const isStrictlyElementArray = (obj) => {
+    return isElementArray(obj)
+        && Array.isArray(obj)
+        && 'getElements' in obj;
+};
+export const isElement = (obj) => {
+    return isSelector(obj)
+        && !Array.isArray(obj)
+        && 'getElement' in obj;
+};
+export const isElementArrayLike = (obj) => {
+    return !!obj && (isStrictlyElementArray(obj) || (Array.isArray(obj) && obj.every(isElement)));
+};
+export const isArrayOfElement = (obj) => {
+    return Array.isArray(obj) && obj.every(isElement);
+};
+export const isElementOrArrayLike = (obj) => {
+    return !!obj && (isElement(obj) || isElementArrayLike(obj));
+};
+export const awaitElementOrArray = async (received) => {
+    if (!received || typeof received !== 'object') {
+        return { other: received };
+    }
+    let awaitedElements = received;
+    if (awaitedElements instanceof Promise) {
+        awaitedElements = await awaitedElements;
+    }
+    if (!isElementOrArrayLike(awaitedElements)) {
+        return { other: awaitedElements };
+    }
+    if ('getElement' in awaitedElements) {
+        const element = await awaitedElements.getElement();
+        return { selector: element, element };
+    }
+    if ('getElements' in awaitedElements) {
+        const elements = await awaitedElements.getElements();
+        return { selector: elements, elements, isEmptyElements: elements.length === 0 };
+    }
+    return { selector: awaitedElements, elements: awaitedElements, isEmptyElements: awaitedElements.length === 0 };
+};
+export const awaitElementArray = async (received) => {
+    let awaitedElements = received;
+    if (awaitedElements instanceof Promise) {
+        awaitedElements = await awaitedElements;
+    }
+    if (!isElementArrayLike(awaitedElements)) {
+        return { other: awaitedElements };
+    }
+    if ('getElements' in awaitedElements) {
+        return { elements: await awaitedElements.getElements() };
+    }
+    return { elements: awaitedElements };
 };