expect-webdriverio 6.1.0 → 8.0.0-alpha.0

package/lib/util/executeCommand.js

@@ -1,13 +1,17 @@
 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 { awaitElementOrArray, isElement, isMultiRemoteElement, isMultiRemoteElementArray, isMultiRemoteElements, isMultiRemoteElementsLike, isStrictlyElementArray } from './elementsUtil.js';
+import { getElementsPerInstance, getPerInstanceValues, hasSameInstanceNames } from './multiRemoteUtils.js';
 import { refreshElementArray } from './refetchElements.js';
-export async function executeCommandWithStrategy({ unresolvedElements, expectedValues, singleElementCompare, context: { isNot, iteration }, strategy = 'NewStrictMultipleElements', supportsArrayContaining = false, strictConfiguration = { allowEmptyElements: false, allowArrayWithSingleElement: false } }) {
+export async function executeCommandWithStrategy({ unresolvedElements, expectedValues, singleElementCompare, context: { isNot = false, iteration }, 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 (isMultiRemoteElementsLike(elements)) {
+            return multiRemoteArrayContainingStrategy(elements, expectedValues, singleElementCompare, iteration);
+        }
         if (elements) {
             if (iteration > 0 && isStrictlyElementArray(elements)) {
                 await refreshElementArray(elements);
@@ -33,67 +37,62 @@ export async function executeCommandWithStrategy({ unresolvedElements, expectedV
         }
         return { subject: selector, ...await singleElementCompare(selector, expectedValues) };
     }
-    if (strategy === 'LegacyLooseMultipleElements') {
-        if (isSome) {
-            throw new Error('some(elements) works only when enabling `useToHaveTextStrictMultiElementsCompareStrategy`');
-        }
-        return legacyMultipleElementResultsStrategy(actualReceived, expectedValues, singleElementCompare, isNot);
-    }
     return multipleElementResultsStrategy(actualReceived, expectedValues, singleElementCompare, { isNot, isSome, iteration }, strictConfiguration);
 }
-export const legacyMultipleElementResultsStrategy = async (unresolvedElements, expectedValues, singleElementCompare, _isNot) => {
-    const { selector, other, isEmptyElements } = await awaitElementOrArray(unresolvedElements);
-    const subject = selector ?? other;
-    if (!selector || isEmptyElements) {
-        return {
-            subject: subject,
-            success: false,
-            actual: undefined,
-            abort: true,
-        };
-    }
-    if (isElement(selector)) {
-        const compareResult = await singleElementCompare(selector, expectedValues);
-        return {
-            subject,
-            ...compareResult,
-        };
+const multiRemoteArrayContainingStrategy = async (elements, expectedValues, singleElementCompare, iteration) => {
+    const currentElements = iteration > 0 ? await refreshElementArray(elements) : elements;
+    const multiRemoteElements = currentElements;
+    if (multiRemoteElements.length === 0) {
+        return { subject: elements, actual: undefined, success: false, abort: !isMultiRemoteElementArray(elements) && !isMultiRemoteElements(elements) };
     }
-    const settled = await Promise.allSettled(Array.from(selector).map((element, index) => singleElementCompare(element, expectedValues, index)));
-    const firstRejection = settled.find((r) => r.status === 'rejected');
-    if (firstRejection) {
-        throw firstRejection.reason;
-    }
-    const results = settled.map((r) => r.value);
+    const { instances } = multiRemoteElements[0];
+    const elementsPerInstance = getElementsPerInstance(multiRemoteElements, instances);
+    const actual = Object.fromEntries(await Promise.all(instances.map(async (instance) => {
+        const results = await Promise.all(elementsPerInstance[instance].map((element, index) => singleElementCompare(element, undefined, index)));
+        return [instance, results.map((result) => result.actual)];
+    })));
     return {
-        subject,
-        success: results.length > 0 && results.every((res) => res.success === true),
-        actual: results.map(({ actual: value }) => value),
+        subject: elements,
+        actual,
+        success: instances.every((instance) => equals(actual[instance], expectedValues)),
+        expected: Object.fromEntries(instances.map((instance) => [instance, expectedValues])),
     };
 };
-export const multipleElementResultsStrategy = async (unresolvedElements, expectedValues, singleElementCompare, { isNot, isSome, iteration }, { allowEmptyElements = false, allowArrayWithSingleElement = false } = {}) => {
-    const { selector, other } = await awaitElementOrArray(unresolvedElements);
-    if (iteration > 0 && isStrictlyElementArray(selector)) {
-        await refreshElementArray(selector);
+export const multipleElementResultsStrategy = async (unresolvedElements, expectedValues, singleElementCompare, { isNot, isSome, iteration }, { allowEmptyElements = false, allowArrayWithSingleElement = false, allowObjectExpectedValue = false } = {}) => {
+    const { selector, other, multiRemoteSelector } = await awaitElementOrArray(unresolvedElements);
+    const isRefetchable = isStrictlyElementArray(selector) || isMultiRemoteElementArray(selector) || isMultiRemoteElements(selector);
+    let currentElements = selector;
+    if (iteration > 0 && (isStrictlyElementArray(selector) || isMultiRemoteElementsLike(selector))) {
+        currentElements = await refreshElementArray(selector);
     }
-    const subject = selector ?? other;
-    if (!selector || (Array.isArray(selector) && selector.length === 0)) {
+    const subject = multiRemoteSelector ?? selector ?? other;
+    if (!currentElements || (Array.isArray(currentElements) && currentElements.length === 0)) {
         return {
             subject,
             success: isNot ? !allowEmptyElements : false,
             actual: undefined,
-            abort: !allowEmptyElements && !isStrictlyElementArray(selector),
+            abort: !allowEmptyElements && !isRefetchable,
             context: { isSome },
         };
     }
+    const isUnexpectedPerInstanceValues = !multiRemoteSelector && !isMultiRemoteElementsLike(selector)
+        && getPerInstanceValues(expectedValues, { allowObjectExpectedValue }) !== undefined;
     if (isElement(selector)) {
-        const forceFailure = !allowArrayWithSingleElement && Array.isArray(expectedValues);
+        const forceFailure = (!allowArrayWithSingleElement && Array.isArray(expectedValues)) || isUnexpectedPerInstanceValues;
         const compareResult = await singleElementCompare(selector, forceFailure ? undefined : expectedValues);
         const success = forceFailure ? !!isNot : compareResult.success;
         return { subject, success, actual: compareResult.actual, abort: forceFailure, context: { isSome } };
     }
-    const lengthMismatch = Array.isArray(expectedValues) && expectedValues.length !== selector.length;
-    const settled = await Promise.allSettled(Array.from(selector).map(async (element, index) => {
+    if (multiRemoteSelector || isMultiRemoteElementsLike(selector)) {
+        return multiRemoteElementsResultsStrategy(subject, multiRemoteSelector ?? selector, expectedValues, singleElementCompare, { isNot, isSome }, { allowArrayWithSingleElement, allowObjectExpectedValue });
+    }
+    const elementsSelector = selector;
+    const lengthMismatch = Array.isArray(expectedValues) && expectedValues.length !== elementsSelector.length;
+    if (isUnexpectedPerInstanceValues) {
+        const results = await Promise.all(Array.from(elementsSelector).map((element, index) => singleElementCompare(element, undefined, index)));
+        return { subject, success: !!isNot, abort: true, actual: results.map(({ actual }) => actual), context: { isSome } };
+    }
+    const settled = await Promise.allSettled(Array.from(elementsSelector).map(async (element, index) => {
         const indexedExpected = Array.isArray(expectedValues) ? expectedValues[index] : expectedValues;
         const forceElementFailure = Array.isArray(indexedExpected)
             || (lengthMismatch && Array.isArray(expectedValues) && index >= expectedValues.length);
@@ -105,19 +104,69 @@ export const multipleElementResultsStrategy = async (unresolvedElements, expecte
         throw firstRejection.reason;
     }
     const results = settled.map((r) => r.value);
-    if (Array.isArray(expectedValues) && expectedValues.length > selector.length) {
-        results.push(...Array(expectedValues.length - selector.length).fill({ success: false, actual: undefined }));
+    if (Array.isArray(expectedValues) && expectedValues.length > elementsSelector.length) {
+        results.push(...Array(expectedValues.length - elementsSelector.length).fill({ success: false, actual: undefined }));
     }
+    const actual = results.map(({ actual }) => actual);
     if (lengthMismatch) {
-        return { subject, success: !!isNot, actual: results.map(({ actual }) => actual), context: { isSome } };
+        return { subject, success: !!isNot, actual, context: { isSome } };
     }
-    const isNotEmpty = results.length > 0;
+    return { subject, success: computeSuccess([results], { isNot, isSome }), actual, context: { isSome } };
+};
+const multiRemoteElementsResultsStrategy = async (subject, multiRemoteSelector, expectedValues, singleElementCompare, { isNot, isSome }, { allowArrayWithSingleElement, allowObjectExpectedValue }) => {
+    const isSingleElement = isMultiRemoteElement(multiRemoteSelector);
+    const multiRemoteElements = isSingleElement ? [multiRemoteSelector] : multiRemoteSelector;
+    const { instances } = multiRemoteElements[0];
+    const elementsPerInstance = getElementsPerInstance(multiRemoteElements, instances);
+    const perInstanceValues = getPerInstanceValues(expectedValues, { allowObjectExpectedValue });
+    const expectedPerInstance = perInstanceValues ?? Object.fromEntries(instances.map((name) => [name, expectedValues]));
+    const instanceNamesMismatch = !!perInstanceValues && !hasSameInstanceNames(perInstanceValues, instances);
+    const unsupportedArray = isSingleElement && !allowArrayWithSingleElement && Object.values(expectedPerInstance).some(Array.isArray);
+    const lengthMismatch = !isSingleElement && instances.some((name) => {
+        const value = expectedPerInstance[name];
+        return Array.isArray(value) && value.length !== elementsPerInstance[name].length;
+    });
+    const actualPerInstance = {};
+    const resultsPerInstance = await Promise.all(instances.map(async (instance) => {
+        const isExpected = instance in expectedPerInstance;
+        const instanceValue = expectedPerInstance[instance];
+        const elements = elementsPerInstance[instance];
+        const results = await Promise.all(elements.map(async (element, index) => {
+            const indexedExpected = isSingleElement || !Array.isArray(instanceValue) ? instanceValue : instanceValue[index];
+            const forceElementFailure = !isExpected || unsupportedArray
+                || (!isSingleElement && Array.isArray(instanceValue) && (index >= instanceValue.length || Array.isArray(indexedExpected)));
+            const elementExpected = forceElementFailure ? undefined : indexedExpected;
+            const result = isSingleElement ? await singleElementCompare(element, elementExpected) : await singleElementCompare(element, elementExpected, index);
+            return forceElementFailure ? { success: false, actual: result.actual } : result;
+        }));
+        const actuals = results.map(({ actual }) => actual);
+        if (isSingleElement) {
+            actualPerInstance[instance] = actuals[0];
+        }
+        else {
+            const expectedLength = Array.isArray(instanceValue) ? instanceValue.length : 0;
+            actualPerInstance[instance] = [...actuals, ...Array(Math.max(expectedLength - actuals.length, 0)).fill(undefined)];
+        }
+        return results;
+    }));
+    const expected = isSingleElement ? expectedPerInstance : Object.fromEntries(Object.entries(expectedPerInstance).map(([name, value]) => {
+        const count = elementsPerInstance[name]?.length ?? 0;
+        return [name, Array.isArray(value) || isArrayContainingMatcher(value) ? value : Array(Math.max(count, 1)).fill(value)];
+    }));
+    if (instanceNamesMismatch || unsupportedArray) {
+        return { subject, success: !!isNot, abort: true, actual: actualPerInstance, context: { isSome }, expected };
+    }
+    if (lengthMismatch) {
+        return { subject, success: !!isNot, actual: actualPerInstance, context: { isSome }, expected };
+    }
+    return { subject, success: computeSuccess(resultsPerInstance, { isNot, isSome }), actual: actualPerInstance, context: { isSome }, expected };
+};
+const computeSuccess = (groups, { isNot, isSome }) => {
     const checkFn = isSome ? isAtLeastOneTrue : isAllTrue;
     const checkNotFn = isSome ? isAtLeastOneFalse : isAllFalse;
-    const success = isNot
-        ? !(isNotEmpty && checkNotFn(results))
-        : isNotEmpty && checkFn(results);
-    return { subject, success, actual: results.map(({ actual }) => actual), context: { isSome } };
+    const isNotEmpty = groups.length > 0 && groups.every((results) => results.length > 0);
+    const assertionPasses = isNotEmpty && groups.every((results) => isNot ? checkNotFn(results) : checkFn(results));
+    return isNot ? !assertionPasses : assertionPasses;
 };
 const isAllTrue = (results) => results.every((res) => res.success === true);
 const isAllFalse = (results) => results.every((res) => res.success === false);

package/lib/util/formatMessage.js

@@ -1,8 +1,9 @@
 import { printDiffOrStringify, printExpected, printReceived, RECEIVED_COLOR, EXPECTED_COLOR, INVERTED_COLOR, stringify } from 'jest-matcher-utils';
 import { equals } from '../jasmineUtils.js';
-import { isArrayOfElement, isElementArrayLike, isElementOrArrayLike, isStrictlyElementArray } from './elementsUtil.js';
+import { isArrayOfElement, isElementArrayLike, isElementOrArrayLike, isElementOrArrayOrMultiRemoteElementLike, isMultiRemoteElement, isMultiRemoteElementArray, isMultiRemoteElementLike, isMultiRemoteElementsLike, isStrictlyElementArray } from './elementsUtil.js';
 import { toJsonString } from './stringUtil.js';
 import { isJasmineStringAsymmetricMatcher, toArray } from '../utils.js';
+import { isBrowser, isMultiRemoteBrowser } from './multiRemoteUtils.js';
 export const isDefined = (value) => value !== null && value !== undefined;
 export const getSelector = (el) => {
     let result = typeof el.selector === 'string' ? el.selector : '<fn>';
@@ -17,7 +18,17 @@ export const getSelectors = (el) => {
     }
     const selectors = [];
     let parent;
-    if (isStrictlyElementArray(el)) {
+    if (isMultiRemoteElement(el)) {
+        const subject = formatMultiRemoteInstanceNames(el.instances);
+        return `${subject}.$(\`${getSelector(el)}\`)`;
+    }
+    else if (isMultiRemoteElementsLike(el)) {
+        const instances = isMultiRemoteElementArray(el) ? el.parent.instances : el[0].instances ?? [];
+        const selector = isMultiRemoteElementArray(el) ? getSelector(el) : el[0] ? getSelector(el[0]) : '';
+        const subject = formatMultiRemoteInstanceNames(instances);
+        return `${subject}.$$(\`${selector}\`)`;
+    }
+    else if (isStrictlyElementArray(el)) {
         selectors.push(`${(el).foundWith}(\`${getSelector(el)}\`)`);
         parent = el.parent;
     }
@@ -38,7 +49,23 @@ export const getSelectors = (el) => {
 const not = (isNot) => `${isNot ? 'not ' : ''}`;
 export const enhanceError = (subject, expected, actual, context, verb, expectation, expectedValueArgument2 = '', { message = '', containing = false } = {}) => {
     const { isNot, useNotInLabel = true } = context;
-    let subjectStr = (isElementOrArrayLike(subject) ? getSelectors(subject) : toJsonString(subject));
+    if ((isBrowser(subject) && isMultiRemoteBrowser(subject)) || isMultiRemoteElementLike(subject)) {
+        expected = labelMultiRemoteValues(expected);
+        actual = labelMultiRemoteValues(actual);
+    }
+    if (isBrowser(subject)) {
+        if (isMultiRemoteBrowser(subject)) {
+            subject = formatMultiRemoteInstanceNames(subject.instances);
+        }
+        else if (subject.isMobile) {
+            subject = context.browserTargetType === 'window' ? 'mobile screen' : 'mobile';
+        }
+        else {
+            const prefix = subject.requestedCapabilities?.browserName ?? 'browser';
+            subject = context.browserTargetType === 'window' ? `${prefix}'s window` : prefix;
+        }
+    }
+    let subjectStr = (isElementOrArrayOrMultiRemoteElementLike(subject) ? getSelectors(subject) : toJsonString(subject));
     if (subjectStr.length > 100) {
         subjectStr = `${subjectStr.substring(0, 100)}...`;
     }
@@ -114,15 +141,47 @@ const printArrayWithMatchingItemInRed = (expectedArray, actualArray) => {
         .join(', ')}]`;
     return { expectedFormatted, receivedFormatted };
 };
-export const enhanceErrorBe = (subject, results, context, options) => {
-    const { isNot, verb, expectation } = context;
+export const enhanceErrorBe = (subject, actuals, context, options) => {
+    const { isNot = false, verb, expectation } = context;
     let expected;
     let actual;
     const expectedValue = `${not(isNot)}${expectation}`;
     const actualValue = `${not(!isNot)}${expectation}`;
-    if (isElementArrayLike(subject)) {
+    if (isMultiRemoteElementLike(subject)) {
+        if (isMultiRemoteElement(subject)) {
+            const typedActuals = actuals;
+            actual = subject.instances.reduce((acc, instance) => {
+                acc[instance] = isSuccess(isNot, typedActuals[instance]) ? `${not(isNot)}${expectation}` : `${not(!isNot)}${expectation}`;
+                return acc;
+            }, {});
+            expected = subject.instances.reduce((acc, instance) => {
+                acc[instance] = expectedValue;
+                return acc;
+            }, {});
+        }
+        else if (isMultiRemoteElementsLike(subject) && subject.length === 0) {
+            expected = 'at least one result';
+            actual = actualValue;
+        }
+        else if (isMultiRemoteElementsLike(subject)) {
+            const { instances } = subject[0];
+            const typedActuals = actuals;
+            actual = instances.reduce((acc, instance) => {
+                acc[instance] = typedActuals[instance].map(actual => isSuccess(isNot, actual) ? `${not(isNot)}${expectation}` : `${not(!isNot)}${expectation}`);
+                return acc;
+            }, {});
+            expected = instances.reduce((acc, instance) => {
+                acc[instance] = Array(typedActuals[instance].length).fill(expectedValue);
+                return acc;
+            }, {});
+        }
+        else {
+            throw new Error('Unsupported Multi-remote object type for enhanceErrorBe');
+        }
+    }
+    else if (isElementArrayLike(subject)) {
         expected = subject.length === 0 ? 'at least one result' : Array(subject.length).fill(expectedValue);
-        actual = toArray(results).map(result => isSuccess(isNot, result) ? `${not(isNot)}${expectation}` : `${not(!isNot)}${expectation}`);
+        actual = toArray(actuals).map(actual => isSuccess(isNot, actual) ? `${not(isNot)}${expectation}` : `${not(!isNot)}${expectation}`);
     }
     else {
         expected = expectedValue;
@@ -133,3 +192,18 @@ export const enhanceErrorBe = (subject, results, context, options) => {
 const isSuccess = (isNot, success) => {
     return isNot ? !success : success;
 };
+class MultiRemoteValuesLabel {
+}
+Object.defineProperty(MultiRemoteValuesLabel, 'name', { value: 'Multi-remote values' });
+export const labelMultiRemoteValues = (value) => {
+    const isPlainObject = typeof value === 'object' && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+    return isPlainObject ? Object.assign(new MultiRemoteValuesLabel(), value) : value;
+};
+export const formatMultiRemoteMocks = ({ names, isNamedByInstance }) => {
+    return isNamedByInstance ? `${formatMultiRemoteInstanceNames(names)} mocks` : 'mocks';
+};
+const formatMultiRemoteInstanceNames = (instances) => {
+    let instanceNames = instances.join(', ');
+    instanceNames = instanceNames.length > 50 ? `${instanceNames.substring(0, 50)}...` : instanceNames;
+    return `multi-remote<${instanceNames}>`;
+};

package/lib/util/multiRemoteUtils.js

@@ -0,0 +1,93 @@
+import { isAsymmetricMatcher } from '../utils.js';
+export const isMultiRemoteValues = (value, existingInstanceNames) => {
+    if (value && typeof value === 'object' && !Array.isArray(value) && !isAsymmetricMatcher(value) && !(value instanceof RegExp) && Object.keys(value).length > 0) {
+        if (existingInstanceNames) {
+            return existingInstanceNames?.some(name => Object.keys(value).includes(name));
+        }
+        return true;
+    }
+    return false;
+};
+export const hasSameInstanceNames = (expected, instances) => {
+    const names = Object.keys(expected);
+    return names.length === instances.length && instances.every((name) => names.includes(name));
+};
+export const MULTI_REMOTE_MATCHER_SYMBOL = Symbol.for('expect-webdriverio.multiRemote');
+export const isMultiRemoteMatcher = (value) => {
+    return !!value && typeof value === 'object' && value[MULTI_REMOTE_MATCHER_SYMBOL] === true;
+};
+export const getPerInstanceValues = (value, { allowObjectExpectedValue = false } = {}) => {
+    if (isMultiRemoteMatcher(value)) {
+        return value.sample;
+    }
+    return !allowObjectExpectedValue && isMultiRemoteValues(value) ? value : undefined;
+};
+export const getElementsPerInstance = (multiRemoteElements, instances) => {
+    return Object.fromEntries(instances.map((name) => {
+        const elements = [];
+        for (let index = 0; index < multiRemoteElements.length; index++) {
+            const element = getInstanceOrUndefined(multiRemoteElements[index], name);
+            if (element) {
+                elements.push(element);
+            }
+        }
+        return [name, elements];
+    }));
+};
+const getInstanceOrUndefined = (element, name) => {
+    try {
+        return element.getInstance(name) || undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const getGlobalMultiRemoteInstanceNames = () => {
+    try {
+        const instances = typeof multiRemoteBrowser === 'undefined' ? undefined : multiRemoteBrowser.instances;
+        return Array.isArray(instances) ? instances : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const isMock = (obj) => {
+    return typeof obj === 'object' && obj !== null && Array.isArray(obj.calls);
+};
+export const isMockArray = (obj) => {
+    return Array.isArray(obj) && obj.length > 0 && obj.every(isMock);
+};
+export const awaitMocks = async (received) => {
+    const mocks = received instanceof Promise ? await received : received;
+    if (Array.isArray(mocks) && mocks.length === 0) {
+        throw new Error('Expected a mock or a non-empty array of mocks, received an empty array');
+    }
+    return mocks;
+};
+export const getMockInstanceNames = (mocks) => {
+    const instances = getGlobalMultiRemoteInstanceNames();
+    if (instances && instances.length === mocks.length) {
+        return { names: instances, isNamedByInstance: true };
+    }
+    return { names: mocks.map((_, index) => `mocks[${index}]`), isNamedByInstance: false };
+};
+export const isGlobalBrowserSingleRemote = () => {
+    try {
+        return typeof browser !== 'undefined' && isBrowser(browser) && !hasMultiRemoteFlag(browser);
+    }
+    catch {
+        return false;
+    }
+};
+export const hasMultiRemoteFlag = (obj) => {
+    if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
+        return false;
+    }
+    const { isMultiRemote, isMultiremote } = obj;
+    return isMultiRemote === true || isMultiremote === true;
+};
+export const isMultiRemoteBrowser = (browser) => hasMultiRemoteFlag(browser);
+export const isBrowser = (obj) => {
+    const name = obj?.constructor?.name?.replace(/^bound /, '');
+    return name === 'Browser' || !!name?.endsWith('MultiRemoteDriver');
+};

package/lib/util/numberOptionsUtil.js

@@ -1,35 +1,37 @@
 import { AsymmetricMatcher } from 'expect';
-import { isDefinedPlainObject } from './commandOptionsUtils.js';
+import { isMultiRemoteMatcher } from './multiRemoteUtils.js';
 export const isNumber = (value) => typeof value === 'number' && !isNaN(value);
 export const isDefinedNotNumber = (value) => value !== undefined && !isNumber(value);
 export const isDefinedNumberOrNonEmptyObject = (value) => typeof value === 'number' || (typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length > 0);
-export function validateNumberAndExtractOptions(expectedValue, commandOptions, { supportDefaultAsGteThen1 } = {}) {
-    let defaultExpectedValue = undefined;
-    if (supportDefaultAsGteThen1 && (expectedValue === undefined || (isDefinedPlainObject(expectedValue) && expectedValue.eq === undefined && expectedValue.gte === undefined && expectedValue.lte === undefined))) {
-        defaultExpectedValue = new NumberMatcher({ gte: 1 });
+const NUMBER_MATCHER_KEYS = ['eq', 'gte', 'lte'];
+export function validateNumberMatcher(expectedValue, { supportDefaultAsGteThen1 } = {}) {
+    if (supportDefaultAsGteThen1 && expectedValue === undefined) {
+        return new NumberMatcher({ gte: 1 });
     }
-    else if (isNumber(expectedValue)) {
-        return { numberMatcher: new NumberMatcher({ eq: expectedValue }), commandOptions };
+    if (isNumber(expectedValue)) {
+        return new NumberMatcher({ eq: expectedValue });
     }
-    else if (!isDefinedNumberOrNonEmptyObject(expectedValue) || isDefinedNotNumber(expectedValue.eq) || isDefinedNotNumber(expectedValue.gte) || isDefinedNotNumber(expectedValue.lte)
+    if (!isDefinedNumberOrNonEmptyObject(expectedValue)
+        || Object.keys(expectedValue).some((key) => !NUMBER_MATCHER_KEYS.includes(key))
+        || isDefinedNotNumber(expectedValue.eq) || isDefinedNotNumber(expectedValue.gte) || isDefinedNotNumber(expectedValue.lte)
         || (expectedValue.eq === undefined && expectedValue.gte === undefined && expectedValue.lte === undefined)) {
         throw new Error(`Invalid NumberMatcher. Received: ${JSON.stringify(expectedValue)}`);
     }
-    const { eq, gte, lte, ...restCommandOptions } = expectedValue ?? {};
+    const { eq, gte, lte } = expectedValue;
     if (isNumber(gte) && isNumber(lte) && gte > lte) {
         throw new Error(`Invalid NumberMatcher range: 'gte' (${gte}) cannot be greater than 'lte' (${lte}).`);
     }
-    return {
-        numberMatcher: defaultExpectedValue ?? new NumberMatcher({ eq, gte, lte }),
-        commandOptions: { ...commandOptions, ...restCommandOptions }
-    };
+    return new NumberMatcher({ eq, gte, lte });
 }
-export function validateNumberArrayAndExtractOptions(expectedValues, commandOptions, { supportDefaultAsGteThen1 } = {}) {
+export function validateNumberMatcherArray(expectedValues, { supportDefaultAsGteThen1 } = {}) {
+    if (isMultiRemoteMatcher(expectedValues)) {
+        const perInstanceValues = expectedValues.sample;
+        return Object.fromEntries(Object.entries(perInstanceValues).map(([instance, value]) => [instance, validateNumberMatcherArray(value)]));
+    }
     if (Array.isArray(expectedValues)) {
-        const allNumbers = expectedValues.map((value) => validateNumberAndExtractOptions(value, commandOptions, { supportDefaultAsGteThen1 }));
-        return { numberMatcher: allNumbers.map(({ numberMatcher }) => numberMatcher), commandOptions };
+        return expectedValues.map((value) => validateNumberMatcher(value, { supportDefaultAsGteThen1 }));
     }
-    return validateNumberAndExtractOptions(expectedValues, commandOptions, { supportDefaultAsGteThen1 });
+    return validateNumberMatcher(expectedValues, { supportDefaultAsGteThen1 });
 }
 export class NumberMatcher extends AsymmetricMatcher {
     sample;
@@ -83,10 +85,3 @@ export class NumberMatcher extends AsymmetricMatcher {
         return this.toString();
     }
 }
-export const isEmptyOrLegacyNumberOptions = (value) => {
-    if (!isDefinedPlainObject(value)) {
-        return false;
-    }
-    const keys = Object.keys(value);
-    return keys.length === 0 || keys.filter((key) => !['eq', 'gte', 'lte'].includes(key)).length > 0;
-};

package/lib/util/refetchElements.js

@@ -1,14 +1,32 @@
-import { isStrictlyElementArray } from './elementsUtil.js';
+import { isMultiRemoteElementArray, isMultiRemoteElements, isStrictlyElementArray } from './elementsUtil.js';
 export const refetchElements = async (elements) => {
     if (elements
-        && isStrictlyElementArray(elements)
+        && (isStrictlyElementArray(elements) || isMultiRemoteElementArray(elements))
         && elements.parent && elements.foundWith && elements.foundWith in elements.parent) {
         const browser = elements.parent;
         const $$ = browser[elements.foundWith];
         return await $$.call(browser, elements.selector, ...elements.props);
     }
+    else if (isMultiRemoteElements(elements)) {
+        const selector = elements.find((element) => !!element.selector)?.selector;
+        if (selector) {
+            warnMultiRemoteRefetchFallbackOnce();
+            if (typeof multiRemoteBrowser === 'undefined') {
+                return elements;
+            }
+            return await multiRemoteBrowser.$$(selector);
+        }
+    }
     return elements;
 };
+let hasWarnedMultiRemoteRefetchFallback = false;
+const warnMultiRemoteRefetchFallbackOnce = () => {
+    if (hasWarnedMultiRemoteRefetchFallback) {
+        return;
+    }
+    hasWarnedMultiRemoteRefetchFallback = true;
+    console.warn('expect-webdriverio: refetching multi-remote elements between retries is best effort: they are re-queried from the global `multiRemoteBrowser`, ignoring any parent element or `select()` scope. Set `WDIO_ENABLE_MULTI_REMOTE_ELEMENT_ARRAY=true` for reliable retries.');
+};
 export const syncronizeElements = async (subject, refetchedElements) => {
     if (subject instanceof Promise) {
         await syncronizeChainableElementArray(subject, refetchedElements);
@@ -31,5 +49,9 @@ export const synchronizeElementArray = (subject, refetchedElements) => {
 };
 export const refreshElementArray = async (subject) => {
     const refetchedElements = await refetchElements(subject);
+    if (refetchedElements.length === 0 && isMultiRemoteElements(subject)) {
+        return refetchedElements;
+    }
     synchronizeElementArray(subject, refetchedElements);
+    return subject;
 };