expect-webdriverio 6.0.10 → 6.1.0

package/lib/constants.js

@@ -1,21 +1,31 @@
-export const DEFAULT_FEATURE_FLAGS = {
-    useToHaveTextStrictMultiElementsCompareStrategy: false
-};
-export const DEFAULT_OPTIONS = {
-    wait: 2000,
-    interval: 100,
-    beforeAssertion: async () => { },
-    afterAssertion: async () => { },
-    featureFlags: DEFAULT_FEATURE_FLAGS
-};
-export const DEFAULT_OPTIONS_TO_BE_DISPLAYED = {
-    ...DEFAULT_OPTIONS,
-    withinViewport: false,
-    contentVisibilityAuto: true,
-    opacityProperty: true,
-    visibilityProperty: true
-};
-export const defaultOptionsList = [
-    DEFAULT_OPTIONS,
-    DEFAULT_OPTIONS_TO_BE_DISPLAYED
-];
+import { getGlobalSingleton } from './util/globalSingleton.js';
+function createSharedConstants() {
+    const DEFAULT_FEATURE_FLAGS = {
+        useToHaveTextStrictMultiElementsCompareStrategy: false
+    };
+    const DEFAULT_OPTIONS = {
+        wait: 2000,
+        interval: 100,
+        beforeAssertion: async () => { },
+        afterAssertion: async () => { },
+        featureFlags: DEFAULT_FEATURE_FLAGS
+    };
+    const DEFAULT_OPTIONS_TO_BE_DISPLAYED = {
+        ...DEFAULT_OPTIONS,
+        withinViewport: false,
+        contentVisibilityAuto: true,
+        opacityProperty: true,
+        visibilityProperty: true
+    };
+    return {
+        DEFAULT_FEATURE_FLAGS,
+        DEFAULT_OPTIONS,
+        DEFAULT_OPTIONS_TO_BE_DISPLAYED,
+        defaultOptionsList: [DEFAULT_OPTIONS, DEFAULT_OPTIONS_TO_BE_DISPLAYED]
+    };
+}
+const shared = getGlobalSingleton('constants', createSharedConstants);
+export const DEFAULT_FEATURE_FLAGS = shared.DEFAULT_FEATURE_FLAGS;
+export const DEFAULT_OPTIONS = shared.DEFAULT_OPTIONS;
+export const DEFAULT_OPTIONS_TO_BE_DISPLAYED = shared.DEFAULT_OPTIONS_TO_BE_DISPLAYED;
+export const defaultOptionsList = shared.defaultOptionsList;

package/lib/index.js

@@ -4,41 +4,52 @@ import { DEFAULT_OPTIONS, defaultOptionsList } from './constants.js';
 import createSoftExpect from './softExpect.js';
 import { SoftAssertService } from './softAssert.js';
 import { oneOf } from './matchers/asymmetrics/oneOf.js';
