expect-webdriverio 5.7.0 → 6.0.1

package/lib/matchers/element/toHaveComputedLabel.js

@@ -1,35 +1,36 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, label, options) {
-    const actualLabel = await el.getComputedLabel();
-    if (Array.isArray(label)) {
-        return compareTextWithArray(actualLabel, label, options);
-    }
-    return compareText(actualLabel, label, options);
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { compareTextOrArray, enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
+async function singleElementCompare(element, label, options) {
+    const actualLabel = await element.getComputedLabel();
+    return compareTextOrArray(actualLabel, label, options);
 }
 export async function toHaveComputedLabel(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'computed label', verb = 'have' } = this;
+    const { expectation = 'computed label', verb = 'have', isNot, matcherName = 'toHaveComputedLabel' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveComputedLabel',
+        matcherName,
         expectedValue,
         options,
     });
-    let el = await received?.getElement();
-    let actualLabel;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
-        el = result.el;
-        actualLabel = result.values;
-        return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualLabel, expectedValue), actualLabel, this, verb, expectation, '', options);
+    expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
+    const { success: pass, actual: actualLabel, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: true }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualLabel, expectedValue), actualLabel, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveComputedLabel',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toHaveComputedRole.js

@@ -1,35 +1,36 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, role, options) {
-    const actualRole = await el.getComputedRole();
-    if (Array.isArray(role)) {
-        return compareTextWithArray(actualRole, role, options);
-    }
-    return compareText(actualRole, role, options);
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { compareTextOrArray, enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
+async function singleElementCompare(element, role, options) {
+    const actualRole = await element.getComputedRole();
+    return compareTextOrArray(actualRole, role, options);
 }
 export async function toHaveComputedRole(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'computed role', verb = 'have' } = this;
+    const { expectation = 'computed role', verb = 'have', isNot, matcherName = 'toHaveComputedRole' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveComputedRole',
+        matcherName,
         expectedValue,
         options,
     });
-    let el = await received?.getElement();
-    let actualRole;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
-        el = result.el;
-        actualRole = result.values;
-        return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualRole, expectedValue), actualRole, this, verb, expectation, '', options);
+    expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
+    const { success: pass, actual: actualRole, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: true }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualRole, expectedValue), actualRole, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveComputedRole',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toHaveElementClass.js

@@ -0,0 +1,57 @@
+import { DEFAULT_OPTIONS } from '../../constants.js';
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { compareText, compareTextOrArray, enhanceError, isAsymmetricMatcher, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+async function singleElementCompare(el, attribute, value, options) {
+    const actualClass = await el.getAttribute(attribute);
+    if (value === undefined) {
+        return { success: false, actual: actualClass };
+    }
+    if (typeof actualClass !== 'string') {
+        return { success: false, actual: actualClass };
+    }
+    if (isAsymmetricMatcher(value)) {
+        return compareText(actualClass, value, options);
+    }
+    const classes = actualClass.split(' ');
+    const isValueInClasses = classes.some((clazz) => {
+        return compareTextOrArray(clazz, value, options).success;
+    });
+    return {
+        success: isValueInClasses,
+        actual: actualClass
+    };
+}
+export function toHaveClass(...args) {
+    return toHaveElementClass.call(this || {}, ...args);
+}
+export async function toHaveElementClass(received, expectedValue, options = DEFAULT_OPTIONS) {
+    const { expectation = 'class', verb = 'have', isNot, matcherName = 'toHaveElementClass' } = this;
+    await options.beforeAssertion?.({
+        matcherName,
+        expectedValue,
+        options,
+    });
+    const attribute = 'class';
+    const { success: pass, actual: attr, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, expectedValue) => singleElementCompare(element, attribute, expectedValue, options),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: true }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const message = enhanceError(el, wrapExpectedWithArray(el, attr, expectedValue), attr, { isNot, isSome }, verb, expectation, '', options);
+    const result = {
+        pass,
+        message: () => message
+    };
+    await options.afterAssertion?.({
+        matcherName,
+        expectedValue,
+        options,
+        result
+    });
+    return result;
+}

package/lib/matchers/element/toHaveElementProperty.js

