eslint-plugin-playwright 2.7.0 → 2.8.0

package/README.md

@@ -1,6 +1,6 @@
 # ESLint Plugin Playwright
 
-[![Test](https://github.com/mskelton/eslint-plugin-playwright/actions/workflows/test.yml/badge.svg)](https://github.com/mskelton/eslint-plugin-playwright/actions/workflows/test.yml)
+[![CI](https://github.com/mskelton/eslint-plugin-playwright/actions/workflows/ci.yml/badge.svg)](https://github.com/mskelton/eslint-plugin-playwright/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/eslint-plugin-playwright)](https://www.npmjs.com/package/eslint-plugin-playwright)
 [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 
@@ -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"]
       }
     }
   }

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,26 +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 (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;
     }
@@ -909,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) {
@@ -967,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
@@ -994,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;
@@ -1047,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,
@@ -1086,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;
@@ -1128,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({});
         }
@@ -1174,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]);
         }
@@ -1295,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,
@@ -1380,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 });
         }
       }
@@ -1409,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 },
@@ -1504,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 });
           }
@@ -1544,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: {
@@ -1611,8 +1720,9 @@ var no_raw_locators_default = createRule({
     }
     return {
       CallExpression(node) {
-        if (node.callee.type !== "MemberExpression" || node.arguments[0]?.type === "Identifier")
+        if (node.callee.type !== "MemberExpression" || node.arguments[0]?.type === "Identifier") {
           return;
+        }
         const method = getStringValue(node.callee.property);
         const arg = getStringValue(node.arguments[0]);
         const isLocator = isPageMethod(node, "locator") || method === "locator";
@@ -1670,7 +1780,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 ?? "",
@@ -1725,7 +1835,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;
@@ -1857,9 +1969,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({
@@ -1919,7 +2033,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;
@@ -2043,7 +2159,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();
         }
       }
@@ -2072,16 +2188,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}]`);
   }
@@ -2107,9 +2229,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) => {
@@ -2242,7 +2368,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);
 }
@@ -2297,7 +2425,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);
   }
@@ -2321,7 +2451,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)
   );
@@ -2336,13 +2468,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({
@@ -2435,7 +2575,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"
               }
@@ -2472,7 +2612,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"
               }
@@ -2504,6 +2644,7 @@ var isString = (node) => {
 var isComparingToString = (expression) => {
   return isString(expression.left) || isString(expression.right);
 };
+var skipModifiers = /* @__PURE__ */ new Set(["not", "soft", "poll"]);
 var invertedOperators = {
   "<": ">=",
   "<=": ">",
@@ -2525,9 +2666,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;
@@ -2546,7 +2694,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)),
@@ -2585,9 +2733,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;
@@ -2649,7 +2801,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;
@@ -2676,7 +2830,9 @@ var prefer_hooks_in_order_default = createRule({
           inHook = false;
           return;
         }
-        if (inHook) return;
+        if (inHook) {
+          return;
+        }
         previousHookIndex = -1;
       }
     };
@@ -2753,7 +2909,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);
 }
@@ -2761,7 +2919,9 @@ var prefer_locator_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (!isSupportedMethod2(node)) return;
+        if (!isSupportedMethod2(node)) {
+          return;
+        }
         context.report({
           messageId: "preferLocator",
           node
@@ -2922,9 +3082,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 (!isPageMethod(node, "locator")) {
+          return;
+        }
         for (const pattern of patterns) {
           const match = query.match(pattern.pattern);
           if (match) {
@@ -2982,7 +3146,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",
@@ -3050,7 +3216,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)) {
@@ -3107,9 +3275,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;
@@ -3304,19 +3476,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;
@@ -3516,10 +3698,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);
@@ -3614,7 +3797,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 },
@@ -3651,7 +3836,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) {
@@ -3720,7 +3907,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;
         }
@@ -3823,7 +4012,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)) {
@@ -4080,7 +4271,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 = {
@@ -4129,6 +4322,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}}."
     },
@@ -4206,9 +4400,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") {
@@ -4218,14 +4416,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") {
@@ -4362,7 +4566,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;
@@ -4411,15 +4617,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
           });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-playwright",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "ESLint plugin for Playwright testing.",
   "license": "MIT",
   "author": "Mark Skelton <mark@mskelton.dev>",