eslint-plugin-playwright 0.11.2 → 0.13.0

package/README.md

@@ -1,23 +1,28 @@
 # ESLint Plugin Playwright
 
 [![Test](https://github.com/playwright-community/eslint-plugin-playwright/actions/workflows/test.yml/badge.svg)](https://github.com/playwright-community/eslint-plugin-playwright/actions/workflows/test.yml)
-[![NPM](https://img.shields.io/npm/v/eslint-plugin-playwright)](https://www.npmjs.com/package/eslint-plugin-playwright)
+[![npm](https://img.shields.io/npm/v/eslint-plugin-playwright)](https://www.npmjs.com/package/eslint-plugin-playwright)
 
-> ESLint plugin for your [Playwright](https://github.com/microsoft/playwright)
-> testing needs.
+ESLint plugin for [Playwright](https://github.com/microsoft/playwright).
 
 ## Installation
 
+npm
+
+```bash
+npm install -D eslint-plugin-playwright
+```
+
 Yarn
 
 ```bash
 yarn add -D eslint-plugin-playwright
 ```
 
-NPM
+pnpm
 
 ```bash
-npm install -D eslint-plugin-playwright
+pnpm add -D eslint-plugin-playwright
 ```
 
 ## Usage
@@ -25,11 +30,11 @@ npm install -D eslint-plugin-playwright
 This plugin bundles two configurations to work with both `@playwright/test` or
 `jest-playwright`.
 
-### With [Playwright test runner](https://playwright.dev/docs/test-intro)
+### With [Playwright test runner](https://playwright.dev/docs/writing-tests)
 
 ```json
 {
-  "extends": ["plugin:playwright/playwright-test"]
+  "extends": ["plugin:playwright/recommended"]
 }
 ```
 
@@ -49,21 +54,25 @@ command line option.\
 💡: Some problems reported by this rule are manually fixable by editor
 [suggestions](https://eslint.org/docs/latest/developer-guide/working-with-rules#providing-suggestions).
 
-|  ✔  | 🔧  | 💡  | Rule                                                                                                                                              | Description                                                       |
-| :-: | :-: | :-: | ------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
-|  ✔  |     |     | [max-nested-describe](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/max-nested-describe.md)               | Enforces a maximum depth to nested describe calls                 |
-|  ✔  | 🔧  |     | [missing-playwright-await](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/missing-playwright-await.md)     | Enforce Playwright APIs to be awaited                             |
-|  ✔  |     |     | [no-conditional-in-test](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-in-test.md)         | Disallow conditional logic in tests                               |
-|  ✔  |     | 💡  | [no-element-handle](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-element-handle.md)                   | Disallow usage of element handles                                 |
-|  ✔  |     |     | [no-eval](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-eval.md)                                       | Disallow usage of `page.$eval` and `page.$$eval`                  |
-|  ✔  |     | 💡  | [no-focused-test](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-focused-test.md)                       | Disallow usage of `.only` annotation                              |
-|  ✔  |     |     | [no-force-option](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-force-option.md)                       | Disallow usage of the `{ force: true }` option                    |
-|  ✔  |     |     | [no-page-pause](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-page-pause.md)                           | Disallow using `page.pause`                                       |
-|     |     |     | [no-restricted-matchers](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-restricted-matchers.md)         | Disallow specific matchers & modifiers                            |
-|  ✔  |     | 💡  | [no-skipped-test](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-skipped-test.md)                       | Disallow usage of the `.skip` annotation                          |
-|  ✔  | 🔧  |     | [no-useless-not](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-useless-not.md)                         | Disallow usage of `not` matchers when a specific matcher exists   |
-|  ✔  |     | 💡  | [no-wait-for-timeout](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-timeout.md)               | Disallow usage of `page.waitForTimeout`                           |
-|     | 🔧  |     | [prefer-lowercase-title](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-lowercase-title.md)         | Enforce lowercase test names                                      |
-|     | 🔧  |     | [prefer-to-have-length](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-length.md)           | Suggest using `toHaveLength()`                                    |
-|     |     |     | [require-top-level-describe](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-top-level-describe.md) | Require test cases and hooks to be inside a `test.describe` block |
-|  ✔  |     |     | [valid-expect](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-expect.md)                             | Enforce valid `expect()` usage                                    |
+|  ✔  | 🔧  | 💡  | Rule                                                                                                                                                | Description                                                       |
+| :-: | :-: | :-: | --------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
+|  ✔  |     |     | [max-nested-describe](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/max-nested-describe.md)                 | Enforces a maximum depth to nested describe calls                 |
+|  ✔  | 🔧  |     | [missing-playwright-await](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/missing-playwright-await.md)       | Enforce Playwright APIs to be awaited                             |
+|  ✔  |     |     | [no-conditional-in-test](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-in-test.md)           | Disallow conditional logic in tests                               |
+|  ✔  |     | 💡  | [no-element-handle](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-element-handle.md)                     | Disallow usage of element handles                                 |
+|  ✔  |     |     | [no-eval](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-eval.md)                                         | Disallow usage of `page.$eval` and `page.$$eval`                  |
+|  ✔  |     | 💡  | [no-focused-test](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-focused-test.md)                         | Disallow usage of `.only` annotation                              |
+|  ✔  |     |     | [no-force-option](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-force-option.md)                         | Disallow usage of the `{ force: true }` option                    |
+|  ✔  |     |     | [no-page-pause](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-page-pause.md)                             | Disallow using `page.pause`                                       |
+|     |     |     | [no-restricted-matchers](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-restricted-matchers.md)           | Disallow specific matchers & modifiers                            |
+|  ✔  |     | 💡  | [no-skipped-test](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-skipped-test.md)                         | Disallow usage of the `.skip` annotation                          |
+|  ✔  | 🔧  |     | [no-useless-not](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-useless-not.md)                           | Disallow usage of `not` matchers when a specific matcher exists   |
+|  ✔  |     | 💡  | [no-wait-for-timeout](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-timeout.md)                 | Disallow usage of `page.waitForTimeout`                           |
+|     |     | 💡  | [prefer-strict-equal](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-strict-equal.md)                 | Suggest using `toStrictEqual()`                                   |
+|     | 🔧  |     | [prefer-lowercase-title](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-lowercase-title.md)           | Enforce lowercase test names                                      |
+|     | 🔧  |     | [prefer-to-be](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-be.md)                               | Suggest using `toBe()`                                            |
+|     | 🔧  |     | [prefer-to-have-length](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-length.md)             | Suggest using `toHaveLength()`                                    |
+|  ✔  | 🔧  |     | [prefer-web-first-assertions](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-web-first-assertions.md) | Suggest using web first assertions                                |
+|     |     |     | [require-top-level-describe](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-top-level-describe.md)   | Require test cases and hooks to be inside a `test.describe` block |
+|     | 🔧  |     | [require-soft-assertions](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-soft-assertions.md)         | Require assertions to use `expect.soft()`                         |
+|  ✔  |     |     | [valid-expect](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-expect.md)                               | Enforce valid `expect()` usage                                    |

package/lib/index.js

@@ -12,32 +12,39 @@ const no_conditional_in_test_1 = require("./rules/no-conditional-in-test");
 const no_restricted_matchers_1 = require("./rules/no-restricted-matchers");
 const no_useless_not_1 = require("./rules/no-useless-not");
 const prefer_lowercase_title_1 = require("./rules/prefer-lowercase-title");
+const prefer_to_be_1 = require("./rules/prefer-to-be");
 const prefer_to_have_length_1 = require("./rules/prefer-to-have-length");
+const prefer_strict_equal_1 = require("./rules/prefer-strict-equal");
+const require_soft_assertions_1 = require("./rules/require-soft-assertions");
 const require_top_level_describe_1 = require("./rules/require-top-level-describe");
 const valid_expect_1 = require("./rules/valid-expect");
+const prefer_web_first_assertions_1 = require("./rules/prefer-web-first-assertions");
+const recommended = {
+    plugins: ['playwright'],
+    env: {
+        'shared-node-browser': true,
+    },
+    rules: {
+        'no-empty-pattern': 'off',
+        'playwright/missing-playwright-await': 'error',
+        'playwright/no-page-pause': 'warn',
+        'playwright/no-element-handle': 'warn',
+        'playwright/no-eval': 'warn',
+        'playwright/no-focused-test': 'error',
+        'playwright/no-skipped-test': 'warn',
+        'playwright/no-wait-for-timeout': 'warn',
+        'playwright/no-force-option': 'warn',
+        'playwright/max-nested-describe': 'warn',
+        'playwright/no-conditional-in-test': 'warn',
+        'playwright/no-useless-not': 'warn',
+        'playwright/prefer-web-first-assertions': 'error',
+        'playwright/valid-expect': 'error',
+    },
+};
 module.exports = {
     configs: {
-        'playwright-test': {
-            plugins: ['playwright'],
-            env: {
-                'shared-node-browser': true,
-            },
-            rules: {
-                'no-empty-pattern': 'off',
-                'playwright/missing-playwright-await': 'error',
-                'playwright/no-page-pause': 'warn',
-                'playwright/no-element-handle': 'warn',
-                'playwright/no-eval': 'warn',
-                'playwright/no-focused-test': 'error',
-                'playwright/no-skipped-test': 'warn',
-                'playwright/no-wait-for-timeout': 'warn',
-                'playwright/no-force-option': 'warn',
-                'playwright/max-nested-describe': 'warn',
-                'playwright/no-conditional-in-test': 'warn',
-                'playwright/no-useless-not': 'warn',
-                'playwright/valid-expect': 'error',
-            },
-        },
+        recommended,
+        'playwright-test': recommended,
         'jest-playwright': {
             plugins: ['jest', 'playwright'],
             env: {
@@ -85,8 +92,12 @@ module.exports = {
         'no-useless-not': no_useless_not_1.default,
         'no-restricted-matchers': no_restricted_matchers_1.default,
         'prefer-lowercase-title': prefer_lowercase_title_1.default,
+        'prefer-strict-equal': prefer_strict_equal_1.default,
+        'prefer-to-be': prefer_to_be_1.default,
         'prefer-to-have-length': prefer_to_have_length_1.default,
+        'prefer-web-first-assertions': prefer_web_first_assertions_1.default,
         'require-top-level-describe': require_top_level_describe_1.default,
+        'require-soft-assertions': require_soft_assertions_1.default,
         'valid-expect': valid_expect_1.default,
     },
 };

package/lib/rules/max-nested-describe.js

@@ -14,7 +14,7 @@ exports.default = {
             describeCallbackStack.push(0);
             if (describeCallbackStack.length > max) {
                 context.report({
-                    node: node.parent,
+                    node: node.parent.callee,
                     messageId: 'exceededMaxDepth',
                     data: {
                         depth: describeCallbackStack.length.toString(),

package/lib/rules/missing-playwright-await.js

@@ -54,23 +54,35 @@ function getCallType(node, awaitableMatchers) {
         (0, ast_1.isPropertyAccessor)(node.callee, 'step')) {
         return { messageId: 'testStep' };
     }
-    const expectType = (0, ast_1.parseExpectCall)(node);
+    const expectType = (0, ast_1.getExpectType)(node);
     if (!expectType)
         return;
     // expect.poll
     if (expectType === 'poll') {
         return { messageId: 'expectPoll' };
     }
-    // expect with awitable matcher
+    // expect with awaitable matcher
     const [lastMatcher] = (0, ast_1.getMatchers)(node).slice(-1);
     const matcherName = (0, ast_1.getStringValue)(lastMatcher);
     if (awaitableMatchers.has(matcherName)) {
         return { messageId: 'expect', data: { matcherName } };
     }
 }
+function isPromiseAll(node) {
+    return node.type === 'ArrayExpression' &&
+        node.parent.type === 'CallExpression' &&
+        node.parent.callee.type === 'MemberExpression' &&
+        (0, ast_1.isIdentifier)(node.parent.callee.object, 'Promise') &&
+        (0, ast_1.isIdentifier)(node.parent.callee.property, 'all')
+        ? node.parent
+        : null;
+}
 function checkValidity(node) {
-    return validTypes.has(node.parent.type)
-        ? undefined
+    if (validTypes.has(node.parent.type))
+        return;
+    const promiseAll = isPromiseAll(node.parent);
+    return promiseAll
+        ? checkValidity(promiseAll)
         : node.parent.type === 'MemberExpression' ||
             (node.parent.type === 'CallExpression' && node.parent.callee === node)
             ? checkValidity(node.parent)
@@ -94,7 +106,7 @@ exports.default = {
                         fix: (fixer) => fixer.insertTextBefore(node, 'await '),
                         messageId: result.messageId,
                         data: result.data,
-                        node: reportNode,
+                        node: node.callee,
                     });
                 }
             },

package/lib/rules/no-element-handle.js

@@ -1,30 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ast_1 = require("../utils/ast");
-function getRange(node) {
-    const callee = node.callee;
-    const start = node.parent.type === 'AwaitExpression'
-        ? node.parent.range[0]
-        : callee.object.range[0];
-    return [start, callee.range[1]];
+function getPropertyRange(node) {
+    return node.type === 'Identifier'
+        ? node.range
+        : [node.range[0] + 1, node.range[1] - 1];
 }
 exports.default = {
     create(context) {
         return {
             CallExpression(node) {
-                if ((0, ast_1.isCalleeObject)(node, 'page') &&
-                    ((0, ast_1.isCalleeProperty)(node, '$') || (0, ast_1.isCalleeProperty)(node, '$$'))) {
+                if ((0, ast_1.isPageMethod)(node, '$') || (0, ast_1.isPageMethod)(node, '$$')) {
                     context.report({
                         messageId: 'noElementHandle',
                         suggest: [
                             {
-                                messageId: (0, ast_1.isCalleeProperty)(node, '$')
+                                messageId: (0, ast_1.isPageMethod)(node, '$')
                                     ? 'replaceElementHandleWithLocator'
                                     : 'replaceElementHandlesWithLocator',
-                                fix: (fixer) => fixer.replaceTextRange(getRange(node), 'page.locator'),
+                                fix: (fixer) => {
+                                    const { property } = node.callee;
+                                    // Replace $/$$ with locator
+                                    const fixes = [
+                                        fixer.replaceTextRange(getPropertyRange(property), 'locator'),
+                                    ];
+                                    // Remove the await expression if it exists as locators do
+                                    // not need to be awaited.
+                                    if (node.parent.type === 'AwaitExpression') {
+                                        fixes.push(fixer.removeRange([node.parent.range[0], node.range[0]]));
+                                    }
+                                    return fixes;
+                                },
                             },
                         ],
-                        node,
+                        node: node.callee,
                     });
                 }
             },

package/lib/rules/no-eval.js

@@ -5,11 +5,11 @@ exports.default = {
     create(context) {
         return {
             CallExpression(node) {
-                if ((0, ast_1.isCalleeObject)(node, 'page') &&
-                    ((0, ast_1.isCalleeProperty)(node, '$eval') || (0, ast_1.isCalleeProperty)(node, '$$eval'))) {
+                const isEval = (0, ast_1.isPageMethod)(node, '$eval');
+                if (isEval || (0, ast_1.isPageMethod)(node, '$$eval')) {
                     context.report({
-                        messageId: (0, ast_1.isCalleeProperty)(node, '$eval') ? 'noEval' : 'noEvalAll',
-                        node,
+                        messageId: isEval ? 'noEval' : 'noEvalAll',
+                        node: node.callee,
                     });
                 }
             },

package/lib/rules/no-focused-test.js

@@ -21,7 +21,7 @@ exports.default = {
                                 ]),
                             },
                         ],
-                        node,
+                        node: node.callee.property,
                     });
                 }
             },

package/lib/rules/no-force-option.js

@@ -4,7 +4,7 @@ const ast_1 = require("../utils/ast");
 function isForceOptionEnabled(node) {
     const arg = node.arguments[node.arguments.length - 1];
     return (arg?.type === 'ObjectExpression' &&
-        arg.properties.some((property) => property.type === 'Property' &&
+        arg.properties.find((property) => property.type === 'Property' &&
             (0, ast_1.getStringValue)(property.key) === 'force' &&
             (0, ast_1.isBooleanLiteral)(property.value, true)));
 }
@@ -27,9 +27,11 @@ exports.default = {
         return {
             MemberExpression(node) {
                 if (methodsWithForceOption.has((0, ast_1.getStringValue)(node.property)) &&
-                    node.parent.type === 'CallExpression' &&
-                    isForceOptionEnabled(node.parent)) {
-                    context.report({ messageId: 'noForceOption', node });
+                    node.parent.type === 'CallExpression') {
+                    const reportNode = isForceOptionEnabled(node.parent);
+                    if (reportNode) {
+                        context.report({ messageId: 'noForceOption', node: reportNode });
+                    }
                 }
             },
         };

package/lib/rules/no-page-pause.js

@@ -5,7 +5,7 @@ exports.default = {
     create(context) {
         return {
             CallExpression(node) {
-                if ((0, ast_1.isCalleeObject)(node, 'page') && (0, ast_1.isCalleeProperty)(node, 'pause')) {
+                if ((0, ast_1.isPageMethod)(node, 'pause')) {
                     context.report({ messageId: 'noPagePause', node });
                 }
             },

package/lib/rules/no-restricted-matchers.js

@@ -1,31 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ast_1 = require("../utils/ast");
+const parseExpectCall_1 = require("../utils/parseExpectCall");
 exports.default = {
     create(context) {
         const restrictedChains = (context.options?.[0] ?? {});
         return {
             CallExpression(node) {
-                if (!(0, ast_1.isExpectCall)(node)) {
+                const expectCall = (0, parseExpectCall_1.parseExpectCall)(node);
+                if (!expectCall)
                     return;
-                }
-                const matchers = (0, ast_1.getMatchers)(node);
-                const permutations = matchers.map((_, i) => matchers.slice(0, i + 1));
-                for (const permutation of permutations) {
-                    const chain = permutation.map(ast_1.getStringValue).join('.');
-                    if (chain in restrictedChains) {
-                        const message = restrictedChains[chain];
-                        context.report({
-                            messageId: message ? 'restrictedWithMessage' : 'restricted',
-                            data: { message: message ?? '', chain },
-                            loc: {
-                                start: permutation[0].loc.start,
-                                end: permutation[permutation.length - 1].loc.end,
-                            },
-                        });
-                        break;
-                    }
-                }
+                Object.entries(restrictedChains)
+                    .map(([restriction, message]) => {
+                    const chain = expectCall.members;
+                    const restrictionLinks = restriction.split('.').length;
+                    // Find in the full chain, where the restriction chain starts
+                    const startIndex = chain.findIndex((_, i) => {
+                        // Construct the partial chain to compare against the restriction
+                        // chain string.
+                        const partial = chain
+                            .slice(i, i + restrictionLinks)
+                            .map(ast_1.getStringValue)
+                            .join('.');
+                        return partial === restriction;
+                    });
+                    return {
+                        // If the restriction chain was found, return the portion of the
+                        // chain that matches the restriction chain.
+                        chain: startIndex !== -1
+                            ? chain.slice(startIndex, startIndex + restrictionLinks)
+                            : [],
+                        restriction,
+                        message,
+                    };
+                })
+                    .filter(({ chain }) => chain.length)
+                    .forEach(({ chain, restriction, message }) => {
+                    context.report({
+                        messageId: message ? 'restrictedWithMessage' : 'restricted',
+                        data: { message: message ?? '', restriction },
+                        loc: {
+                            start: chain[0].loc.start,
+                            end: chain[chain.length - 1].loc.end,
+                        },
+                    });
+                });
             },
         };
     },
@@ -37,7 +56,7 @@ exports.default = {
             url: 'https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-restricted-matchers.md',
         },
         messages: {
-            restricted: 'Use of `{{chain}}` is disallowed',
+            restricted: 'Use of `{{restriction}}` is disallowed',
             restrictedWithMessage: '{{message}}',
         },
         type: 'suggestion',

package/lib/rules/no-skipped-test.js

@@ -9,13 +9,14 @@ exports.default = {
                 if (((0, ast_1.isTestIdentifier)(callee) || (0, ast_1.isDescribeCall)(node)) &&
                     callee.type === 'MemberExpression' &&
                     (0, ast_1.isPropertyAccessor)(callee, 'skip')) {
+                    const isHook = (0, ast_1.isTest)(node) || (0, ast_1.isDescribeCall)(node);
                     context.report({
                         messageId: 'noSkippedTest',
                         suggest: [
                             {
                                 messageId: 'removeSkippedTestAnnotation',
                                 fix: (fixer) => {
-                                    return (0, ast_1.isTest)(node) || (0, ast_1.isDescribeCall)(node)
+                                    return isHook
                                         ? fixer.removeRange([
                                             callee.property.range[0] - 1,
                                             callee.range[1],
@@ -24,7 +25,7 @@ exports.default = {
                                 },
                             },
                         ],
-                        node,
+                        node: isHook ? callee.property : node,
                     });
                 }
             },

package/lib/rules/no-useless-not.js

@@ -1,43 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ast_1 = require("../utils/ast");
+const fixer_1 = require("../utils/fixer");
+const parseExpectCall_1 = require("../utils/parseExpectCall");
 const matcherMap = {
     toBeVisible: 'toBeHidden',
     toBeHidden: 'toBeVisible',
     toBeEnabled: 'toBeDisabled',
     toBeDisabled: 'toBeEnabled',
 };
-const getRangeOffset = (node) => node.type === 'Identifier' ? 0 : 1;
 exports.default = {
     create(context) {
         return {
-            MemberExpression(node) {
-                if (node.object.type === 'MemberExpression' &&
-                    node.object.object.type === 'CallExpression' &&
-                    (0, ast_1.isExpectCall)(node.object.object) &&
-                    (0, ast_1.isPropertyAccessor)(node.object, 'not')) {
-                    const matcher = (0, ast_1.getStringValue)(node.property);
-                    if (matcher && matcher in matcherMap) {
-                        const { property } = node.object;
-                        context.report({
-                            fix: (fixer) => [
-                                fixer.removeRange([
-                                    property.range[0] - getRangeOffset(property),
-                                    property.range[1] + 1,
-                                ]),
-                                fixer.replaceTextRange([
-                                    node.property.range[0] + getRangeOffset(node.property),
-                                    node.property.range[1] - getRangeOffset(node.property),
-                                ], matcherMap[matcher]),
-                            ],
-                            messageId: 'noUselessNot',
-                            node: node,
-                            data: {
-                                old: matcher,
-                                new: matcherMap[matcher],
-                            },
-                        });
-                    }
+            CallExpression(node) {
+                const expectCall = (0, parseExpectCall_1.parseExpectCall)(node);
+                if (!expectCall)
+                    return;
+                // As the name implies, this rule only implies if the not modifier is
+                // part of the matcher chain
+                const notModifier = expectCall.modifiers.find((mod) => (0, ast_1.getStringValue)(mod) === 'not');
+                if (!notModifier)
+                    return;
+                // This rule only applies to specific matchers that have opposites
+                if (expectCall.matcherName in matcherMap) {
+                    const newMatcher = matcherMap[expectCall.matcherName];
+                    context.report({
+                        fix: (fixer) => [
+                            fixer.removeRange([
+                                notModifier.range[0] - (0, fixer_1.getRangeOffset)(notModifier),
+                                notModifier.range[1] + 1,
+                            ]),
+                            (0, fixer_1.replaceAccessorFixer)(fixer, expectCall.matcher, newMatcher),
+                        ],
+                        messageId: 'noUselessNot',
+                        data: { old: expectCall.matcherName, new: newMatcher },
+                        loc: {
+                            start: notModifier.loc.start,
+                            end: expectCall.matcher.loc.end,
+                        },
+                    });
                 }
             },
         };

package/lib/rules/no-wait-for-timeout.js

@@ -5,8 +5,7 @@ exports.default = {
     create(context) {
         return {
             CallExpression(node) {
-                if ((0, ast_1.isCalleeObject)(node, 'page') &&
-                    (0, ast_1.isCalleeProperty)(node, 'waitForTimeout')) {
+                if ((0, ast_1.isPageMethod)(node, 'waitForTimeout')) {
                     context.report({
                         messageId: 'noWaitForTimeout',
                         suggest: [

package/lib/rules/prefer-strict-equal.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fixer_1 = require("../utils/fixer");
+const parseExpectCall_1 = require("../utils/parseExpectCall");
+exports.default = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const expectCall = (0, parseExpectCall_1.parseExpectCall)(node);
+                if (expectCall?.matcherName === 'toEqual') {
+                    context.report({
+                        node: expectCall.matcher,
+                        messageId: 'useToStrictEqual',
+                        suggest: [
+                            {
+                                messageId: 'suggestReplaceWithStrictEqual',
+                                fix: (fixer) => {
+                                    return (0, fixer_1.replaceAccessorFixer)(fixer, expectCall.matcher, 'toStrictEqual');
+                                },
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            category: 'Best Practices',
+            description: 'Suggest using `toStrictEqual()`',
+            recommended: false,
+            url: 'https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-strict-equal.md',
+        },
+        messages: {
+            useToStrictEqual: 'Use toStrictEqual() instead',
+            suggestReplaceWithStrictEqual: 'Replace with `toStrictEqual()`',
+        },
+        fixable: 'code',
+        type: 'suggestion',
+        hasSuggestions: true,
+        schema: [],
+    },
+};

package/lib/rules/prefer-to-be.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ast_1 = require("../utils/ast");
+const fixer_1 = require("../utils/fixer");
+const parseExpectCall_1 = require("../utils/parseExpectCall");
+function shouldUseToBe(expectCall) {
+    let arg = expectCall.args[0];
+    if (arg.type === 'UnaryExpression' && arg.operator === '-') {
+        arg = arg.argument;
+    }
+    if (arg.type === 'Literal') {
+        // regex literals are classed as literals, but they're actually objects
+        // which means "toBe" will give different results than other matchers
+        return !('regex' in arg);
+    }
+    return arg.type === 'TemplateLiteral';
+}
+function reportPreferToBe(context, expectCall, whatToBe, notModifier) {
+    context.report({
+        node: expectCall.matcher,
+        messageId: `useToBe${whatToBe}`,
+        fix(fixer) {
+            const fixes = [
+                (0, fixer_1.replaceAccessorFixer)(fixer, expectCall.matcher, `toBe${whatToBe}`),
+            ];
+            if (expectCall.args?.length && whatToBe !== '') {
+                fixes.push(fixer.remove(expectCall.args[0]));
+            }
+            if (notModifier) {
+                const [start, end] = notModifier.range;
+                fixes.push(fixer.removeRange([start - 1, end]));
+            }
+            return fixes;
+        },
+    });
+}
+exports.default = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const expectCall = (0, parseExpectCall_1.parseExpectCall)(node);
+                if (!expectCall)
+                    return;
+                const notMatchers = ['toBeUndefined', 'toBeDefined'];
+                const notModifier = expectCall.modifiers.find((node) => (0, ast_1.getStringValue)(node) === 'not');
+                if (notModifier && notMatchers.includes(expectCall.matcherName)) {
+                    return reportPreferToBe(context, expectCall, expectCall.matcherName === 'toBeDefined' ? 'Undefined' : 'Defined', notModifier);
+                }
+                const argumentMatchers = ['toBe', 'toEqual', 'toStrictEqual'];
+                const firstArg = expectCall.args[0];
+                if (!argumentMatchers.includes(expectCall.matcherName) || !firstArg) {
+                    return;
+                }
+                if (firstArg.type === 'Literal' && firstArg.value === null) {
+                    return reportPreferToBe(context, expectCall, 'Null');
+                }
+                if ((0, ast_1.isIdentifier)(firstArg, 'undefined')) {
+                    const name = notModifier ? 'Defined' : 'Undefined';
+                    return reportPreferToBe(context, expectCall, name, notModifier);
+                }
+                if ((0, ast_1.isIdentifier)(firstArg, 'NaN')) {
+                    return reportPreferToBe(context, expectCall, 'NaN');
+                }
+                if (shouldUseToBe(expectCall) && expectCall.matcherName !== 'toBe') {
+                    reportPreferToBe(context, expectCall, '');
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            category: 'Best Practices',
+            description: 'Suggest using `toBe()` for primitive literals',
+            recommended: false,
+            url: 'https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-be.md',
+        },
+        messages: {
+            useToBe: 'Use `toBe` when expecting primitive literals',
+            useToBeUndefined: 'Use `toBeUndefined` instead',
+            useToBeDefined: 'Use `toBeDefined` instead',
+            useToBeNull: 'Use `toBeNull` instead',
+            useToBeNaN: 'Use `toBeNaN` instead',
+        },
+        fixable: 'code',
+        type: 'suggestion',
+        schema: [],
+    },
+};

package/lib/rules/prefer-to-have-length.js

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ast_1 = require("../utils/ast");
-const matchers = new Set(['toBe', 'toEqual', 'toStrictEqual']);
-const getRangeOffset = (node) => node.type === 'Identifier' ? 0 : 1;
+const fixer_1 = require("../utils/fixer");
+const parseExpectCall_1 = require("../utils/parseExpectCall");
+const lengthMatchers = new Set(['toBe', 'toEqual', 'toStrictEqual']);
 exports.default = {
     create(context) {
         return {
             CallExpression(node) {
-                if (!(0, ast_1.isExpectCall)(node)) {
+                const expectCall = (0, parseExpectCall_1.parseExpectCall)(node);
+                if (!expectCall || !lengthMatchers.has(expectCall.matcherName)) {
                     return;
                 }
                 const [argument] = node.arguments;
-                const [matcher] = (0, ast_1.getMatchers)(node).slice(-1);
-                if (!matcher ||
-                    !matchers.has((0, ast_1.getStringValue)(matcher) ?? '') ||
-                    argument?.type !== 'MemberExpression' ||
+                if (argument?.type !== 'MemberExpression' ||
                     !(0, ast_1.isPropertyAccessor)(argument, 'length')) {
                     return;
                 }
@@ -27,14 +26,11 @@ exports.default = {
                                 argument.range[1],
                             ]),
                             // replace the current matcher with "toHaveLength"
-                            fixer.replaceTextRange([
-                                matcher.range[0] + getRangeOffset(matcher),
-                                matcher.range[1] - getRangeOffset(matcher),
-                            ], 'toHaveLength'),
+                            (0, fixer_1.replaceAccessorFixer)(fixer, expectCall.matcher, 'toHaveLength'),
                         ];
                     },
                     messageId: 'useToHaveLength',
-                    node: matcher,
+                    node: expectCall.matcher,
                 });
             },
         };

package/lib/rules/prefer-web-first-assertions.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMatcherCall = void 0;
+const ast_1 = require("../utils/ast");
+const parseExpectCall_1 = require("../utils/parseExpectCall");
+const methods = {
+    innerText: { type: 'string', matcher: 'toHaveText' },
+    textContent: { type: 'string', matcher: 'toHaveText' },
+    inputValue: { type: 'string', matcher: 'toHaveValue' },
+    isEditable: { type: 'boolean', matcher: 'toBeEditable' },
+    isChecked: { type: 'boolean', matcher: 'toBeChecked' },
+    isDisabled: {
+        type: 'boolean',
+        matcher: 'toBeDisabled',
+        inverse: 'toBeEnabled',
+    },
+    isEnabled: {
+        type: 'boolean',
+        matcher: 'toBeEnabled',
+        inverse: 'toBeDisabled',
+    },
+    isHidden: {
+        type: 'boolean',
+        matcher: 'toBeHidden',
+        inverse: 'toBeVisible',
+    },
+    isVisible: {
+        type: 'boolean',
+        matcher: 'toBeVisible',
+        inverse: 'toBeHidden',
+    },
+    getAttribute: {
+        type: 'string',
+        matcher: 'toHaveAttribute',
+    },
+};
+const supportedMatchers = new Set([
+    'toBe',
+    'toEqual',
+    'toBeTruthy',
+    'toBeFalsy',
+]);
+function getMatcherCall(node) {
+    const grandparent = node.parent?.parent;
+    return grandparent.type === 'CallExpression' ? grandparent : undefined;
+}
+exports.getMatcherCall = getMatcherCall;
+exports.default = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const expectCall = (0, parseExpectCall_1.parseExpectCall)(node);
+                if (!expectCall)
+                    return;
+                const [arg] = node.arguments;
+                if (arg.type !== 'AwaitExpression' ||
+                    arg.argument.type !== 'CallExpression' ||
+                    arg.argument.callee.type !== 'MemberExpression') {
+                    return;
+                }
+                // Matcher must be supported
+                if (!supportedMatchers.has(expectCall.matcherName))
+                    return;
+                // Playwright method must be supported
+                const method = (0, ast_1.getStringValue)(arg.argument.callee.property);
+                const methodConfig = methods[method];
+                if (!methodConfig)
+                    return;
+                // Change the matcher
+                const { args, matcher } = expectCall;
+                const notModifier = expectCall.modifiers.find((mod) => (0, ast_1.getStringValue)(mod) === 'not');
+                const isFalsy = methodConfig.type === 'boolean' &&
+                    ((!!args.length && (0, ast_1.isBooleanLiteral)(args[0], false)) ||
+                        expectCall.matcherName === 'toBeFalsy');
+                const isInverse = methodConfig.inverse
+                    ? notModifier || isFalsy
+                    : notModifier && isFalsy;
+                // Replace the old matcher with the new matcher. The inverse
+                // matcher should only be used if the old statement was not a
+                // double negation.
+                const newMatcher = (+!!notModifier ^ +isFalsy && methodConfig.inverse) ||
+                    methodConfig.matcher;
+                const { callee } = arg.argument;
+                context.report({
+                    node,
+                    messageId: 'useWebFirstAssertion',
+                    data: {
+                        method: method,
+                        matcher: newMatcher,
+                    },
+                    fix: (fixer) => {
+                        const methodArgs = arg.argument.type === 'CallExpression'
+                            ? arg.argument.arguments
+                            : [];
+                        const methodEnd = methodArgs.length
+                            ? methodArgs[methodArgs.length - 1].range[1] + 1
+                            : callee.property.range[1] + 2;
+                        const fixes = [
+                            // Add await to the expect call
+                            fixer.insertTextBefore(node, 'await '),
+                            // Remove the await keyword
+                            fixer.replaceTextRange([arg.range[0], arg.argument.range[0]], ''),
+                            // Remove the old Playwright method and any arguments
+                            fixer.replaceTextRange([callee.property.range[0] - 1, methodEnd], ''),
+                        ];
+                        // Remove not from matcher chain if no longer needed
+                        if (isInverse && notModifier) {
+                            const notRange = notModifier.range;
+                            fixes.push(fixer.removeRange([notRange[0], notRange[1] + 1]));
+                        }
+                        // Add not to the matcher chain if no inverse matcher exists
+                        if (!methodConfig.inverse && !notModifier && isFalsy) {
+                            fixes.push(fixer.insertTextBefore(matcher, 'not.'));
+                        }
+                        fixes.push(fixer.replaceText(matcher, newMatcher));
+                        // Remove boolean argument if it exists
+                        const [matcherArg] = args ?? [];
+                        if (matcherArg && (0, ast_1.isBooleanLiteral)(matcherArg)) {
+                            fixes.push(fixer.remove(matcherArg));
+                        }
+                        // Add the new matcher arguments if needed
+                        const hasOtherArgs = !!methodArgs.filter((arg) => !(0, ast_1.isBooleanLiteral)(arg)).length;
+                        if (methodArgs) {
+                            const range = matcher.range;
+                            const stringArgs = methodArgs
+                                .map((arg) => (0, ast_1.getRawValue)(arg))
+                                .concat(hasOtherArgs ? '' : [])
+                                .join(', ');
+                            fixes.push(fixer.insertTextAfterRange([range[0], range[1] + 1], stringArgs));
+                        }
+                        return fixes;
+                    },
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            category: 'Best Practices',
+            description: 'Prefer web first assertions',
+            recommended: true,
+            url: 'https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-web-first-assertions.md',
+        },
+        fixable: 'code',
+        messages: {
+            useWebFirstAssertion: 'Replace {{method}}() with {{matcher}}().',
+        },
+        type: 'suggestion',
+    },
+};

package/lib/rules/require-soft-assertions.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ast_1 = require("../utils/ast");
+exports.default = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                if ((0, ast_1.getExpectType)(node) === 'standalone') {
+                    context.report({
+                        node: node.callee,
+                        messageId: 'requireSoft',
+                        fix: (fixer) => fixer.insertTextAfter(node.callee, '.soft'),
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Require all assertions to use `expect.soft`',
+            recommended: false,
+            url: 'https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-soft-assertions.md',
+        },
+        messages: {
+            requireSoft: 'Unexpected non-soft assertion',
+        },
+        fixable: 'code',
+        type: 'suggestion',
+        schema: [],
+    },
+};

package/lib/rules/require-top-level-describe.js

@@ -18,7 +18,7 @@ exports.default = {
                         topLevelDescribeCount++;
                         if (topLevelDescribeCount > maxTopLevelDescribes) {
                             context.report({
-                                node,
+                                node: node.callee,
                                 messageId: 'tooManyDescribes',
                                 data: (0, misc_1.getAmountData)(maxTopLevelDescribes),
                             });
@@ -27,10 +27,10 @@ exports.default = {
                 }
                 else if (!describeCount) {
                     if ((0, ast_1.isTest)(node)) {
-                        context.report({ node, messageId: 'unexpectedTest' });
+                        context.report({ node: node.callee, messageId: 'unexpectedTest' });
                     }
                     else if ((0, ast_1.isTestHook)(node)) {
-                        context.report({ node, messageId: 'unexpectedHook' });
+                        context.report({ node: node.callee, messageId: 'unexpectedHook' });
                     }
                 }
             },

package/lib/rules/valid-expect.js

@@ -2,16 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ast_1 = require("../utils/ast");
 const misc_1 = require("../utils/misc");
-function isMatcherFound(node) {
-    if (node.parent.type !== 'MemberExpression') {
-        return { found: false, node };
-    }
-    if ((0, ast_1.isPropertyAccessor)(node.parent, 'not') &&
-        node.parent.parent.type !== 'MemberExpression') {
-        return { found: false, node: node.parent };
-    }
-    return { found: true, node };
-}
+const parseExpectCall_1 = require("../utils/parseExpectCall");
 function isMatcherCalled(node) {
     if (node.parent.type !== 'MemberExpression') {
         // Just asserting that the parent is a call expression is not enough as
@@ -40,15 +31,17 @@ exports.default = {
             CallExpression(node) {
                 if (!(0, ast_1.isExpectCall)(node))
                     return;
-                const result = isMatcherFound(node);
-                if (!result.found) {
-                    context.report({ node: result.node, messageId: 'matcherNotFound' });
+                const expectCall = (0, parseExpectCall_1.parseExpectCall)(node);
+                if (!expectCall) {
+                    context.report({ node, messageId: 'matcherNotFound' });
                 }
                 else {
                     const result = isMatcherCalled(node);
                     if (!result.called) {
                         context.report({
-                            node: result.node,
+                            node: result.node.type === 'MemberExpression'
+                                ? result.node.property
+                                : result.node,
                             messageId: 'matcherNotCalled',
                         });
                     }

package/lib/utils/ast.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMatchers = exports.isExpectCall = exports.parseExpectCall = exports.isTestHook = exports.isTest = exports.findParent = exports.isDescribeCall = exports.isTestIdentifier = exports.isCalleeProperty = exports.isCalleeObject = exports.isPropertyAccessor = exports.isBooleanLiteral = exports.isStringLiteral = exports.isIdentifier = exports.getStringValue = void 0;
+exports.isPageMethod = exports.getMatchers = exports.isExpectCall = exports.getExpectType = exports.isTestHook = exports.isTest = exports.findParent = exports.isDescribeCall = exports.isTestIdentifier = exports.isPropertyAccessor = exports.isBooleanLiteral = exports.isStringLiteral = exports.isIdentifier = exports.getRawValue = exports.getStringValue = void 0;
 function getStringValue(node) {
     if (!node)
         return '';
@@ -13,8 +13,13 @@ function getStringValue(node) {
                 : '';
 }
 exports.getStringValue = getStringValue;
+function getRawValue(node) {
+    return node.type === 'Literal' ? node.raw : undefined;
+}
+exports.getRawValue = getRawValue;
 function isIdentifier(node, name) {
-    return node.type === 'Identifier' && node.name === name;
+    return (node.type === 'Identifier' &&
+        (typeof name === 'string' ? node.name === name : name.test(node.name)));
 }
 exports.isIdentifier = isIdentifier;
 function isLiteral(node, type, value) {
@@ -35,16 +40,6 @@ function isPropertyAccessor(node, name) {
     return getStringValue(node.property) === name;
 }
 exports.isPropertyAccessor = isPropertyAccessor;
-function isCalleeObject(node, name) {
-    return (node.callee.type === 'MemberExpression' &&
-        isIdentifier(node.callee.object, name));
-}
-exports.isCalleeObject = isCalleeObject;
-function isCalleeProperty(node, name) {
-    return (node.callee.type === 'MemberExpression' &&
-        isPropertyAccessor(node.callee, name));
-}
-exports.isCalleeProperty = isCalleeProperty;
 function isTestIdentifier(node) {
     return (isIdentifier(node, 'test') ||
         (node.type === 'MemberExpression' && isIdentifier(node.object, 'test')));
@@ -96,7 +91,7 @@ function isTestHook(node) {
 }
 exports.isTestHook = isTestHook;
 const expectSubCommands = new Set(['soft', 'poll']);
-function parseExpectCall(node) {
+function getExpectType(node) {
     if (isIdentifier(node.callee, 'expect')) {
         return 'standalone';
     }
@@ -106,15 +101,37 @@ function parseExpectCall(node) {
         return expectSubCommands.has(type) ? type : undefined;
     }
 }
-exports.parseExpectCall = parseExpectCall;
+exports.getExpectType = getExpectType;
 function isExpectCall(node) {
-    return !!parseExpectCall(node);
+    return !!getExpectType(node);
 }
 exports.isExpectCall = isExpectCall;
 function getMatchers(node, chain = []) {
     if (node.parent.type === 'MemberExpression' && node.parent.object === node) {
-        return getMatchers(node.parent, [...chain, node.parent.property]);
+        return getMatchers(node.parent, [
+            ...chain,
+            node.parent.property,
+        ]);
     }
     return chain;
 }
 exports.getMatchers = getMatchers;
+/**
+ * Digs through a series of MemberExpressions and CallExpressions to find an
+ * Identifier with the given name.
+ */
+function dig(node, identifier) {
+    return node.type === 'MemberExpression'
+        ? dig(node.property, identifier)
+        : node.type === 'CallExpression'
+            ? dig(node.callee, identifier)
+            : node.type === 'Identifier'
+                ? isIdentifier(node, identifier)
+                : false;
+}
+function isPageMethod(node, name) {
+    return (node.callee.type === 'MemberExpression' &&
+        dig(node.callee.object, /(^page|Page$)/) &&
+        isPropertyAccessor(node.callee, name));
+}
+exports.isPageMethod = isPageMethod;

package/lib/utils/fixer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceAccessorFixer = exports.getRangeOffset = void 0;
+const getRangeOffset = (node) => node.type === 'Identifier' ? 0 : 1;
+exports.getRangeOffset = getRangeOffset;
+/**
+ * Replaces an accessor node with the given `text`.
+ *
+ * This ensures that fixes produce valid code when replacing both dot-based and
+ * bracket-based property accessors.
+ */
+function replaceAccessorFixer(fixer, node, text) {
+    const [start, end] = node.range;
+    return fixer.replaceTextRange([start + (0, exports.getRangeOffset)(node), end - (0, exports.getRangeOffset)(node)], text);
+}
+exports.replaceAccessorFixer = replaceAccessorFixer;

package/lib/utils/parseExpectCall.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExpectCall = void 0;
+const ast_1 = require("./ast");
+const MODIFIER_NAMES = new Set(['not', 'resolves', 'rejects']);
+function getExpectArguments(node) {
+    const grandparent = node.parent.parent;
+    return grandparent.type === 'CallExpression' ? grandparent.arguments : [];
+}
+function parseExpectCall(node) {
+    if (!(0, ast_1.isExpectCall)(node)) {
+        return;
+    }
+    const members = (0, ast_1.getMatchers)(node);
+    const modifiers = [];
+    let matcher;
+    // Separate the matchers (e.g. toBe) from modifiers (e.g. not)
+    members.forEach((item) => {
+        if (MODIFIER_NAMES.has((0, ast_1.getStringValue)(item))) {
+            modifiers.push(item);
+        }
+        else {
+            matcher = item;
+        }
+    });
+    // Rules only run against full expect calls with matchers
+    if (!matcher) {
+        return;
+    }
+    return {
+        members,
+        matcher,
+        matcherName: (0, ast_1.getStringValue)(matcher),
+        modifiers,
+        args: getExpectArguments(matcher),
+    };
+}
+exports.parseExpectCall = parseExpectCall;

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "eslint-plugin-playwright",
   "description": "ESLint plugin for Playwright testing.",
-  "version": "0.11.2",
+  "version": "0.13.0",
   "main": "lib/index.js",
   "repository": "https://github.com/playwright-community/eslint-plugin-playwright",
   "author": "Max Schmitt <max@schmitt.mx>",
+  "contributors": [
+    "Mark Skelton <mark@mskelton.dev>"
+  ],
   "license": "MIT",
   "files": [
     "lib",