@@ -1,50 +1,58 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareText, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, property, value, options = DEFAULT_OPTIONS) {
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { expect as wdioExpect } from '../../index.js';
+import { compareText, enhanceError, isAsymmetricMatcher, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
+import { OneOfMatcher } from '../asymmetrics/oneOf.js';
+async function condition(el, property, expectedValue, options = DEFAULT_OPTIONS) {
     const { asString = false } = options;
-    let prop = await el.getProperty(property);
-    if (prop === null || prop === undefined) {
-        return { result: false, value: prop };
+    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: propertyValue === expectedValue, actual: propertyValue };
     }
-    if (value === null) {
-        return { result: true, value: prop };
+    else if (expectedValue instanceof OneOfMatcher) {
+        return { success: expectedValue.asymmetricMatch(propertyValue), actual: propertyValue };
     }
-    if (!(value instanceof RegExp) && typeof prop !== 'string' && !asString) {
-        return { result: prop === value, value: prop };
-    }
-    prop = prop.toString();
-    return compareText(prop, value, options);
+    return compareText(propertyValue.toString(), expectedValue, options);
 }
 export async function toHaveElementProperty(received, property, value, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'property', verb = 'have' } = this;
+    const { expectation = 'property', verb = 'have', isNot, matcherName = 'toHaveElementProperty' } = this;
+    const paramsCount = arguments.length;
+    if (value === undefined || value === null) {
+        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();
+    }
     await options.beforeAssertion?.({
-        matcherName: 'toHaveElementProperty',
+        matcherName,
         expectedValue: [property, value],
         options,
     });
-    let el = await received?.getElement();
-    let prop;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [property, value]);
-        el = result.el;
-        prop = result.values;
-        return result.success;
-    }, isNot, options);
-    let message;
-    if (value === undefined) {
-        message = enhanceError(el, !isNot, pass, this, verb, expectation, property, options);
-    }
-    else {
-        const expected = wrapExpectedWithArray(el, prop, value);
-        message = enhanceError(el, expected, prop, this, verb, expectation, property, options);
-    }
+    value = buildWdioAsymmetricMatchersWithOptions(value, options);
+    const { success: pass, actual: actualProppertyValue, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: value,
+            singleElementCompare: (element, expectedValue) => {
+                return condition(element, property, expectedValue, options);
+            },
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: false }
+        });
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const expected = wrapExpectedWithArray(elements, actualProppertyValue, value);
+    const message = enhanceError(elements, expected, actualProppertyValue, { isNot, isSome }, verb, expectation, property, options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveElementProperty',
+        matcherName,
         expectedValue: [property, value],
         options,
         result

package/lib/matchers/element/toHaveHTML.js

@@ -1,39 +1,38 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, html, options) {
+import { compareTextOrArray, enhanceError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
+async function singleElementCompare(el, html, options) {
     const actualHTML = await el.getHTML(options);
-    if (Array.isArray(html)) {
-        return compareTextWithArray(actualHTML, html, options);
-    }
-    return compareText(actualHTML, html, options);
+    return compareTextOrArray(actualHTML, html, options);
 }
 export async function toHaveHTML(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'HTML', verb = 'have' } = this;
+    const { expectation = 'HTML', verb = 'have', isNot, matcherName = 'toHaveHTML' } = this;
+    expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
     await options.beforeAssertion?.({
-        matcherName: 'toHaveHTML',
+        matcherName,
         expectedValue,
         options,
     });
-    let el = 'getElement' in received
-        ? await received?.getElement()
-        : 'getElements' in received
-            ? await received?.getElements()
-            : received;
-    let actualHTML;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
-        el = result.el;
-        actualHTML = result.values;
-        return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualHTML, expectedValue), actualHTML, this, verb, expectation, '', options);
+    const { success: pass, actual: actualHTML, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        const result = await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedValue,
+            singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: true }
+        });
+        return result;
+    }, isNot, { wait: options.wait, interval: options.interval });
+    const expectedValues = wrapExpectedWithArray(elements, actualHTML, expectedValue);
+    const message = enhanceError(elements, expectedValues, actualHTML, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveHTML',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/element/toHaveHeight.js

@@ -1,46 +1,41 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareNumbers, enhanceError, executeCommand, numberError, waitUntil, } from '../../utils.js';
-async function condition(el, height, 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 actualHeight = await el.getSize('height');
     return {
-        result: compareNumbers(actualHeight, options),
-        value: actualHeight
+        success: expectedNumber?.asymmetricMatch(actualHeight) ?? false,
+        actual: actualHeight
     };
 }
 export async function toHaveHeight(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'height', verb = 'have' } = this;
+    const { expectation = 'height', verb = 'have', isNot, matcherName = 'toHaveHeight' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveHeight',
+        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 actualHeight;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, numberOptions, [expectedValue, numberOptions]);
-        el = result.el;
-        actualHeight = result.values;
-        return result.success;
-    }, isNot, { ...numberOptions, ...options });
-    const error = numberError(numberOptions);
-    const message = enhanceError(el, error, actualHeight, this, verb, expectation, '', options);
+    const { numberMatcher: expectedNumber, commandOptions } = validateNumberArrayAndExtractOptions(expectedValue, options);
+    const { success: pass, actual: actualHeight, 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, actualHeight, expectedNumber);
+    const message = enhanceError(elements, expectedValues, actualHeight, { isNot, isSome }, verb, expectation, '', commandOptions);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveHeight',
+        matcherName,
         expectedValue,
         options,
         result

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