eslint-plugin-playwright 2.7.1 → 2.9.0

package/README.md

@@ -79,8 +79,8 @@ can configure this plugin to be aware of these additional names.
   "settings": {
     "playwright": {
       "globalAliases": {
-        "test": ["myTest"],
-        "expect": ["myExpect"]
+        "test": ["it"],
+        "expect": ["assert"]
       }
     }
   }
@@ -127,13 +127,13 @@ CLI option\
 | [no-commented-out-tests](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-commented-out-tests.md)                       | Disallow commented out tests                                       |     |     |     |
 | [no-conditional-expect](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-expect.md)                         | Disallow calling `expect` conditionally                            | ✅  |     |     |
 | [no-conditional-in-test](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-in-test.md)                       | Disallow conditional logic in tests                                | ✅  |     |     |
-| [no-duplicate-hooks](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-duplicate-hooks.md)                               | Disallow duplicate setup and teardown hooks                        |     |     |     |
+| [no-duplicate-hooks](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-duplicate-hooks.md)                               | Disallow duplicate setup and teardown hooks                        | ✅  |     |     |
 | [no-duplicate-slow](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-duplicate-slow.md)                                 | Disallow multiple `test.slow()` calls in the same test             | ✅  |     |     |
 | [no-element-handle](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-element-handle.md)                                 | Disallow usage of element handles                                  | ✅  |     | 💡  |
 | [no-eval](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-eval.md)                                                     | Disallow usage of `page.$eval()` and `page.$$eval()`               | ✅  |     |     |
 | [no-focused-test](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-focused-test.md)                                     | Disallow usage of `.only` annotation                               | ✅  |     | 💡  |
 | [no-force-option](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-force-option.md)                                     | Disallow usage of the `{ force: true }` option                     | ✅  |     |     |
-| [no-get-by-title](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-get-by-title.md)                                     | Disallow using `getByTitle()`                                      |     | 🔧  |     |
+| [no-get-by-title](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-get-by-title.md)                                     | Disallow using `getByTitle()`                                      |     |     |     |
 | [no-hooks](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-hooks.md)                                                   | Disallow setup and teardown hooks                                  |     |     |     |
 | [no-nested-step](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-nested-step.md)                                       | Disallow nested `test.step()` methods                              | ✅  |     |     |
 | [no-networkidle](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-networkidle.md)                                       | Disallow usage of the `networkidle` option                         | ✅  |     |     |
@@ -145,7 +145,7 @@ CLI option\
 | [no-restricted-roles](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-restricted-roles.md)                             | Disallow specific roles in `getByRole()`                           |     |     |     |
 | [no-skipped-test](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-skipped-test.md)                                     | Disallow usage of the `.skip` annotation                           | ✅  |     | 💡  |
 | [no-slowed-test](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-slowed-test.md)                                       | Disallow usage of the `.slow` annotation                           |     |     | 💡  |
-| [no-standalone-expect](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-standalone-expect.md)                           | Disallow using expect outside of `test` blocks                     | ✅  |     |     |
+| [no-standalone-expect](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-standalone-expect.md)                           | Disallow using expect outside of `test` blocks                     | ✅  | 🔧  |     |
 | [no-unsafe-references](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-unsafe-references.md)                           | Prevent unsafe variable references in `page.evaluate()`            | ✅  | 🔧  |     |
 | [no-unused-locators](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-unused-locators.md)                               | Disallow usage of page locators that are not used                  | ✅  |     |     |
 | [no-useless-await](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-useless-await.md)                                   | Disallow unnecessary `await`s for Playwright methods               | ✅  | 🔧  |     |
@@ -155,16 +155,16 @@ CLI option\
 | [no-wait-for-timeout](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-timeout.md)                             | Disallow usage of `page.waitForTimeout()`                          | ✅  |     | 💡  |
 | [prefer-comparison-matcher](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-comparison-matcher.md)                 | Suggest using the built-in comparison matchers                     |     | 🔧  |     |
 | [prefer-equality-matcher](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-equality-matcher.md)                     | Suggest using the built-in equality matchers                       |     |     | 💡  |
-| [prefer-hooks-in-order](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-in-order.md)                         | Prefer having hooks in a consistent order                          |     |     |     |
-| [prefer-hooks-on-top](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-on-top.md)                             | Suggest having hooks before any test cases                         |     |     |     |
+| [prefer-hooks-in-order](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-in-order.md)                         | Prefer having hooks in a consistent order                          | ✅  |     |     |
+| [prefer-hooks-on-top](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-on-top.md)                             | Suggest having hooks before any test cases                         | ✅  |     |     |
 | [prefer-lowercase-title](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-lowercase-title.md)                       | Enforce lowercase test names                                       |     | 🔧  |     |
 | [prefer-native-locators](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-native-locators.md)                       | Suggest built-in locators over `page.locator()`                    |     | 🔧  |     |
-| [prefer-locator](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-locator.md)                                       | Suggest locators over page methods                                 |     |     |     |
-| [prefer-strict-equal](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-strict-equal.md)                             | Suggest using `toStrictEqual()`                                    |     |     | 💡  |
+| [prefer-locator](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-locator.md)                                       | Suggest locators over page methods                                 | ✅  |     |     |
+| [prefer-strict-equal](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-strict-equal.md)                             | Suggest using `toStrictEqual()`                                    |     | 🔧  | 💡  |
 | [prefer-to-be](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-be.md)                                           | Suggest using `toBe()`                                             |     | 🔧  |     |
 | [prefer-to-contain](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-contain.md)                                 | Suggest using `toContain()`                                        |     | 🔧  |     |