-export const wdioCustomMatchers = {};
-export const matchers = new Map();
-const extend = expectLib.extend;
-expectLib.extend = (extendedMatchers) => {
-    if (!extendedMatchers || typeof extendedMatchers !== 'object') {
-        return;
-    }
-    Object.entries(extendedMatchers).forEach(([name, matcher]) => {
-        wdioCustomMatchers[name] = matcher;
-        matchers.set(name, matcher);
+import { getGlobalSingleton } from './util/globalSingleton.js';
+function createSharedExpectSetup() {
+    const wdioCustomMatchers = {};
+    const matchers = new Map();
+    const extend = expectLib.extend;
+    expectLib.extend = (extendedMatchers) => {
+        if (!extendedMatchers || typeof extendedMatchers !== 'object') {
+            return;
+        }
+        Object.entries(extendedMatchers).forEach(([name, matcher]) => {
+            wdioCustomMatchers[name] = matcher;
+            matchers.set(name, matcher);
+        });
+        return extend(extendedMatchers);
+    };
+    const filteredWdioMatchers = {};
+    Object.entries(wdioMatchers).forEach(([matcher, value]) => {
+        if (typeof value === 'function') {
+            filteredWdioMatchers[matcher] = value;
+        }
     });
-    return extend(extendedMatchers);
-};
-const filteredWdioMatchers = {};
-Object.entries(wdioMatchers).forEach(([matcher, value]) => {
-    if (typeof value === 'function') {
-        filteredWdioMatchers[matcher] = value;
-    }
-});
-const wdioExpect = expectLib;
-wdioExpect.extend(filteredWdioMatchers);
-wdioExpect.oneOf = oneOf;
-Object.defineProperty(wdioExpect, 'soft', {
-    value: (actual) => createSoftExpect(actual)
-});
-Object.defineProperty(wdioExpect, 'getSoftFailures', {
-    value: (testId) => SoftAssertService.getInstance().getFailures(testId)
-});
-Object.defineProperty(wdioExpect, 'assertSoftFailures', {
-    value: (testId) => SoftAssertService.getInstance().assertNoFailures(testId)
-});
-Object.defineProperty(wdioExpect, 'clearSoftFailures', {
-    value: (testId) => SoftAssertService.getInstance().clearFailures(testId)
-});
-export const expect = wdioExpect;
+    const wdioExpect = expectLib;
+    wdioExpect.extend(filteredWdioMatchers);
+    wdioExpect.oneOf = oneOf;
+    Object.defineProperty(wdioExpect, 'soft', {
+        configurable: true,
+        value: (actual) => createSoftExpect(actual)
+    });
+    Object.defineProperty(wdioExpect, 'getSoftFailures', {
+        configurable: true,
+        value: (testId) => SoftAssertService.getInstance().getFailures(testId)
+    });
+    Object.defineProperty(wdioExpect, 'assertSoftFailures', {
+        configurable: true,
+        value: (testId) => SoftAssertService.getInstance().assertNoFailures(testId)
+    });
+    Object.defineProperty(wdioExpect, 'clearSoftFailures', {
+        configurable: true,
+        value: (testId) => SoftAssertService.getInstance().clearFailures(testId)
+    });
+    return { wdioExpect, wdioCustomMatchers, matchers };
+}
+const sharedExpectSetup = getGlobalSingleton('expect', createSharedExpectSetup);
+export const wdioCustomMatchers = sharedExpectSetup.wdioCustomMatchers;
+export const matchers = sharedExpectSetup.matchers;
+export const expect = sharedExpectSetup.wdioExpect;
 export const getDefaultOptions = () => DEFAULT_OPTIONS;
 export const setDefaultOptions = (options) => {
     Object.entries(options).forEach(([key, value]) => {

package/lib/jasmineUtils.js

@@ -11,7 +11,10 @@ function asymmetricMatch(a, b) {
     if (asymmetricA && asymmetricB) {
         return undefined;
     }
-    const matchersUtil = { equals, contains: equals };
+    const matchersUtil = {
+        equals,
+        contains: (actual, expected) => actual.some(value => equals(value, expected)),
+    };
     if (asymmetricA) {
         return a.asymmetricMatch(b, matchersUtil);
     }

package/lib/matchers/browser/toHaveLocalStorageItem.js

@@ -1,6 +1,6 @@
 import { waitUntil, enhanceError, compareText } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { expect } from '../../index.js';
+import { expect } from 'expect';
 export async function toHaveLocalStorageItem(browser, key, expectedValue, options = DEFAULT_OPTIONS) {
     const { expectation = 'localStorage item', verb = 'have', isNot, matcherName = 'toHaveLocalStorageItem' } = this;
     await options.beforeAssertion?.({

package/lib/matchers/element/toHaveAttribute.js

@@ -1,7 +1,7 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
 import { compareText, enhanceError, isAsymmetricMatcher, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-import { expect as wdioExpect } from '../../index.js';
+import { expect } from 'expect';
 import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
 import { isOneOfMatcher } from '../asymmetrics/oneOf.js';
 async function conditionAttributeValueMatchWithExpected(el, attribute, expectedValue, options) {
@@ -23,6 +23,7 @@ export async function toHaveAttributeAndValue(received, attribute, expectedValue
     const { success: pass, actual: attr, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: expectedValue,
             singleElementCompare: (element, values) => {
                 return conditionAttributeValueMatchWithExpected(element, attribute, values, options);
@@ -51,7 +52,7 @@ export async function toHaveAttribute(received, attribute, value, options = DEFA
         if (paramsCount > 2) {
             console.warn('Using undefined or null as value for toHaveAttribute is deprecated and will be removed in v6.0.0. Please omit the third argument entirely or use toHaveAttribute(el, attribute, wdioExpect.anything(), options).');
         }
-        expectedValue = wdioExpect.anything();
+        expectedValue = expect.anything();
     }
     else {
         expectedValue = value;

package/lib/matchers/element/toHaveComputedLabel.js

@@ -17,6 +17,7 @@ export async function toHaveComputedLabel(received, expectedValue, options = DEF
     const { success: pass, actual: actualLabel, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: expectedValue,
             singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
             context: { isNot, iteration },

package/lib/matchers/element/toHaveComputedRole.js

@@ -17,6 +17,7 @@ export async function toHaveComputedRole(received, expectedValue, options = DEFA
     const { success: pass, actual: actualRole, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: expectedValue,
             singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
             context: { isNot, iteration },

package/lib/matchers/element/toHaveElementClass.js

@@ -35,6 +35,7 @@ export async function toHaveElementClass(received, expectedValue, options = DEFA
     const { success: pass, actual: attr, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: expectedValue,
             singleElementCompare: (element, expectedValue) => singleElementCompare(element, attribute, expectedValue, options),
             context: { isNot, iteration },

package/lib/matchers/element/toHaveElementProperty.js

@@ -1,6 +1,7 @@
+import { equals } from '../../jasmineUtils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
-import { expect as wdioExpect } from '../../index.js';
+import { expect } from 'expect';
 import { compareText, enhanceError, isAsymmetricMatcher, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
 import { isOneOfMatcher } from '../asymmetrics/oneOf.js';
@@ -9,7 +10,7 @@ async function condition(el, property, expectedValue, options = DEFAULT_OPTIONS)
     const propertyValue = await el.getProperty(property);
     if (propertyValue === null || propertyValue === undefined || (!(expectedValue instanceof RegExp) && typeof propertyValue !== 'string' && !asString)) {
         if (isAsymmetricMatcher(expectedValue)) {
-            return { success: expectedValue.asymmetricMatch(propertyValue), actual: propertyValue };
+            return { success: equals(propertyValue, expectedValue), actual: propertyValue };
         }
         return { success: propertyValue === expectedValue, actual: propertyValue };
     }
@@ -25,7 +26,7 @@ export async function toHaveElementProperty(received, property, value, options =
         if (paramsCount > 2) {
             console.warn('Using undefined or null as value for toHaveElementProperty is deprecated and will be removed in v6.0.0. Please omit the third argument entirely or use toHaveElementProperty(el, property, object.anything(), options).');
         }
-        value = wdioExpect.anything();
+        value = expect.anything();
     }
     await options.beforeAssertion?.({
         matcherName,
@@ -36,6 +37,7 @@ export async function toHaveElementProperty(received, property, value, options =
     const { success: pass, actual: actualProppertyValue, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: value,
             singleElementCompare: (element, expectedValue) => {
                 return condition(element, property, expectedValue, options);

package/lib/matchers/element/toHaveHTML.js

@@ -17,6 +17,7 @@ export async function toHaveHTML(received, expectedValue, options = DEFAULT_OPTI
     const { success: pass, actual: actualHTML, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         const result = await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: expectedValue,
             singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
             context: { isNot, iteration },

package/lib/matchers/element/toHaveText.js

@@ -1,5 +1,5 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareTextOrArray, enhanceError, getFeatureFlagValue, waitUntil, } from '../../utils.js';
+import { compareTextOrArray, enhanceError, getFeatureFlagValue, isArrayContainingMatcher, waitUntil, } from '../../utils.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
 import { fillSingleExpectedForElementArray } from '../../util/elementsUtil.js';
 import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
@@ -20,6 +20,7 @@ export async function toHaveText(received, expectedValue, options = DEFAULT_OPTI
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             expectedValues: expectedValue,
+            supportsArrayContaining: 'arrayOnly',
             singleElementCompare: (element, values) => {
                 return compareElement(element, values, options);
             },
@@ -28,6 +29,9 @@ export async function toHaveText(received, expectedValue, options = DEFAULT_OPTI
             strictConfiguration: { allowArrayWithSingleElement: true }
         });
     }, isNot, { wait: options.wait, interval: options.interval });
+    if (isArrayContainingMatcher(expectedValue) && actualText === undefined) {
+        throw new Error('toHaveText with arrayContaining requires an array of elements');
+    }
     const expected = fillSingleExpectedForElementArray(subject, expectedValue);
     const message = enhanceError(subject, expected, actualText, { isNot, isSome }, verb, expectation, '', options);
     const result = {

package/lib/snapshot.js

@@ -1,7 +1,7 @@
 import { expect } from '@wdio/globals';
 import { SnapshotClient } from '@vitest/snapshot';
 import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-let service;
+import { getGlobalSingleton } from './util/globalSingleton.js';
 class WebdriverIOSnapshotEnvironment extends NodeSnapshotEnvironment {
     #resolveSnapshotPath;
     constructor(resolveSnapshotPath) {
@@ -84,9 +84,6 @@ export class SnapshotService {
         }
     }
     static initiate(options) {
-        if (!service) {
-            service = new SnapshotService(options);
-        }
-        return service;
+        return getGlobalSingleton('snapshotService', () => new SnapshotService(options));
     }
 }

package/lib/softAssert.js

@@ -1,14 +1,11 @@
+import { getGlobalSingleton } from './util/globalSingleton.js';
 export class SoftAssertService {
-    static instance;
     static GLOBAL_TEST_ID = '__global_soft_assert_context__';
     failureMap = new Map();
     currentTest = null;
     constructor() { }
     static getInstance() {
-        if (!SoftAssertService.instance) {
-            SoftAssertService.instance = new SoftAssertService();
-        }
-        return SoftAssertService.instance;
+        return getGlobalSingleton('softAssertService', () => new SoftAssertService());
     }
     setCurrentTest(testId, testName, testFile) {
         this.currentTest = { id: testId, name: testName, file: testFile };

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/api/index.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"}
+{"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/api/index.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/globalSingleton.ts","../src/util/numberOptionsUtil.ts","../src/util/refetchElements.ts","../src/util/stringUtil.ts","../src/util/waitUntil.ts"],"version":"5.9.3"}

package/lib/util/elementsUtil.js

@@ -1,11 +1,12 @@
+import { isArrayContainingMatcher } from '../utils.js';
 export const wrapExpectedWithArray = (elements, actual, expected) => {
-    if (Array.isArray(elements) && Array.isArray(actual) && !Array.isArray(expected)) {
+    if (Array.isArray(elements) && Array.isArray(actual) && !Array.isArray(expected) && !isArrayContainingMatcher(expected)) {
         expected = Array(actual.length).fill(expected);
     }
     return expected;
 };
 export const fillSingleExpectedForElementArray = (subject, value) => {
-    if (isElementArrayLike(subject) && !Array.isArray(value)) {
+    if (isElementArrayLike(subject) && !Array.isArray(value) && !isArrayContainingMatcher(value)) {
         const fillerlength = subject.length > 0 ? subject.length : 1;
         return Array(fillerlength).fill(value);
     }

package/lib/util/executeCommand.js

@@ -1,15 +1,44 @@
+import { equals } from '../jasmineUtils.js';
+import { isArrayContainingMatcher } from '../utils.js';
 import { isSomeWrapper } from '../matchers/modifiers/some.js';
 import { awaitElementOrArray, isElement, isStrictlyElementArray } from './elementsUtil.js';
 import { refreshElementArray } from './refetchElements.js';
-export async function executeCommandWithStrategy({ unresolvedElements, expectedValues, singleElementCompare, context: { isNot, iteration }, strategy = 'NewStrictMultipleElements', strictConfiguration = { allowEmptyElements: false, allowArrayWithSingleElement: false } }) {
+export async function executeCommandWithStrategy({ unresolvedElements, expectedValues, singleElementCompare, context: { isNot, iteration }, strategy = 'NewStrictMultipleElements', supportsArrayContaining = false, strictConfiguration = { allowEmptyElements: false, allowArrayWithSingleElement: false } }) {
     const isSome = isSomeWrapper(unresolvedElements);
+    const actualReceived = isSome ? unresolvedElements.elements : unresolvedElements;
+    if (supportsArrayContaining && !isSome && isArrayContainingMatcher(expectedValues)) {
+        const { selector, elements, other } = await awaitElementOrArray(unresolvedElements);
+        if (elements) {
+            if (iteration > 0 && isStrictlyElementArray(elements)) {
+                await refreshElementArray(elements);
+            }
+            const settled = await Promise.allSettled(Array.from(elements).map(async (element, index) => {
+                return singleElementCompare(element, undefined, index);
+            }));
+            const actual = settled.map((result) => {
+                if (result.status === 'rejected') {
+                    throw result.reason;
+                }
+                return result.value.actual;
+            });
+            return {
+                subject: elements,
+                actual,
+                success: equals(actual, expectedValues),
+                abort: elements.length === 0 && !isStrictlyElementArray(elements),
+            };
+        }
+        if (!isElement(selector) || supportsArrayContaining === 'arrayOnly') {
+            return { subject: selector ?? other, actual: undefined, success: !!isNot, abort: true };
+        }
+        return { subject: selector, ...await singleElementCompare(selector, expectedValues) };
+    }
     if (strategy === 'LegacyLooseMultipleElements') {
         if (isSome) {
             throw new Error('some(elements) works only when enabling `useToHaveTextStrictMultiElementsCompareStrategy`');
         }
-        return legacyMultipleElementResultsStrategy(unresolvedElements, expectedValues, singleElementCompare, isNot);
+        return legacyMultipleElementResultsStrategy(actualReceived, expectedValues, singleElementCompare, isNot);
     }
-    const actualReceived = isSome ? unresolvedElements.elements : unresolvedElements;
     return multipleElementResultsStrategy(actualReceived, expectedValues, singleElementCompare, { isNot, isSome, iteration }, strictConfiguration);
 }
 export const legacyMultipleElementResultsStrategy = async (unresolvedElements, expectedValues, singleElementCompare, _isNot) => {

package/lib/util/formatMessage.js

@@ -56,10 +56,10 @@ export const enhanceError = (subject, expected, actual, context, verb, expectati
     };
     let diffString = '';
     if (isJasmineStringAsymmetricMatcher(expected)) {
-        expected = expected.jasmineToString();
+        expected = expected.jasmineToString(stringify);
     }
     else if (isElementOrArrayLike(subject) && Array.isArray(expected)) {
-        expected = expected.map(item => isJasmineStringAsymmetricMatcher(item) ? item.jasmineToString() : item);
+        expected = expected.map(item => isJasmineStringAsymmetricMatcher(item) ? item.jasmineToString(stringify) : item);
     }
     if (isNotInLabel && isElementOrArrayLike(subject) && Array.isArray(expected) && Array.isArray(actual) && expected.length === actual.length) {
         const { expectedFormatted, receivedFormatted } = printArrayWithMatchingItemInRed(expected, actual);

package/lib/util/globalSingleton.js

@@ -0,0 +1,8 @@
+import { createRequire } from 'node:module';
+const { version } = createRequire(import.meta.url)('../../package.json');
+const packageMajorVersion = version.split('.')[0];
+export function getGlobalSingleton(key, create) {
+    const globalKey = Symbol.for(`expect-webdriverio.${key}@${packageMajorVersion}`);
+    const globalScope = globalThis;
+    return (globalScope[globalKey] ??= create());
+}

package/lib/utils.js

@@ -15,6 +15,19 @@ export function isAsymmetricMatcher(expected) {
         'asymmetricMatch' in expected &&
         !!expected.asymmetricMatch);
 }
+export function isArrayContainingMatcher(expected) {
+    if (!isAsymmetricMatcher(expected) || typeof expected.asymmetricMatch !== 'function') {
+        return false;
+    }
+    if (typeof expected.toString === 'function' && /^Array(Not)?Containing$/.test(expected.toString())) {
+        return true;
+    }
+    if ('jasmineToString' in expected && typeof expected.jasmineToString === 'function') {
+        const description = expected.jasmineToString(() => '');
+        return description === '<jasmine.arrayContaining()>';
+    }
+    return false;
+}
 export function isStringContainingMatcherLike(expected) {
     return !!expected && expected.constructor.name === 'StringContaining';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "6.0.10",
+  "version": "6.1.0",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -86,7 +86,7 @@
     "playgrounds:snapshots:update": "cd playgrounds && npm run snapshots:update"
   },
   "dependencies": {
-    "@vitest/snapshot": "^4.1.10",
+    "@vitest/snapshot": "^4.1.11",
     "deep-eql": "^5.0.2",
     "expect": "^30.4.1",
     "jest-matcher-utils": "^30.4.1"
@@ -102,7 +102,7 @@
     "@vitest/coverage-v8": "^4.1.11",
     "@vitest/eslint-plugin": "^1.6.27",
     "@wdio/eslint": "^0.1.3",
-    "@wdio/types": "^9.31.2",
+    "@wdio/types": "^9.32.0",
     "eslint": "^9.39.5",
     "husky": "^9.1.7",
     "npm-run-all2": "^9.0.3",
@@ -111,7 +111,7 @@
     "strip-ansi": "^7.2.0",
     "typescript": "^5.9.3",
     "vitest": "^4.1.11",
-    "webdriverio": "^9.31.5"
+    "webdriverio": "^9.32.0"
   },
   "peerDependencies": {
     "@wdio/globals": "^9.0.0",

package/types/expect-webdriverio.d.ts

@@ -550,6 +550,7 @@ interface WdioElementOrArrayMatchers<_R, ActualT = unknown> {
      * // Check if an element array contains the specified text
      * const elem = await $$('ul > li')
      * await expect(elem).toHaveText(['Coffee', 'Tea', 'Milk'])
+     * await expect(elem).toHaveText(expect.arrayContaining(['Tea', 'Coffee']))
      * ```
      */
     toHaveText: FnWhenElementOrArrayLike<ActualT, {
@@ -853,7 +854,7 @@ type WdioOneOfAsymmetricMatcher<R> = ExpectWebdriverIO.PartialMatcher<R> & {
 }
 
 type JasmineBaseAsymmetricMatcher = {
-    jasmineToString(): string;
+    jasmineToString(pp?: (value: unknown) => string): string;
     asymmetricMatch(other: unknown): boolean;
 }