expect-webdriverio 5.2.1 → 5.3.0

package/lib/matchers/element/toHaveHeight.js

@@ -1,10 +1,10 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, height) {
+import { compareNumbers, enhanceError, executeCommand, numberError, waitUntil, } from '../../utils.js';
+async function condition(el, height, options) {
     const actualHeight = await el.getSize('height');
     return {
-        value: actualHeight,
-        result: actualHeight === height,
+        result: compareNumbers(actualHeight, options),
+        value: actualHeight
     };
 }
 export async function toHaveHeight(received, expectedValue, options = DEFAULT_OPTIONS) {
@@ -15,15 +15,26 @@ export async function toHaveHeight(received, expectedValue, options = DEFAULT_OP
         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, options, [expectedValue, options]);
+        const result = await executeCommand.call(this, el, condition, numberOptions, [expectedValue, numberOptions]);
         el = result.el;
         actualHeight = result.values;
         return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualHeight, expectedValue), actualHeight, this, verb, expectation, '', options);
+    }, isNot, { ...numberOptions, ...options });
+    const error = numberError(numberOptions);
+    const message = enhanceError(el, error, actualHeight, this, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message

package/lib/matchers/element/toHaveWidth.js

@@ -1,10 +1,10 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
-async function condition(el, width) {
+import { compareNumbers, enhanceError, executeCommand, numberError, waitUntil, } from '../../utils.js';
+async function condition(el, width, options) {
     const actualWidth = await el.getSize('width');
     return {
-        value: actualWidth,
-        result: actualWidth === width,
+        result: compareNumbers(actualWidth, options),
+        value: actualWidth
     };
 }
 export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPTIONS) {
@@ -15,15 +15,26 @@ export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPT
         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, options, [expectedValue, options]);
+        const result = await executeCommand.call(this, el, condition, numberOptions, [expectedValue, numberOptions]);
         el = result.el;
         actualWidth = result.values;
         return result.success;
-    }, isNot, options);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualWidth, expectedValue), actualWidth, this, verb, expectation, '', options);
+    }, isNot, { ...numberOptions, ...options });
+    const error = numberError(numberOptions);
+    const message = enhanceError(el, error, actualWidth, this, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "5.2.1",
+  "version": "5.3.0",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -58,29 +58,29 @@
     "prepare": "husky install"
   },
   "dependencies": {
-    "@vitest/snapshot": "^3.2.0",
+    "@vitest/snapshot": "^3.2.1",
     "expect": "^29.7.0",
     "jest-matcher-utils": "^29.7.0",
     "lodash.isequal": "^4.5.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
-    "@types/jest": "^29.5.12",
+    "@types/jest": "^29.5.14",
     "@types/lodash.isequal": "^4.5.8",
-    "@types/node": "^22.9.0",
-    "@vitest/coverage-v8": "^3.0.5",
-    "@wdio/eslint": "^0.1.0",
-    "@wdio/types": "^9.9.0",
-    "c8": "^10.1.2",
-    "eslint": "^9.15.0",
-    "husky": "^9.1.5",
-    "npm-run-all2": "^7.0.1",
-    "release-it": "^19.0.1",
+    "@types/node": "^22.15.29",
+    "@vitest/coverage-v8": "^3.2.1",
+    "@wdio/eslint": "^0.1.1",
+    "@wdio/types": "^9.15.0",
+    "c8": "^10.1.3",
+    "eslint": "^9.28.0",
+    "husky": "^9.1.7",
+    "npm-run-all2": "^8.0.4",
+    "release-it": "^19.0.3",
     "rimraf": "^6.0.1",
-    "shelljs": "^0.9.1",
-    "typescript": "^5.5.4",
-    "vitest": "^3.0.4",
-    "webdriverio": "^9.2.11"
+    "shelljs": "^0.10.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.1",
+    "webdriverio": "^9.15.0"
   },
   "peerDependencies": {
     "@wdio/globals": "^9.0.0",

package/types/expect-webdriverio.d.ts

@@ -1,16 +1,24 @@
+type ServiceInstance =  import('@wdio/types').Services.ServiceInstance;
+type Test = import('@wdio/types').Frameworks.Test;
+type TestResult = import('@wdio/types').Frameworks.TestResult;
+type PickleStep = import('@wdio/types').Frameworks.PickleStep;
+type Scenario = import('@wdio/types').Frameworks.Scenario;
+type SnapshotResult = import('@vitest/snapshot').SnapshotResult;
+type SnapshotUpdateState = import('@vitest/snapshot').SnapshotUpdateState;
+
 declare namespace ExpectWebdriverIO {
     const expect: ExpectWebdriverIO.Expect
     function setOptions(options: DefaultOptions): void
     function getConfig(): any
 
     interface SnapshotServiceArgs {
-        updateState?: import('@vitest/snapshot').SnapshotUpdateState
+        updateState?: SnapshotUpdateState
         resolveSnapshotPath?: (path: string, extension: string) => string
     }
 
     class SnapshotService {
-        static initiate(options: SnapshotServiceArgs): import('@wdio/types').Services.ServiceInstance & {
-            results: import('@vitest/snapshot').SnapshotResult[]
+        static initiate(options: SnapshotServiceArgs): ServiceInstance & {
+            results: SnapshotResult[]
         }
     }
 
@@ -35,12 +43,12 @@ declare namespace ExpectWebdriverIO {
         autoAssertOnTestEnd?: boolean;
     }
 
-    class SoftAssertionService implements import('@wdio/types').Services.ServiceInstance {
+    class SoftAssertionService implements ServiceInstance {
         constructor(serviceOptions?: SoftAssertionServiceOptions, capabilities?: any, config?: any);
-        beforeTest(test: import('@wdio/types').Frameworks.Test): void;
-        beforeStep(step: import('@wdio/types').Frameworks.PickleStep, scenario: import('@wdio/types').Frameworks.Scenario): void;
-        afterTest(test: import('@wdio/types').Frameworks.Test, context: any, result: import('@wdio/types').Frameworks.TestResult): void;
-        afterStep(step: import('@wdio/types').Frameworks.PickleStep, scenario: import('@wdio/types').Frameworks.Scenario, result: { passed: boolean, error?: Error }): void;
+        beforeTest(test: Test): void;
+        beforeStep(step: PickleStep, scenario: Scenario): void;
+        afterTest(test: Test, context: any, result: TestResult): void;
+        afterStep(step: PickleStep, scenario: Scenario, result: { passed: boolean, error?: Error }): void;
     }
 
     interface AssertionResult {