-| [prefer-to-have-count](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-count.md)                           | Suggest using `toHaveCount()`                                      |     | 🔧  |     |
-| [prefer-to-have-length](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-length.md)                         | Suggest using `toHaveLength()`                                     |     | 🔧  |     |
+| [prefer-to-have-count](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-count.md)                           | Suggest using `toHaveCount()`                                      | ✅  | 🔧  |     |
+| [prefer-to-have-length](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-length.md)                         | Suggest using `toHaveLength()`                                     | ✅  | 🔧  |     |
 | [prefer-web-first-assertions](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-web-first-assertions.md)             | Suggest using web first assertions                                 | ✅  | 🔧  |     |
 | [require-hook](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/require-hook.md)                                           | Require setup and teardown code to be within a hook                |     |     |     |
 | [require-soft-assertions](https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/require-soft-assertions.md)                     | Require assertions to use `expect.soft()`                          |     | 🔧  |     |

package/dist/index.cjs

@@ -118,27 +118,55 @@ var Chain = class {
     }
   }
 };
-var resolvePossibleAliasedGlobal = (context, global) => {
+function resolvePossibleAliasedGlobal(context, name) {
   const settings = context.settings;
   const globalAliases = settings?.playwright?.globalAliases ?? {};
-  const alias = Object.entries(globalAliases).find(([, aliases]) => aliases.includes(global));
+  const alias = Object.entries(globalAliases).find(([, aliases]) => aliases.includes(name));
   return alias?.[0] ?? null;
-};
+}
+function resolveImportAlias(context, node) {
+  if (node.type !== "Identifier") {
+    return null;
+  }
+  const scope = context.sourceCode.getScope(node);
+  const ref = scope.references.find((r) => r.identifier === node);
+  for (const def of ref?.resolved?.defs ?? []) {
+    if (def.type === "ImportBinding" && def.node.type === "ImportSpecifier") {
+      const imported = getStringValue(def.node.imported);
+      if (imported !== node.name) {
+        return imported;
+      }
+    }
+  }
+  return null;
+}
 var resolveToPlaywrightFn = (context, accessor) => {
   const ident = getStringValue(accessor);
   const resolved = /(^expect|Expect)$/.test(ident) ? "expect" : ident;
+  if (resolved === "test" || resolved === "expect") {
+    return { original: null, local: resolved };
+  }
   return {
-    // eslint-disable-next-line sort/object-properties
-    original: resolvePossibleAliasedGlobal(context, resolved),
+    original: resolvePossibleAliasedGlobal(context, resolved) ?? resolveImportAlias(context, accessor),
     local: resolved
   };
 };
 function determinePlaywrightFnGroup(name) {
-  if (name === "step") return "step";
-  if (name === "expect") return "expect";
-  if (name === "describe") return "describe";
-  if (name === "test") return "test";
-  if (testHooks.has(name)) return "hook";
+  if (name === "step") {
+    return "step";
+  }
+  if (name === "expect") {
+    return "expect";
+  }
+  if (name === "describe") {
+    return "describe";
+  }
+  if (name === "test") {
+    return "test";
+  }
+  if (testHooks.has(name)) {
+    return "hook";
+  }
   return "unknown";
 }
 var modifiers = /* @__PURE__ */ new Set(["not", "resolves", "rejects"]);
@@ -213,14 +241,43 @@ var findTopMostCallExpression = (node) => {
   }
   return top;
 };
+function isTestExtendCall(context, node) {
+  if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression" || !isPropertyAccessor(node.callee, "extend")) {
+    return false;
+  }
+  const object = node.callee.object;
+  if (object.type === "Identifier") {
+    const resolved = resolveToPlaywrightFn(context, object);
+    if ((resolved?.original ?? resolved?.local) === "test") {
+      return true;
+    }
+    const dereferenced = dereference(context, object);
+    if (dereferenced) {
+      return isTestExtendCall(context, dereferenced);
+    }
+  }
+  return false;
+}
 function parse(context, node) {
   const chain = new Chain(node);
-  if (!chain.nodes?.length) return null;
+  if (!chain.nodes?.length) {
+    return null;
+  }
   const [first, ...rest] = chain.nodes;
-  const resolved = resolveToPlaywrightFn(context, first);
-  if (!resolved) return null;
+  let resolved = resolveToPlaywrightFn(context, first);
+  if (!resolved) {
+    return null;
+  }
   let name = resolved.original ?? resolved.local;
   const links = [name, ...rest.map((link) => getStringValue(link))];
+  if (determinePlaywrightFnGroup(name) === "unknown") {
+    const dereferenced = dereference(context, first);
+    if (dereferenced && isTestExtendCall(context, dereferenced)) {
+      name = "test";
+      links[0] = "test";
+      resolved = { local: resolved.local, original: "test" };
+    }
+  }
   if (name === "test" && links.length > 1) {
     const nextLinkName = links[1];
     const nextLinkGroup = determinePlaywrightFnGroup(nextLinkName);
@@ -246,7 +303,9 @@ function parse(context, node) {
       parsedFnCall.members.shift();
     }
     const result = parseExpectCall(chain, parsedFnCall, stage);
-    if (!result) return null;
+    if (!result) {
+      return null;
+    }
     if (typeof result === "string" && findTopMostCallExpression(node) !== node) {
       return null;
     }
@@ -294,7 +353,9 @@ var isTypeOfFnCall = (context, node, types) => {
 
 // src/utils/ast.ts
 function getStringValue(node) {
-  if (!node) return "";
+  if (!node) {
+    return "";
+  }
   return node.type === "Identifier" ? node.name : node.type === "TemplateLiteral" ? node.quasis[0].value.raw : node.type === "Literal" && typeof node.value === "string" ? node.value : "";
 }
 function getRawValue(node) {
@@ -323,7 +384,9 @@ function isPropertyAccessor(node, name) {
 }
 function findParent(node, type) {
   const parent = node.parent;
-  if (!parent) return;
+  if (!parent) {
+    return;
+  }
   return parent.type === type ? parent : findParent(parent, type);
 }
 function dig(node, identifier) {
@@ -394,6 +457,9 @@ var getPaddingLineSequences = (prevNode, nextNode, sourceCode) => {
   return pairs;
 };
 var areTokensOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
+var isPromiseAccessor = (node) => {
+  return node.type === "MemberExpression" && isIdentifier(node.property, /^(then|catch|finally)$/);
+};
 
 // src/utils/createRule.ts
 function interpolate(str, data) {
@@ -683,7 +749,7 @@ var max_expects_default = createRule({
       "ArrowFunctionExpression:exit": maybeResetCount,
       "CallExpression"(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect" || call.head.node.parent?.type === "MemberExpression") {
+        if (call?.type !== "expect") {
           return;
         }
         count += 1;
@@ -872,29 +938,65 @@ var missing_playwright_await_default = createRule({
       // Add any custom matchers to the set
       ...options.customMatchers || []
     ]);
+    function isVariableConsumed(declarator, checkValidity2, validTypes2, visited) {
+      const variables = context.sourceCode.getDeclaredVariables(declarator);
+      for (const variable of variables) {
+        for (const ref of variable.references) {
+          if (!ref.isRead()) {
+            continue;
+          }
+          const refParent = ref.identifier.parent;
+          if (visited.has(refParent)) {
+            continue;
+          }
+          if (validTypes2.has(refParent.type)) {
+            return true;
+          }
+          if (refParent.type === "VariableDeclarator") {
+            if (checkValidity2(ref.identifier, visited)) {
+              return true;
+            }
+            continue;
+          }
+          if (checkValidity2(refParent, visited)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
     function checkValidity(node, visited) {
       const parent = node.parent;
-      if (!parent) return false;
-      if (visited.has(parent)) return false;
+      if (!parent) {
+        return false;
+      }
+      if (visited.has(parent)) {
+        return false;
+      }
       visited.add(parent);
-      if (validTypes.has(parent.type)) return true;
-      if (parent.type === "MemberExpression" && isIdentifier(parent.property, /^(then|catch|finally)$/) && parent.parent?.type === "CallExpression") {
+      if (validTypes.has(parent.type)) {
+        return true;
+      }
+      if (isPromiseAccessor(parent) && parent.parent?.type === "CallExpression") {
         return checkValidity(parent.parent, visited);
       }
+      if (parent.type === "CallExpression" && parent.callee === node && isPromiseAccessor(node)) {
+        return checkValidity(parent, visited);
+      }
       if (parent.type === "ArrayExpression") {
         return checkValidity(parent, visited);
       }
+      if (parent.type === "ConditionalExpression") {
+        return checkValidity(parent, visited);
+      }
+      if (parent.type === "SpreadElement") {
+        return checkValidity(parent, visited);
+      }
       if (parent.type === "CallExpression" && parent.callee.type === "MemberExpression" && isIdentifier(parent.callee.object, "Promise") && isIdentifier(parent.callee.property, "all")) {
         return true;
       }
       if (parent.type === "VariableDeclarator") {
-        const scope = context.sourceCode.getScope(parent.parent);
-        for (const ref of scope.references) {
-          const refParent = ref.identifier.parent;
-          if (visited.has(refParent)) continue;
-          if (validTypes.has(refParent.type)) return true;
-          if (checkValidity(refParent, visited)) return true;
-        }
+        return isVariableConsumed(parent, checkValidity, validTypes, visited);
       }
       return false;
     }
@@ -912,7 +1014,9 @@ var missing_playwright_await_default = createRule({
           return;
         }
         const call = parseFnCall(context, node);
-        if (call?.type !== "step" && call?.type !== "expect") return;
+        if (call?.type !== "step" && call?.type !== "expect") {
+          return;
+        }
         const result = getCallType(call, awaitableMatchers);
         const isValid = result ? checkValidity(node, /* @__PURE__ */ new Set()) : false;
         if (result && !isValid) {
@@ -970,7 +1074,9 @@ function hasTests(context, node) {
 var no_commented_out_tests_default = createRule({
   create(context) {
     function checkNode(node) {
-      if (!hasTests(context, node)) return;
+      if (!hasTests(context, node)) {
+        return;
+      }
       context.report({
         messageId: "commentedTests",
         node
@@ -997,18 +1103,6 @@ var no_commented_out_tests_default = createRule({
 
 // src/rules/no-conditional-expect.ts
 var isCatchCall = (node) => node.callee.type === "MemberExpression" && isPropertyAccessor(node.callee, "catch");
-var getTestCallExpressionsFromDeclaredVariables = (context, declaredVariables) => {
-  return declaredVariables.reduce(
-    (acc, { references }) => [
-      ...acc,
-      ...references.map(({ identifier }) => identifier.parent).filter(
-        // ESLint types are infurating
-        (node) => node?.type === "CallExpression" && isTypeOfFnCall(context, node, ["test"])
-      )
-    ],
-    []
-  );
-};
 var no_conditional_expect_default = createRule({
   create(context) {
     let conditionalDepth = 0;
@@ -1050,16 +1144,6 @@ var no_conditional_expect_default = createRule({
       "CatchClause:exit": decreaseConditionalDepth,
       "ConditionalExpression": increaseConditionalDepth,
       "ConditionalExpression:exit": decreaseConditionalDepth,
-      "FunctionDeclaration"(node) {
-        const declaredVariables = context.sourceCode.getDeclaredVariables(node);
-        const testCallExpressions = getTestCallExpressionsFromDeclaredVariables(
-          context,
-          declaredVariables
-        );
-        if (testCallExpressions.length > 0) {
-          inTestCase = true;
-        }
-      },
       "IfStatement": increaseConditionalDepth,
       "IfStatement:exit": decreaseConditionalDepth,
       "LogicalExpression": increaseConditionalDepth,
@@ -1089,11 +1173,15 @@ var no_conditional_in_test_default = createRule({
         return;
       }
       const call = findParent(node, "CallExpression");
-      if (!call) return;
+      if (!call) {
+        return;
+      }
       if (isTypeOfFnCall(context, call, ["test", "step"])) {
         const testFunction = call.arguments[call.arguments.length - 1];
         const functionBody = findParent(node, "BlockStatement");
-        if (!functionBody) return;
+        if (!functionBody) {
+          return;
+        }
         let currentParent = functionBody.parent;
         while (currentParent && currentParent !== testFunction) {
           currentParent = currentParent.parent;
@@ -1131,7 +1219,9 @@ var no_duplicate_hooks_default = createRule({
     return {
       "CallExpression"(node) {
         const call = parseFnCall(context, node);
-        if (!call) return;
+        if (!call) {
+          return;
+        }
         if (call.type === "describe") {
           hookContexts.push({});
         }
@@ -1177,7 +1267,9 @@ var no_duplicate_slow_default = createRule({
     return {
       "CallExpression"(node) {
         const call = parseFnCall(context, node);
-        if (!call) return;
+        if (!call) {
+          return;
+        }
         if (call.type === "test" || call.type === "describe") {
           scopes.push(scopes[scopes.length - 1]);
         }
@@ -1298,7 +1390,9 @@ var no_focused_test_default = createRule({
           return;
         }
         const onlyNode = call.members.find((s) => getStringValue(s) === "only");
-        if (!onlyNode) return;
+        if (!onlyNode) {
+          return;
+        }
         context.report({
           messageId: "noFocusedTest",
           node: onlyNode,
@@ -1383,7 +1477,7 @@ var no_get_by_title_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (isPageMethod(node, "getByTitle")) {
+        if (node.callee.type === "MemberExpression" && getStringValue(node.callee.property) === "getByTitle") {
           context.report({ messageId: "noGetByTitle", node });
         }
       }
@@ -1412,7 +1506,9 @@ var no_hooks_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (!call) return;
+        if (!call) {
+          return;
+        }
         if (call.type === "hook" && !options.allow.includes(call.name)) {
           context.report({
             data: { hookName: call.name },
@@ -1507,20 +1603,26 @@ var no_networkidle_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type !== "MemberExpression") return;
+        if (node.callee.type !== "MemberExpression") {
+          return;
+        }
         const methodName = getStringValue(node.callee.property);
-        if (!methods.has(methodName)) return;
+        if (!methods.has(methodName)) {
+          return;
+        }
         if (methodName === "waitForLoadState") {
           const arg = node.arguments[0];
-          if (arg && isStringLiteral(arg, "networkidle")) {
+          if (arg && isStringNode(arg, "networkidle")) {
             context.report({ messageId, node: arg });
           }
           return;
         }
         if (node.arguments.length >= 2) {
           const [_, arg] = node.arguments;
-          if (arg.type !== "ObjectExpression") return;
-          const property = arg.properties.filter((p) => p.type === "Property").find((p) => isStringLiteral(p.value, "networkidle"));
+          if (arg.type !== "ObjectExpression") {
+            return;
+          }
+          const property = arg.properties.filter((p) => p.type === "Property").find((p) => isStringNode(p.value, "networkidle"));
           if (property) {
             context.report({ messageId, node: property.value });
           }
@@ -1547,9 +1649,13 @@ var no_nth_methods_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type !== "MemberExpression") return;
+        if (node.callee.type !== "MemberExpression") {
+          return;
+        }
         const method = getStringValue(node.callee.property);
-        if (!methods2.has(method)) return;
+        if (!methods2.has(method)) {
+          return;
+        }
         context.report({
           data: { method },
           loc: {
@@ -1614,13 +1720,12 @@ var no_raw_locators_default = createRule({
     }
     return {
       CallExpression(node) {
-        if (node.callee.type !== "MemberExpression" || node.arguments[0]?.type === "Identifier")
+        if (node.callee.type !== "MemberExpression" || !isPropertyAccessor(node.callee, "locator")) {
           return;
-        const method = getStringValue(node.callee.property);
-        const arg = getStringValue(node.arguments[0]);
-        const isLocator = isPageMethod(node, "locator") || method === "locator";
-        if (isLocator && !isAllowed(arg)) {
+        }
+        if ((node.arguments.length === 0 || isStringNode(node.arguments[0])) && !isAllowed(getStringValue(node.arguments[0]))) {
           context.report({ messageId: "noRawLocator", node });
+          return;
         }
       }
     };
@@ -1673,7 +1778,7 @@ var no_restricted_locators_default = createRule({
           return;
         }
         for (const [restrictedType, message] of restrictionMap.entries()) {
-          if (isPageMethod(node, restrictedType)) {
+          if (getStringValue(node.callee.property) === restrictedType) {
             context.report({
               data: {
                 message: message ?? "",
@@ -1728,7 +1833,9 @@ var no_restricted_matchers_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect") return;
+        if (call?.type !== "expect") {
+          return;
+        }
         Object.entries(restrictedChains).map(([restriction, message]) => {
           const chain = call.members;
           const restrictionLinks = restriction.split(".").length;
@@ -1797,7 +1904,7 @@ var no_restricted_roles_default = createRule({
     }
     return {
       CallExpression(node) {
-        if (!isPageMethod(node, "getByRole")) {
+        if (node.callee.type !== "MemberExpression" || !isPropertyAccessor(node.callee, "getByRole")) {
           return;
         }
         const role = getStringValue(node.arguments[0]);
@@ -1860,9 +1967,11 @@ var no_skipped_test_default = createRule({
           return;
         }
         const skipNode = call.members.find((s) => getStringValue(s) === "skip");
-        if (!skipNode) return;
+        if (!skipNode) {
+          return;
+        }
         const isStandalone = call.type === "config";
-        if (isStandalone && allowConditional && (node.arguments.length !== 0 || findParent(node, "BlockStatement")?.parent?.type === "IfStatement")) {
+        if (isStandalone && allowConditional && (node.arguments.length !== 0 || findParent(node, "BlockStatement")?.parent?.type === "IfStatement" || findParent(node, "SwitchCase") !== void 0)) {
           return;
         }
         context.report({
@@ -1922,7 +2031,9 @@ var no_slowed_test_default = createRule({
           return;
         }
         const slowNode = call.members.find((s) => getStringValue(s) === "slow");
-        if (!slowNode) return;
+        if (!slowNode) {
+          return;
+        }
         const isStandalone = call.type === "config";
         if (isStandalone && allowConditional && (node.arguments.length !== 0 || findParent(node, "BlockStatement")?.parent?.type === "IfStatement")) {
           return;
@@ -2046,7 +2157,7 @@ var no_standalone_expect_default = createRule({
       },
       "CallExpression:exit"(node) {
         const top = callStack.at(-1);
-        if (top === "test" && isTypeOfFnCall(context, node, ["test"]) && node.callee.type !== "MemberExpression" || top === "template" && node.callee.type === "TaggedTemplateExpression" || top === "fixture" && node.callee.type === "MemberExpression" && isPropertyAccessor(node.callee, "extend")) {
+        if (top === "test" && isTypeOfFnCall(context, node, ["test"]) || top === "hook" && isTypeOfFnCall(context, node, ["hook"]) || top === "template" && node.callee.type === "TaggedTemplateExpression" || top === "fixture" && node.callee.type === "MemberExpression" && isPropertyAccessor(node.callee, "extend")) {
           callStack.pop();
         }
       }
@@ -2075,16 +2186,22 @@ var truthy = Boolean;
 
 // src/rules/no-unsafe-references.ts
 function collectVariables(scope) {
-  if (!scope || scope.type === "global") return [];
+  if (!scope || scope.type === "global") {
+    return [];
+  }
   return [...collectVariables(scope.upper), ...scope.variables.map((ref) => ref.name)];
 }
 function addArgument(fixer, node, refs) {
-  if (!node.arguments.length) return;
+  if (!node.arguments.length) {
+    return;
+  }
   if (node.arguments.length === 1) {
     return fixer.insertTextAfter(node.arguments[0], `, [${refs}]`);
   }
   const arg = node.arguments.at(-1);
-  if (!arg) return;
+  if (!arg) {
+    return;
+  }
   if (arg.type !== "ArrayExpression") {
     return fixer.replaceText(arg, `[${getStringValue(arg)}, ${refs}]`);
   }
@@ -2110,9 +2227,13 @@ var no_unsafe_references_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (!isPageMethod(node, "evaluate") && !isPageMethod(node, "addInitScript")) return;
+        if (!isPageMethod(node, "evaluate") && !isPageMethod(node, "addInitScript")) {
+          return;
+        }
         const [fn] = node.arguments;
-        if (!fn || !isFunction(fn)) return;
+        if (!fn || !isFunction(fn)) {
+          return;
+        }
         const { through, upper } = context.sourceCode.getScope(fn.body);
         const allRefs = new Set(collectVariables(upper));
         through.filter((ref) => {
@@ -2162,7 +2283,7 @@ var no_unused_locators_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (!isPageMethod(node, LOCATOR_REGEX)) {
+        if (node.callee.type !== "MemberExpression" || !isPropertyAccessor(node.callee, LOCATOR_REGEX)) {
           return;
         }
         if (node.parent.type === "ExpressionStatement" || node.parent.type === "AwaitExpression") {
@@ -2245,7 +2366,9 @@ var expectMatchers = /* @__PURE__ */ new Set([
   "toThrowError"
 ]);
 function isSupportedMethod(node) {
-  if (node.callee.type !== "MemberExpression") return false;
+  if (node.callee.type !== "MemberExpression") {
+    return false;
+  }
   const name = getStringValue(node.callee.property);
   return locatorMethods.has(name) || pageMethods.has(name) && isPageMethod(node, name);
 }
@@ -2300,7 +2423,9 @@ function replaceAccessorFixer(fixer, node, text) {
 }
 function removePropertyFixer(fixer, property) {
   const parent = property.parent;
-  if (parent?.type !== "ObjectExpression") return;
+  if (parent?.type !== "ObjectExpression") {
+    return;
+  }
   if (parent.properties.length === 1) {
     return fixer.remove(parent);
   }
@@ -2324,7 +2449,9 @@ var matcherConfig = {
 };
 function getOptions(call, name) {
   const [arg] = call.matcherArgs;
-  if (arg?.type !== "ObjectExpression") return;
+  if (arg?.type !== "ObjectExpression") {
+    return;
+  }
   const property = arg.properties.find(
     (p) => p.type === "Property" && getStringValue(p.key) === name && isBooleanLiteral(p.value)
   );
@@ -2339,13 +2466,21 @@ var no_useless_not_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect") return;
+        if (call?.type !== "expect") {
+          return;
+        }
         const config = matcherConfig[call.matcherName];
-        if (!config) return;
+        if (!config) {
+          return;
+        }
         const options = config.argName ? getOptions(call, config.argName) : void 0;
-        if (options?.arg && options.value === void 0) return;
+        if (options?.arg && options.value === void 0) {
+          return;
+        }
         const notModifier = call.modifiers.find((mod) => getStringValue(mod) === "not");
-        if (!notModifier && !options?.property) return;
+        if (!notModifier && !options?.property) {
+          return;
+        }
         const isInverted = !!notModifier !== (options?.value === false);
         const newMatcherName = isInverted ? config.inverse : call.matcherName;
         context.report({
@@ -2438,7 +2573,7 @@ var no_wait_for_selector_default = createRule({
             suggest: [
               {
                 fix: (fixer) => fixer.remove(
-                  node.parent && node.parent.type !== "AwaitExpression" ? node.parent : node.parent.parent
+                  node.parent && node.parent.type !== "AwaitExpression" && node.parent.type !== "VariableDeclarator" ? node.parent : node.parent.parent
                 ),
                 messageId: "removeWaitForSelector"
               }
@@ -2475,7 +2610,7 @@ var no_wait_for_timeout_default = createRule({
             suggest: [
               {
                 fix: (fixer) => fixer.remove(
-                  node.parent && node.parent.type !== "AwaitExpression" ? node.parent : node.parent.parent
+                  node.parent && node.parent.type !== "AwaitExpression" && node.parent.type !== "VariableDeclarator" ? node.parent : node.parent.parent
                 ),
                 messageId: "removeWaitForTimeout"
               }
@@ -2507,6 +2642,7 @@ var isString = (node) => {
 var isComparingToString = (expression) => {
   return isString(expression.left) || isString(expression.right);
 };
+var skipModifiers = /* @__PURE__ */ new Set(["not", "soft", "poll"]);
 var invertedOperators = {
   "<": ">=",
   "<=": ">",
@@ -2528,9 +2664,16 @@ var prefer_comparison_matcher_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect" || call.matcherArgs.length === 0) return;
-        const expect = call.head.node.parent;
-        if (expect?.type !== "CallExpression") return;
+        if (call?.type !== "expect" || call.matcherArgs.length === 0) {
+          return;
+        }
+        let expect = call.head.node.parent;
+        while (expect?.type === "MemberExpression") {
+          expect = expect.parent;
+        }
+        if (expect?.type !== "CallExpression") {
+          return;
+        }
         const [comparison] = expect.arguments;
         const expectCallEnd = expect.range[1];
         const [matcherArg] = call.matcherArgs;
@@ -2549,7 +2692,7 @@ var prefer_comparison_matcher_default = createRule({
           data: { preferredMatcher },
           fix(fixer) {
             const [modifier] = call.modifiers;
-            const modifierText = modifier && getStringValue(modifier) !== "not" ? `.${getStringValue(modifier)}` : "";
+            const modifierText = modifier && !skipModifiers.has(getStringValue(modifier)) ? `.${getStringValue(modifier)}` : "";
             return [
               // Replace the comparison argument with the left-hand side of the comparison
               fixer.replaceText(comparison, context.sourceCode.getText(comparison.left)),
@@ -2588,9 +2731,13 @@ var prefer_equality_matcher_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect" || call.matcherArgs.length === 0) return;
+        if (call?.type !== "expect" || call.matcherArgs.length === 0) {
+          return;
+        }
         const expect = call.head.node.parent;
-        if (expect?.type !== "CallExpression") return;
+        if (expect?.type !== "CallExpression") {
+          return;
+        }
         const [comparison] = expect.arguments;
         const expectCallEnd = expect.range[1];
         const [matcherArg] = call.matcherArgs;
@@ -2652,7 +2799,9 @@ var prefer_hooks_in_order_default = createRule({
     let inHook = false;
     return {
       "CallExpression"(node) {
-        if (inHook) return;
+        if (inHook) {
+          return;
+        }
         const call = parseFnCall(context, node);
         if (call?.type !== "hook") {
           previousHookIndex = -1;
@@ -2679,7 +2828,9 @@ var prefer_hooks_in_order_default = createRule({
           inHook = false;
           return;
         }
-        if (inHook) return;
+        if (inHook) {
+          return;
+        }
         previousHookIndex = -1;
       }
     };
@@ -2756,7 +2907,9 @@ var pageMethods2 = /* @__PURE__ */ new Set([
   "uncheck"
 ]);
 function isSupportedMethod2(node) {
-  if (node.callee.type !== "MemberExpression") return false;
+  if (node.callee.type !== "MemberExpression") {
+    return false;
+  }
   const name = getStringValue(node.callee.property);
   return pageMethods2.has(name) && isPageMethod(node, name);
 }
@@ -2764,7 +2917,9 @@ var prefer_locator_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (!isSupportedMethod2(node)) return;
+        if (!isSupportedMethod2(node)) {
+          return;
+        }
         context.report({
           messageId: "preferLocator",
           node
@@ -2925,9 +3080,13 @@ var prefer_native_locators_default = createRule({
     const patterns = compilePatterns({ testIdAttribute });
     return {
       CallExpression(node) {
-        if (node.callee.type !== "MemberExpression") return;
+        if (node.callee.type !== "MemberExpression") {
+          return;
+        }
         const query = getStringValue(node.arguments[0]);
-        if (!isPageMethod(node, "locator")) return;
+        if (!isPropertyAccessor(node.callee, "locator")) {
+          return;
+        }
         for (const pattern of patterns) {
           const match = query.match(pattern.pattern);
           if (match) {
@@ -2985,7 +3144,9 @@ var prefer_strict_equal_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect") return;
+        if (call?.type !== "expect") {
+          return;
+        }
         if (call.matcherName === "toEqual") {
           context.report({
             messageId: "useToStrictEqual",
@@ -3053,7 +3214,9 @@ var prefer_to_be_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect") return;
+        if (call?.type !== "expect") {
+          return;
+        }
         const notMatchers = ["toBeUndefined", "toBeDefined"];
         const notModifier = call.modifiers.find((node2) => getStringValue(node2) === "not");
         if (notModifier && notMatchers.includes(call.matcherName)) {
@@ -3110,9 +3273,13 @@ var prefer_to_contain_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect" || call.matcherArgs.length === 0) return;
+        if (call?.type !== "expect" || call.matcherArgs.length === 0) {
+          return;
+        }
         const expect = call.head.node.parent;
-        if (expect?.type !== "CallExpression") return;
+        if (expect?.type !== "CallExpression") {
+          return;
+        }
         const [includesCall] = expect.arguments;
         const { matcher } = call;
         const [matcherArg] = call.matcherArgs;
@@ -3307,19 +3474,29 @@ var prefer_web_first_assertions_default = createRule({
     return {
       CallExpression(node) {
         const fnCall = parseFnCall(context, node);
-        if (fnCall?.type !== "expect") return;
+        if (fnCall?.type !== "expect") {
+          return;
+        }
         const expect = findParent(fnCall.head.node, "CallExpression");
-        if (!expect) return;
+        if (!expect) {
+          return;
+        }
         const arg = dereference(context, fnCall.args[0]);
-        if (!arg) return;
+        if (!arg) {
+          return;
+        }
         const call = arg.type === "AwaitExpression" ? arg.argument : arg;
         if (call.type !== "CallExpression" || call.callee.type !== "MemberExpression") {
           return;
         }
-        if (!supportedMatchers.has(fnCall.matcherName)) return;
+        if (!supportedMatchers.has(fnCall.matcherName)) {
+          return;
+        }
         const method = getStringValue(call.callee.property);
         const methodConfig = methods3[method];
-        if (!Object.hasOwn(methods3, method)) return;
+        if (!Object.hasOwn(methods3, method)) {
+          return;
+        }
         const notModifier = fnCall.modifiers.find((mod) => getStringValue(mod) === "not");
         const isFalsy = methodConfig.type === "boolean" && (!!fnCall.matcherArgs.length && isBooleanLiteral(fnCall.matcherArgs[0], false) || fnCall.matcherName === "toBeFalsy");
         const isInverse = methodConfig.inverse ? notModifier || isFalsy : notModifier && isFalsy;
@@ -3519,10 +3696,11 @@ function hasTagInOptions(node) {
 }
 function hasTagInTitle(node) {
   const title = node.arguments[0];
-  if (!title || title.type !== "Literal" || typeof title.value !== "string") {
+  if (!title) {
     return false;
   }
-  return tagRegex.test(title.value);
+  const value = getStringValue(title);
+  return !!value && tagRegex.test(value);
 }
 function hasTags(node) {
   return hasTagInTitle(node) || hasTagInOptions(node);
@@ -3617,7 +3795,9 @@ var require_to_throw_message_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect") return;
+        if (call?.type !== "expect") {
+          return;
+        }
         if (call.matcherArgs.length === 0 && ["toThrow", "toThrowError"].includes(call.matcherName) && !call.modifiers.some((nod) => getStringValue(nod) === "not")) {
           context.report({
             data: { matcherName: call.matcherName },
@@ -3654,7 +3834,9 @@ var require_top_level_describe_default = createRule({
     return {
       "CallExpression"(node) {
         const call = parseFnCall(context, node);
-        if (!call) return;
+        if (!call) {
+          return;
+        }
         if (call.type === "describe") {
           describeCount++;
           if (describeCount === 1) {
@@ -3723,7 +3905,9 @@ var valid_describe_callback_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.group !== "describe") return;
+        if (call?.group !== "describe") {
+          return;
+        }
         if (call.members.some((s) => getStringValue(s) === "configure")) {
           return;
         }
@@ -3826,7 +4010,9 @@ var isTestCaseCallWithCallbackArg = (context, node) => {
 };
 var isPromiseMethodThatUsesValue = (node, identifier) => {
   const name = getStringValue(identifier);
-  if (node.argument == null) return false;
+  if (node.argument == null) {
+    return false;
+  }
   if (node.argument.type === "CallExpression" && node.argument.arguments.length > 0) {
     const nodeName = getNodeName(node.argument);
     if (["Promise.all", "Promise.allSettled"].includes(nodeName)) {
@@ -4083,7 +4269,9 @@ var valid_expect_default = createRule({
           return;
         }
         const { parent: expect } = call.head.node;
-        if (expect?.type !== "CallExpression") return;
+        if (expect?.type !== "CallExpression") {
+          return;
+        }
         if (expect.arguments.length < minArgs) {
           const expectLength = getStringValue(call.head.node).length;
           const loc = {
@@ -4132,6 +4320,7 @@ var valid_expect_default = createRule({
     messages: {
       matcherNotCalled: "Matchers must be called to assert.",
       matcherNotFound: "Expect must have a corresponding matcher call.",
+      modifierUnknown: "Expect has an unknown modifier.",
       notEnoughArgs: "Expect requires at least {{amount}} argument{{s}}.",
       tooManyArgs: "Expect takes at most {{amount}} argument{{s}}."
     },
@@ -4209,9 +4398,13 @@ var valid_test_tags_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (!call) return;
+        if (!call) {
+          return;
+        }
         const { type } = call;
-        if (type !== "test" && type !== "describe" && type !== "step") return;
+        if (type !== "test" && type !== "describe" && type !== "step") {
+          return;
+        }
         if (node.arguments.length > 0) {
           const titleArg = node.arguments[0];
           if (titleArg && titleArg.type === "Literal" && typeof titleArg.value === "string") {
@@ -4221,14 +4414,20 @@ var valid_test_tags_default = createRule({
             }
           }
         }
-        if (node.arguments.length < 2) return;
+        if (node.arguments.length < 2) {
+          return;
+        }
         const optionsArg = node.arguments[1];
-        if (!optionsArg || optionsArg.type !== "ObjectExpression") return;
+        if (!optionsArg || optionsArg.type !== "ObjectExpression") {
+          return;
+        }
         const tagProperty = optionsArg.properties.find(
           (prop) => prop.type === "Property" && !("argument" in prop) && // Ensure it's not a spread element
           prop.key.type === "Identifier" && prop.key.name === "tag"
         );
-        if (!tagProperty) return;
+        if (!tagProperty) {
+          return;
+        }
         const tagValue = tagProperty.value;
         if (tagValue.type === "Literal") {
           if (typeof tagValue.value !== "string") {
@@ -4365,7 +4564,9 @@ var valid_title_default = createRule({
         }
         const [argument] = node.arguments;
         const title = dereference(context, argument) ?? argument;
-        if (!title) return;
+        if (!title) {
+          return;
+        }
         if (!isStringNode(title)) {
           if (title.type === "BinaryExpression" && doesBinaryExpressionContainStringNode(title)) {
             return;
@@ -4414,15 +4615,15 @@ var valid_title_default = createRule({
             node: title
           });
         }
-        const [firstWord] = titleString.split(" ");
+        const [firstWord, ...rest] = titleString.split(" ");
         if (firstWord.toLowerCase() === functionName) {
           context.report({
-            fix: (fixer) => [
+            fix: rest.length > 0 ? (fixer) => [
               fixer.replaceTextRange(
                 title.range,
                 quoteStringValue(title).replace(/^([`'"]).+? /u, "$1")
               )
-            ],
+            ] : void 0,
             messageId: "duplicatePrefix",
             node: title
           });
@@ -4594,6 +4795,8 @@ var sharedConfig = {
     "playwright/missing-playwright-await": "error",
     "playwright/no-conditional-expect": "warn",
     "playwright/no-conditional-in-test": "warn",
+    "playwright/no-duplicate-hooks": "warn",
+    "playwright/no-duplicate-slow": "warn",
     "playwright/no-element-handle": "warn",
     "playwright/no-eval": "warn",
     "playwright/no-focused-test": "error",
@@ -4610,6 +4813,11 @@ var sharedConfig = {
     "playwright/no-wait-for-navigation": "error",
     "playwright/no-wait-for-selector": "warn",
     "playwright/no-wait-for-timeout": "warn",
+    "playwright/prefer-hooks-in-order": "warn",
+    "playwright/prefer-hooks-on-top": "warn",
+    "playwright/prefer-locator": "warn",
+    "playwright/prefer-to-have-count": "warn",
+    "playwright/prefer-to-have-length": "warn",
     "playwright/prefer-web-first-assertions": "error",
     "playwright/valid-describe-callback": "error",
     "playwright/valid-expect": "error",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-playwright",
-  "version": "2.7.1",
+  "version": "2.9.0",
   "description": "ESLint plugin for Playwright testing.",
   "license": "MIT",
   "author": "Mark Skelton <mark@mskelton.dev>",
@@ -31,7 +31,7 @@
     "lint": "eslint .",
     "format": "oxfmt .",
     "format:check": "oxfmt --check .",
-    "test": "vitest --reporter dot --hideSkippedTests",
+    "test": "vitest --hideSkippedTests",
     "typecheck": "tsc --noEmit",
     "ci": "yarn format:check && yarn lint && yarn typecheck"
   },