eslint-plugin-playwright 1.3.0 → 1.4.0

package/dist/index.mjs

@@ -6,6 +6,244 @@ var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 
+// src/utils/parseFnCall.ts
+function getNodeChain(node) {
+  if (isSupportedAccessor(node)) {
+    return [node];
+  }
+  switch (node.type) {
+    case "TaggedTemplateExpression":
+      return getNodeChain(node.tag);
+    case "MemberExpression":
+      return joinChains(getNodeChain(node.object), getNodeChain(node.property));
+    case "CallExpression":
+      return getNodeChain(node.callee);
+  }
+  return null;
+}
+function determinePlaywrightFnType(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";
+  return "unknown";
+}
+function getExpectArguments(call) {
+  return findParent(call.head.node, "CallExpression")?.arguments ?? [];
+}
+function parse(context, node) {
+  const chain = getNodeChain(node);
+  if (!chain?.length) {
+    return null;
+  }
+  const [first, ...rest] = chain;
+  const resolved = resolveToPlaywrightFn(context, first);
+  if (!resolved)
+    return null;
+  let name = resolved.original ?? resolved.local;
+  const links = [name, ...rest.map((link) => getStringValue(link))];
+  if (name !== "expect" && !VALID_CHAINS.has(links.join("."))) {
+    return null;
+  }
+  if (name === "test" && links.length > 1) {
+    const nextLinkName = links[1];
+    const nextLinkType = determinePlaywrightFnType(nextLinkName);
+    if (nextLinkType !== "unknown") {
+      name = nextLinkName;
+    }
+  }
+  const parsedFnCall = {
+    head: { ...resolved, node: first },
+    // every member node must have a member expression as their parent
+    // in order to be part of the call chain we're parsing
+    members: rest,
+    name
+  };
+  const type = determinePlaywrightFnType(name);
+  if (type === "expect") {
+    const result = parseExpectCall(parsedFnCall);
+    if (typeof result === "string" && findTopMostCallExpression(node) !== node) {
+      return null;
+    }
+    if (result === "matcher-not-found") {
+      if (getParent(node)?.type === "MemberExpression") {
+        return "matcher-not-called";
+      }
+    }
+    return result;
+  }
+  if (chain.slice(0, chain.length - 1).some((n) => getParent(n)?.type !== "MemberExpression")) {
+    return null;
+  }
+  const parent = getParent(node);
+  if (parent?.type === "CallExpression" || parent?.type === "MemberExpression") {
+    return null;
+  }
+  return { ...parsedFnCall, type };
+}
+function parseFnCallWithReason(context, node) {
+  if (cache.has(node)) {
+    return cache.get(node);
+  }
+  const call = parse(context, node);
+  cache.set(node, call);
+  return call;
+}
+function parseFnCall(context, node) {
+  const call = parseFnCallWithReason(context, node);
+  return typeof call === "string" ? null : call;
+}
+var testHooks, VALID_CHAINS, joinChains, isSupportedAccessor, resolvePossibleAliasedGlobal, resolveToPlaywrightFn, modifiers, findModifiersAndMatcher, parseExpectCall, findTopMostCallExpression, cache, isTypeOfFnCall;
+var init_parseFnCall = __esm({
+  "src/utils/parseFnCall.ts"() {
+    "use strict";
+    init_ast();
+    testHooks = /* @__PURE__ */ new Set(["afterAll", "afterEach", "beforeAll", "beforeEach"]);
+    VALID_CHAINS = /* @__PURE__ */ new Set([
+      // Hooks
+      "afterAll",
+      "afterEach",
+      "beforeAll",
+      "beforeEach",
+      "test.afterAll",
+      "test.afterEach",
+      "test.beforeAll",
+      "test.beforeEach",
+      // Describe
+      "describe",
+      "describe.only",
+      "describe.skip",
+      "describe.fixme",
+      "describe.fixme.only",
+      "describe.configure",
+      "describe.serial",
+      "describe.serial.only",
+      "describe.serial.skip",
+      "describe.serial.fixme",
+      "describe.serial.fixme.only",
+      "describe.parallel",
+      "describe.parallel.only",
+      "describe.parallel.skip",
+      "describe.parallel.fixme",
+      "describe.parallel.fixme.only",
+      "test.describe",
+      "test.describe.only",
+      "test.describe.skip",
+      "test.describe.fixme",
+      "test.describe.fixme.only",
+      "test.describe.configure",
+      "test.describe.serial",
+      "test.describe.serial.only",
+      "test.describe.serial.skip",
+      "test.describe.serial.fixme",
+      "test.describe.serial.fixme.only",
+      "test.describe.parallel",
+      "test.describe.parallel.only",
+      "test.describe.parallel.skip",
+      "test.describe.parallel.fixme",
+      "test.describe.parallel.fixme.only",
+      // Test
+      "test",
+      "test.fail",
+      "test.fixme",
+      "test.only",
+      "test.skip",
+      "test.step",
+      "test.slow",
+      "test.use"
+    ]);
+    joinChains = (a, b) => a && b ? [...a, ...b] : null;
+    isSupportedAccessor = (node, value) => isIdentifier(node, value) || isStringNode(node, value);
+    resolvePossibleAliasedGlobal = (context, global) => {
+      const globalAliases = context.settings.playwright?.globalAliases ?? {};
+      const alias = Object.entries(globalAliases).find(
+        ([, aliases]) => aliases.includes(global)
+      );
+      return alias?.[0] ?? null;
+    };
+    resolveToPlaywrightFn = (context, accessor) => {
+      const ident = getStringValue(accessor);
+      const resolved = /(^expect|Expect)$/.test(ident) ? "expect" : ident;
+      return {
+        // eslint-disable-next-line sort/object-properties
+        original: resolvePossibleAliasedGlobal(context, resolved),
+        local: resolved
+      };
+    };
+    modifiers = /* @__PURE__ */ new Set(["not", "resolves", "rejects"]);
+    findModifiersAndMatcher = (members) => {
+      const modifiers2 = [];
+      for (const member of members) {
+        const name = getStringValue(member);
+        if (name === "soft" || name === "poll") {
+          if (modifiers2.length > 0) {
+            return "modifier-unknown";
+          }
+        } else if (name === "resolves" || name === "rejects") {
+          const lastModifier = getStringValue(modifiers2.at(-1));
+          if (lastModifier && lastModifier !== "soft" && lastModifier !== "poll") {
+            return "modifier-unknown";
+          }
+        } else if (name !== "not") {
+          if (member.parent?.type === "MemberExpression" && member.parent.parent?.type === "CallExpression") {
+            return {
+              matcher: member,
+              matcherArgs: member.parent.parent.arguments,
+              matcherName: name,
+              modifiers: modifiers2
+            };
+          }
+          return "modifier-unknown";
+        }
+        modifiers2.push(member);
+      }
+      return "matcher-not-found";
+    };
+    parseExpectCall = (call) => {
+      const modifiersAndMatcher = findModifiersAndMatcher(call.members);
+      if (typeof modifiersAndMatcher === "string") {
+        return modifiersAndMatcher;
+      }
+      return {
+        ...call,
+        args: getExpectArguments(call),
+        type: "expect",
+        ...modifiersAndMatcher
+      };
+    };
+    findTopMostCallExpression = (node) => {
+      let top = node;
+      let parent = getParent(node);
+      let child = node;
+      while (parent) {
+        if (parent.type === "CallExpression" && parent.callee === child) {
+          top = parent;
+          node = parent;
+          parent = getParent(parent);
+          continue;
+        }
+        if (parent.type !== "MemberExpression") {
+          break;
+        }
+        child = parent;
+        parent = getParent(parent);
+      }
+      return top;
+    };
+    cache = /* @__PURE__ */ new WeakMap();
+    isTypeOfFnCall = (context, node, types) => {
+      const call = parseFnCall(context, node);
+      return call !== null && types.includes(call.type);
+    };
+  }
+});
+
 // src/utils/ast.ts
 function getStringValue(node) {
   if (!node)
@@ -16,7 +254,7 @@ function getRawValue(node) {
   return node.type === "Literal" ? node.raw : void 0;
 }
 function isIdentifier(node, name) {
-  return node.type === "Identifier" && (typeof name === "string" ? node.name === name : name.test(node.name));
+  return node.type === "Identifier" && (!name || (typeof name === "string" ? node.name === name : name.test(node.name)));
 }
 function isLiteral(node, type, value) {
   return node.type === "Literal" && (value === void 0 ? typeof node.value === type : node.value === value);
@@ -27,91 +265,20 @@ function isStringLiteral(node, value) {
 function isBooleanLiteral(node, value) {
   return isLiteral(node, "boolean", value);
 }
-function isStringNode(node) {
-  return node && (isStringLiteral(node) || isTemplateLiteral(node));
+function isStringNode(node, value) {
+  return node && (isStringLiteral(node, value) || isTemplateLiteral(node, value));
 }
 function isPropertyAccessor(node, name) {
   return getStringValue(node.property) === name;
 }
-function getTestNames(context) {
-  const aliases = context.settings.playwright?.globalAliases?.test ?? [];
-  return ["test", ...aliases];
-}
-function isTestIdentifier(context, node) {
-  const testNames = getTestNames(context);
-  const regex = new RegExp(`^(${testNames.join("|")})$`);
-  return isIdentifier(node, regex) || node.type === "MemberExpression" && isIdentifier(node.object, regex);
-}
-function isDescribeCall(node) {
-  const inner = node.type === "CallExpression" ? node.callee : node;
-  if (isIdentifier(inner, "describe")) {
-    return true;
-  }
-  if (inner.type !== "MemberExpression") {
-    return false;
-  }
-  return isPropertyAccessor(inner, "describe") ? true : describeProperties.has(getStringValue(inner.property)) ? isDescribeCall(inner.object) : false;
-}
 function getParent(node) {
   return node.parent;
 }
 function findParent(node, type) {
-  if (!node.parent)
+  const parent = node.parent;
+  if (!parent)
     return;
-  return node.parent.type === type ? node.parent : findParent(node.parent, type);
-}
-function isTestCall(context, node, modifiers) {
-  return isTestIdentifier(context, node.callee) && !isDescribeCall(node) && (node.callee.type !== "MemberExpression" || !modifiers || modifiers?.includes(getStringValue(node.callee.property))) && node.arguments.length === 2 && isFunction(node.arguments[1]);
-}
-function isTestHook(context, node) {
-  return node.callee.type === "MemberExpression" && isTestIdentifier(context, node.callee.object) && testHooks.has(getStringValue(node.callee.property));
-}
-function parseFnCall(context, node) {
-  if (isTestCall(context, node)) {
-    return {
-      fn: node.arguments[1],
-      name: getStringValue(node.callee),
-      type: "test"
-    };
-  }
-  if (node.callee.type === "MemberExpression" && isTestIdentifier(context, node.callee.object) && testHooks.has(getStringValue(node.callee.property))) {
-    return {
-      fn: node.arguments[0],
-      name: getStringValue(node.callee.property),
-      type: "hook"
-    };
-  }
-  if (isDescribeCall(node)) {
-    return {
-      name: getStringValue(node.callee),
-      type: "describe"
-    };
-  }
-}
-function getExpectType(context, node) {
-  const aliases = context.settings.playwright?.globalAliases?.expect ?? [];
-  const expectNames = ["expect", ...aliases];
-  const regex = new RegExp(`(^(${expectNames.join("|")})|Expect)$`);
-  if (isIdentifier(node.callee, regex)) {
-    return "standalone";
-  }
-  if (node.callee.type === "MemberExpression" && // TODO: Maybe
-  isIdentifier(node.callee.object, "expect")) {
-    const type = getStringValue(node.callee.property);
-    return expectSubCommands.has(type) ? type : void 0;
-  }
-}
-function isExpectCall(context, node) {
-  return !!getExpectType(context, node);
-}
-function getMatchers(node, chain = []) {
-  if (node.parent.type === "MemberExpression" && node.parent.object === node) {
-    return getMatchers(node.parent, [
-      ...chain,
-      node.parent.property
-    ]);
-  }
-  return chain;
+  return parent.type === type ? parent : findParent(parent, type);
 }
 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;
@@ -120,36 +287,42 @@ function isPageMethod(node, name) {
   return node.callee.type === "MemberExpression" && dig(node.callee.object, /(^(page|frame)|(Page|Frame)$)/) && isPropertyAccessor(node.callee, name);
 }
 function isFunction(node) {
-  return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+  return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+}
+function getNodeName(node) {
+  if (isSupportedAccessor(node)) {
+    return getStringValue(node);
+  }
+  switch (node.type) {
+    case "TaggedTemplateExpression":
+      return getNodeName(node.tag);
+    case "MemberExpression":
+      return joinNames(getNodeName(node.object), getNodeName(node.property));
+    case "NewExpression":
+    case "CallExpression":
+      return getNodeName(node.callee);
+  }
+  return null;
 }
-var isTemplateLiteral, describeProperties, testHooks, expectSubCommands, equalityMatchers;
+var isTemplateLiteral, equalityMatchers, joinNames;
 var init_ast = __esm({
   "src/utils/ast.ts"() {
     "use strict";
+    init_parseFnCall();
     isTemplateLiteral = (node, value) => node.type === "TemplateLiteral" && node.quasis.length === 1 && // bail out if not simple
     (value === void 0 || node.quasis[0].value.raw === value);
-    describeProperties = /* @__PURE__ */ new Set([
-      "parallel",
-      "serial",
-      "only",
-      "skip",
-      "fixme"
-    ]);
-    testHooks = /* @__PURE__ */ new Set(["afterAll", "afterEach", "beforeAll", "beforeEach"]);
-    expectSubCommands = /* @__PURE__ */ new Set(["soft", "poll"]);
     equalityMatchers = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
+    joinNames = (a, b) => a && b ? `${a}.${b}` : null;
   }
 });
 
 // src/rules/expect-expect.ts
-function isAssertionCall(context, node, assertFunctionNames) {
-  return isExpectCall(context, node) || assertFunctionNames.find((name) => dig(node.callee, name));
-}
 var expect_expect_default;
 var init_expect_expect = __esm({
   "src/rules/expect-expect.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     expect_expect_default = {
       create(context) {
         const options = {
@@ -168,9 +341,10 @@ var init_expect_expect = __esm({
         }
         return {
           CallExpression(node) {
-            if (isTestCall(context, node, ["fixme", "only", "skip"])) {
+            const call = parseFnCall(context, node);
+            if (call?.type === "test") {
               unchecked.push(node);
-            } else if (isAssertionCall(context, node, options.assertFunctionNames)) {
+            } else if (call?.type === "expect" || options.assertFunctionNames.find((name) => dig(node.callee, name))) {
               const ancestors = context.sourceCode.getAncestors(node);
               checkExpressions(ancestors);
             }
@@ -216,6 +390,7 @@ var init_max_expects = __esm({
   "src/rules/max-expects.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     max_expects_default = {
       create(context) {
         const options = {
@@ -225,7 +400,7 @@ var init_max_expects = __esm({
         let count = 0;
         const maybeResetCount = (node) => {
           const parent = getParent(node);
-          const isTestFn = parent?.type !== "CallExpression" || isTestCall(context, parent);
+          const isTestFn = parent?.type !== "CallExpression" || isTypeOfFnCall(context, parent, ["test"]);
           if (isTestFn) {
             count = 0;
           }
@@ -234,8 +409,10 @@ var init_max_expects = __esm({
           ArrowFunctionExpression: maybeResetCount,
           "ArrowFunctionExpression:exit": maybeResetCount,
           CallExpression(node) {
-            if (!getExpectType(context, node))
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect" || getParent(call.head.node)?.type === "MemberExpression") {
               return;
+            }
             count += 1;
             if (count > options.max) {
               context.report({
@@ -285,39 +462,33 @@ var max_nested_describe_default;
 var init_max_nested_describe = __esm({
   "src/rules/max-nested-describe.ts"() {
     "use strict";
-    init_ast();
+    init_parseFnCall();
     max_nested_describe_default = {
       create(context) {
         const { options } = context;
         const max = options[0]?.max ?? 5;
-        const describeCallbackStack = [];
-        function pushDescribeCallback(node) {
-          if (node.parent.type !== "CallExpression" || !isDescribeCall(node.parent)) {
-            return;
-          }
-          describeCallbackStack.push(0);
-          if (describeCallbackStack.length > max) {
-            context.report({
-              data: {
-                depth: describeCallbackStack.length.toString(),
-                max: max.toString()
-              },
-              messageId: "exceededMaxDepth",
-              node: node.parent.callee
-            });
-          }
-        }
-        function popDescribeCallback(node) {
-          const { parent } = node;
-          if (parent.type === "CallExpression" && isDescribeCall(parent)) {
-            describeCallbackStack.pop();
-          }
-        }
+        const describes = [];
         return {
-          ArrowFunctionExpression: pushDescribeCallback,
-          "ArrowFunctionExpression:exit": popDescribeCallback,
-          FunctionExpression: pushDescribeCallback,
-          "FunctionExpression:exit": popDescribeCallback
+          CallExpression(node) {
+            if (isTypeOfFnCall(context, node, ["describe"])) {
+              describes.unshift(node);
+              if (describes.length > max) {
+                context.report({
+                  data: {
+                    depth: describes.length.toString(),
+                    max: max.toString()
+                  },
+                  messageId: "exceededMaxDepth",
+                  node: node.callee
+                });
+              }
+            }
+          },
+          "CallExpression:exit"(node) {
+            if (describes[0] === node) {
+              describes.shift();
+            }
+          }
         };
       },
       meta: {
@@ -349,24 +520,23 @@ var init_max_nested_describe = __esm({
 });
 
 // src/rules/missing-playwright-await.ts
-function getCallType(context, node, awaitableMatchers) {
-  if (node.callee.type === "MemberExpression" && isIdentifier(node.callee.object, "test") && isPropertyAccessor(node.callee, "step")) {
-    return { messageId: "testStep", node };
+function getReportNode(node) {
+  const parent = getParent(node);
+  return parent?.type === "MemberExpression" ? parent : node;
+}
+function getCallType(call, awaitableMatchers) {
+  if (call.type === "step") {
+    return { messageId: "testStep", node: call.head.node };
   }
-  const expectType = getExpectType(context, node);
-  if (!expectType)
-    return;
-  const [lastMatcher] = getMatchers(node).slice(-1);
-  const grandparent = lastMatcher?.parent?.parent;
-  if (grandparent?.type !== "CallExpression")
-    return;
-  const matcherName = getStringValue(lastMatcher);
-  if (expectType === "poll" || awaitableMatchers.has(matcherName)) {
-    return {
-      data: { matcherName },
-      messageId: expectType === "poll" ? "expectPoll" : "expect",
-      node: grandparent
-    };
+  if (call.type === "expect") {
+    const isPoll = call.modifiers.some((m) => getStringValue(m) === "poll");
+    if (isPoll || awaitableMatchers.has(call.matcherName)) {
+      return {
+        data: { matcherName: call.matcherName },
+        messageId: isPoll ? "expectPoll" : "expect",
+        node: call.head.node
+      };
+    }
   }
 }
 var validTypes, expectPlaywrightMatchers, playwrightTestMatchers, missing_playwright_await_default;
@@ -374,6 +544,7 @@ var init_missing_playwright_await = __esm({
   "src/rules/missing-playwright-await.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     validTypes = /* @__PURE__ */ new Set([
       "AwaitExpression",
       "ReturnStatement",
@@ -436,16 +607,19 @@ var init_missing_playwright_await = __esm({
           ...options.customMatchers || []
         ]);
         function checkValidity(node) {
-          if (validTypes.has(node.parent.type))
+          const parent = getParent(node);
+          if (!parent)
+            return false;
+          if (validTypes.has(parent.type))
             return true;
-          if (node.parent.type === "ArrayExpression") {
-            return checkValidity(node.parent);
+          if (parent.type === "ArrayExpression") {
+            return checkValidity(parent);
           }
-          if (node.parent.type === "CallExpression" && node.parent.callee.type === "MemberExpression" && isIdentifier(node.parent.callee.object, "Promise") && isIdentifier(node.parent.callee.property, "all")) {
+          if (parent.type === "CallExpression" && parent.callee.type === "MemberExpression" && isIdentifier(parent.callee.object, "Promise") && isIdentifier(parent.callee.property, "all")) {
             return true;
           }
-          if (node.parent.type === "VariableDeclarator") {
-            const scope = context.sourceCode.getScope(node.parent.parent);
+          if (parent.type === "VariableDeclarator") {
+            const scope = context.sourceCode.getScope(parent.parent);
             for (const ref of scope.references) {
               const refParent = ref.identifier.parent;
               if (validTypes.has(refParent.type))
@@ -458,14 +632,17 @@ var init_missing_playwright_await = __esm({
         }
         return {
           CallExpression(node) {
-            const result = getCallType(context, node, awaitableMatchers);
-            const isValid = result ? checkValidity(result.node) : false;
+            const call = parseFnCall(context, node);
+            if (call?.type !== "step" && call?.type !== "expect")
+              return;
+            const result = getCallType(call, awaitableMatchers);
+            const isValid = result ? checkValidity(node) : false;
             if (result && !isValid) {
               context.report({
                 data: result.data,
                 fix: (fixer) => fixer.insertTextBefore(node, "await "),
                 messageId: result.messageId,
-                node: node.callee
+                node: getReportNode(result.node)
               });
             }
           }
@@ -502,6 +679,10 @@ var init_missing_playwright_await = __esm({
 });
 
 // src/rules/no-commented-out-tests.ts
+function getTestNames(context) {
+  const aliases = context.settings.playwright?.globalAliases?.test ?? [];
+  return ["test", ...aliases];
+}
 function hasTests(context, node) {
   const testNames = getTestNames(context);
   const names = testNames.join("|");
@@ -515,7 +696,6 @@ var no_commented_out_tests_default;
 var init_no_commented_out_tests = __esm({
   "src/rules/no-commented-out-tests.ts"() {
     "use strict";
-    init_ast();
     no_commented_out_tests_default = {
       create(context) {
         function checkNode(node) {
@@ -554,13 +734,15 @@ var init_no_conditional_expect = __esm({
   "src/rules/no-conditional-expect.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     isCatchCall = (node) => node.callee.type === "MemberExpression" && isPropertyAccessor(node.callee, "catch");
     getTestCallExpressionsFromDeclaredVariables = (context, declaredVariables) => {
       return declaredVariables.reduce(
         (acc, { references }) => [
           ...acc,
           ...references.map(({ identifier }) => getParent(identifier)).filter(
-            (node) => node?.type === "CallExpression" && isTestCall(context, node)
+            // ESLint types are infurating
+            (node) => node?.type === "CallExpression" && isTypeOfFnCall(context, node, ["test"])
           )
         ],
         []
@@ -575,20 +757,20 @@ var init_no_conditional_expect = __esm({
         const decreaseConditionalDepth = () => inTestCase && conditionalDepth--;
         return {
           CallExpression(node) {
-            if (isTestCall(context, node)) {
+            const call = parseFnCall(context, node);
+            if (call?.type === "test") {
               inTestCase = true;
             }
             if (isCatchCall(node)) {
               inPromiseCatch = true;
             }
-            const expectType = getExpectType(context, node);
-            if (inTestCase && expectType && conditionalDepth > 0) {
+            if (inTestCase && call?.type === "expect" && conditionalDepth > 0) {
               context.report({
                 messageId: "conditionalExpect",
                 node
               });
             }
-            if (inPromiseCatch && expectType) {
+            if (inPromiseCatch && call?.type === "expect") {
               context.report({
                 messageId: "conditionalExpect",
                 node
@@ -596,7 +778,7 @@ var init_no_conditional_expect = __esm({
             }
           },
           "CallExpression:exit"(node) {
-            if (isTestCall(context, node)) {
+            if (isTypeOfFnCall(context, node, ["test"])) {
               inTestCase = false;
             }
             if (isCatchCall(node)) {
@@ -647,11 +829,18 @@ var init_no_conditional_in_test = __esm({
   "src/rules/no-conditional-in-test.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     no_conditional_in_test_default = {
       create(context) {
         function checkConditional(node) {
           const call = findParent(node, "CallExpression");
-          if (call && isTestCall(context, call)) {
+          if (!call)
+            return;
+          const fnCall = parseFnCall(context, call);
+          if (fnCall?.type === "test" && fnCall.members.some((member) => getStringValue(member) === "skip") && call.arguments[0]?.type === "LogicalExpression") {
+            return;
+          }
+          if (fnCall?.type === "test" || fnCall?.type === "step") {
             context.report({ messageId: "conditionalInTest", node });
           }
         }
@@ -685,15 +874,19 @@ var init_no_duplicate_hooks = __esm({
   "src/rules/no-duplicate-hooks.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     no_duplicate_hooks_default = {
       create(context) {
         const hookContexts = [{}];
         return {
           CallExpression(node) {
-            if (isDescribeCall(node)) {
+            const call = parseFnCall(context, node);
+            if (!call)
+              return;
+            if (call.type === "describe") {
               hookContexts.push({});
             }
-            if (!isTestHook(context, node)) {
+            if (call.type !== "hook") {
               return;
             }
             const currentLayer = hookContexts[hookContexts.length - 1];
@@ -709,7 +902,7 @@ var init_no_duplicate_hooks = __esm({
             }
           },
           "CallExpression:exit"(node) {
-            if (isDescribeCall(node)) {
+            if (isTypeOfFnCall(context, node, ["describe"])) {
               hookContexts.pop();
             }
           }
@@ -838,27 +1031,33 @@ var init_no_focused_test = __esm({
   "src/rules/no-focused-test.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     no_focused_test_default = {
       create(context) {
         return {
           CallExpression(node) {
-            if ((isTestCall(context, node) || isDescribeCall(node)) && node.callee.type === "MemberExpression" && isPropertyAccessor(node.callee, "only")) {
-              const { callee } = node;
-              context.report({
-                messageId: "noFocusedTest",
-                node: node.callee.property,
-                suggest: [
-                  {
-                    // - 1 to remove the `.only` annotation with dot notation
-                    fix: (fixer) => fixer.removeRange([
-                      callee.property.range[0] - 1,
-                      callee.range[1]
-                    ]),
-                    messageId: "suggestRemoveOnly"
-                  }
-                ]
-              });
+            const call = parseFnCall(context, node);
+            if (call?.type !== "test" && call?.type !== "describe") {
+              return;
             }
+            const onlyNode = call.members.find((s) => getStringValue(s) === "only");
+            if (!onlyNode)
+              return;
+            context.report({
+              messageId: "noFocusedTest",
+              node: onlyNode,
+              suggest: [
+                {
+                  fix: (fixer) => {
+                    return fixer.removeRange([
+                      onlyNode.range[0] - 1,
+                      onlyNode.range[1] + Number(onlyNode.type !== "Identifier")
+                    ]);
+                  },
+                  messageId: "suggestRemoveOnly"
+                }
+              ]
+            });
           }
         };
       },
@@ -971,7 +1170,7 @@ var no_hooks_default;
 var init_no_hooks = __esm({
   "src/rules/no-hooks.ts"() {
     "use strict";
-    init_ast();
+    init_parseFnCall();
     no_hooks_default = {
       create(context) {
         const options = {
@@ -981,7 +1180,9 @@ var init_no_hooks = __esm({
         return {
           CallExpression(node) {
             const call = parseFnCall(context, node);
-            if (call?.type === "hook" && !options.allow.includes(call.name)) {
+            if (!call)
+              return;
+            if (call.type === "hook" && !options.allow.includes(call.name)) {
               context.report({
                 data: { hookName: call.name },
                 messageId: "unexpectedHook",
@@ -1270,62 +1471,23 @@ var init_no_raw_locators = __esm({
   }
 });
 
-// src/utils/parseExpectCall.ts
-function getExpectArguments(node) {
-  const grandparent = node.parent.parent;
-  return grandparent.type === "CallExpression" ? grandparent.arguments : [];
-}
-function parseExpectCall(context, node) {
-  if (!isExpectCall(context, node)) {
-    return;
-  }
-  const members = getMatchers(node);
-  const modifiers = [];
-  let matcher;
-  members.forEach((item) => {
-    if (MODIFIER_NAMES.has(getStringValue(item))) {
-      modifiers.push(item);
-    } else {
-      matcher = item;
-    }
-  });
-  if (!matcher) {
-    return;
-  }
-  return {
-    args: getExpectArguments(matcher),
-    matcher,
-    matcherName: getStringValue(matcher),
-    members,
-    modifiers
-  };
-}
-var MODIFIER_NAMES;
-var init_parseExpectCall = __esm({
-  "src/utils/parseExpectCall.ts"() {
-    "use strict";
-    init_ast();
-    MODIFIER_NAMES = /* @__PURE__ */ new Set(["not", "resolves", "rejects"]);
-  }
-});
-
 // src/rules/no-restricted-matchers.ts
 var no_restricted_matchers_default;
 var init_no_restricted_matchers = __esm({
   "src/rules/no-restricted-matchers.ts"() {
     "use strict";
     init_ast();
-    init_parseExpectCall();
+    init_parseFnCall();
     no_restricted_matchers_default = {
       create(context) {
         const restrictedChains = context.options?.[0] ?? {};
         return {
           CallExpression(node) {
-            const expectCall = parseExpectCall(context, node);
-            if (!expectCall)
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect")
               return;
             Object.entries(restrictedChains).map(([restriction, message]) => {
-              const chain = expectCall.members;
+              const chain = call.members;
               const restrictionLinks = restriction.split(".").length;
               const startIndex = chain.findIndex((_, i) => {
                 const partial = chain.slice(i, i + restrictionLinks).map(getStringValue).join(".");
@@ -1382,34 +1544,39 @@ var init_no_skipped_test = __esm({
   "src/rules/no-skipped-test.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     no_skipped_test_default = {
       create(context) {
         return {
           CallExpression(node) {
             const options = context.options[0] || {};
             const allowConditional = !!options.allowConditional;
-            const { callee } = node;
-            if ((isTestIdentifier(context, callee) || isDescribeCall(node)) && callee.type === "MemberExpression" && isPropertyAccessor(callee, "skip")) {
-              const isHook = isTestCall(context, node) || isDescribeCall(node);
-              if (!isHook && allowConditional && node.arguments.length) {
-                return;
-              }
-              context.report({
-                messageId: "noSkippedTest",
-                node: isHook ? callee.property : node,
-                suggest: [
-                  {
-                    fix: (fixer) => {
-                      return isHook ? fixer.removeRange([
-                        callee.property.range[0] - 1,
-                        callee.range[1]
-                      ]) : fixer.remove(node.parent);
-                    },
-                    messageId: "removeSkippedTestAnnotation"
-                  }
-                ]
-              });
+            const call = parseFnCall(context, node);
+            if (call?.type !== "test" && call?.type !== "describe") {
+              return;
             }
+            const skipNode = call.members.find((s) => getStringValue(s) === "skip");
+            if (!skipNode)
+              return;
+            const isStandalone = call.type === "test" && !isFunction(node.arguments[1]);
+            if (isStandalone && allowConditional && node.arguments.length) {
+              return;
+            }
+            context.report({
+              messageId: "noSkippedTest",
+              node: isStandalone ? node : skipNode,
+              suggest: [
+                {
+                  fix: (fixer) => {
+                    return isStandalone ? fixer.remove(node.parent) : fixer.removeRange([
+                      skipNode.range[0] - 1,
+                      skipNode.range[1] + Number(skipNode.type !== "Identifier")
+                    ]);
+                  },
+                  messageId: "removeSkippedTestAnnotation"
+                }
+              ]
+            });
           }
         };
       },
@@ -1449,7 +1616,8 @@ var init_no_standalone_expect = __esm({
   "src/rules/no-standalone-expect.ts"() {
     "use strict";
     init_ast();
-    getBlockType = (statement) => {
+    init_parseFnCall();
+    getBlockType = (context, statement) => {
       const func = getParent(statement);
       if (!func) {
         throw new Error(
@@ -1464,7 +1632,7 @@ var init_no_standalone_expect = __esm({
         if (expr.type === "VariableDeclarator" || expr.type === "MethodDefinition") {
           return "function";
         }
-        if (expr.type === "CallExpression" && isDescribeCall(expr)) {
+        if (expr.type === "CallExpression" && isTypeOfFnCall(context, expr, ["describe"])) {
           return "describe";
         }
       }
@@ -1480,43 +1648,48 @@ var init_no_standalone_expect = __esm({
             }
           },
           "ArrowFunctionExpression:exit"() {
-            if (callStack[callStack.length - 1] === "arrow") {
+            if (callStack.at(-1) === "arrow") {
               callStack.pop();
             }
           },
           BlockStatement(statement) {
-            const blockType = getBlockType(statement);
+            const blockType = getBlockType(context, statement);
             if (blockType) {
               callStack.push(blockType);
             }
           },
           "BlockStatement:exit"(statement) {
-            if (callStack[callStack.length - 1] === getBlockType(statement)) {
+            if (callStack.at(-1) === getBlockType(context, statement)) {
               callStack.pop();
             }
           },
           CallExpression(node) {
-            if (getExpectType(context, node)) {
+            const call = parseFnCall(context, node);
+            if (call?.type === "expect") {
+              if (getParent(call.head.node)?.type === "MemberExpression" && call.members.length === 1 && !["assertions", "hasAssertions"].includes(
+                getStringValue(call.members[0])
+              )) {
+                return;
+              }
               const parent = callStack.at(-1);
               if (!parent || parent === "describe") {
-                const root = findParent(node, "CallExpression");
-                context.report({
-                  messageId: "unexpectedExpect",
-                  node: root ?? node
-                });
+                context.report({ messageId: "unexpectedExpect", node });
               }
               return;
             }
-            if (isTestCall(context, node)) {
+            if (call?.type === "test") {
               callStack.push("test");
             }
+            if (call?.type === "hook") {
+              callStack.push("hook");
+            }
             if (node.callee.type === "TaggedTemplateExpression") {
               callStack.push("template");
             }
           },
           "CallExpression:exit"(node) {
-            const top = callStack[callStack.length - 1];
-            if (top === "test" && isTestCall(context, node) && node.callee.type !== "MemberExpression" || top === "template" && node.callee.type === "TaggedTemplateExpression") {
+            const top = callStack.at(-1);
+            if (top === "test" && isTypeOfFnCall(context, node, ["test"]) && node.callee.type !== "MemberExpression" || top === "template" && node.callee.type === "TaggedTemplateExpression") {
               callStack.pop();
             }
           }
@@ -1764,7 +1937,7 @@ var init_no_useless_not = __esm({
     "use strict";
     init_ast();
     init_fixer();
-    init_parseExpectCall();
+    init_parseFnCall();
     matcherMap = {
       toBeDisabled: "toBeEnabled",
       toBeEnabled: "toBeDisabled",
@@ -1775,27 +1948,28 @@ var init_no_useless_not = __esm({
       create(context) {
         return {
           CallExpression(node) {
-            const expectCall = parseExpectCall(context, node);
-            if (!expectCall)
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect")
               return;
-            const notModifier = expectCall.modifiers.find(
+            const notModifier = call.modifiers.find(
               (mod) => getStringValue(mod) === "not"
             );
             if (!notModifier)
               return;
-            if (expectCall.matcherName in matcherMap) {
-              const newMatcher = matcherMap[expectCall.matcherName];
+            const matcherName = call.matcherName;
+            if (matcherName in matcherMap) {
+              const newMatcher = matcherMap[matcherName];
               context.report({
-                data: { new: newMatcher, old: expectCall.matcherName },
+                data: { new: newMatcher, old: matcherName },
                 fix: (fixer) => [
                   fixer.removeRange([
                     notModifier.range[0] - getRangeOffset(notModifier),
                     notModifier.range[1] + 1
                   ]),
-                  replaceAccessorFixer(fixer, expectCall.matcher, newMatcher)
+                  replaceAccessorFixer(fixer, call.matcher, newMatcher)
                 ],
                 loc: {
-                  end: expectCall.matcher.loc.end,
+                  end: call.matcher.loc.end,
                   start: notModifier.loc.start
                 },
                 messageId: "noUselessNot"
@@ -1917,7 +2091,7 @@ var init_prefer_comparison_matcher = __esm({
   "src/rules/prefer-comparison-matcher.ts"() {
     "use strict";
     init_ast();
-    init_parseExpectCall();
+    init_parseFnCall();
     isString = (node) => {
       return isStringLiteral(node) || node.type === "TemplateLiteral";
     };
@@ -1944,17 +2118,19 @@ var init_prefer_comparison_matcher = __esm({
       create(context) {
         return {
           CallExpression(node) {
-            const expectCall = parseExpectCall(context, node);
-            if (!expectCall || expectCall.args.length === 0)
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect" || call.matcherArgs.length === 0)
               return;
-            const { args, matcher } = expectCall;
-            const [comparison] = node.arguments;
-            const expectCallEnd = node.range[1];
-            const [matcherArg] = args;
-            if (comparison?.type !== "BinaryExpression" || isComparingToString(comparison) || !equalityMatchers.has(getStringValue(matcher)) || !isBooleanLiteral(matcherArg)) {
+            const expect = findParent(call.head.node, "CallExpression");
+            if (!expect)
+              return;
+            const [comparison] = expect.arguments;
+            const expectCallEnd = expect.range[1];
+            const [matcherArg] = call.matcherArgs;
+            if (comparison?.type !== "BinaryExpression" || isComparingToString(comparison) || !equalityMatchers.has(call.matcherName) || !isBooleanLiteral(matcherArg)) {
               return;
             }
-            const hasNot = expectCall.modifiers.some(
+            const hasNot = call.modifiers.some(
               (node2) => getStringValue(node2) === "not"
             );
             const preferredMatcher = determineMatcher(
@@ -1967,7 +2143,7 @@ var init_prefer_comparison_matcher = __esm({
             context.report({
               data: { preferredMatcher },
               fix(fixer) {
-                const [modifier] = expectCall.modifiers;
+                const [modifier] = call.modifiers;
                 const modifierText = modifier && getStringValue(modifier) !== "not" ? `.${getStringValue(modifier)}` : "";
                 return [
                   // Replace the comparison argument with the left-hand side of the comparison
@@ -1977,7 +2153,7 @@ var init_prefer_comparison_matcher = __esm({
                   ),
                   // Replace the current matcher & modifier with the preferred matcher
                   fixer.replaceTextRange(
-                    [expectCallEnd, getParent(matcher).range[1]],
+                    [expectCallEnd, getParent(call.matcher).range[1]],
                     `${modifierText}.${preferredMatcher}`
                   ),
                   // Replace the matcher argument with the right-hand side of the comparison
@@ -1988,7 +2164,7 @@ var init_prefer_comparison_matcher = __esm({
                 ];
               },
               messageId: "useToBeComparison",
-              node: matcher
+              node: call.matcher
             });
           }
         };
@@ -2015,30 +2191,32 @@ var init_prefer_equality_matcher = __esm({
   "src/rules/prefer-equality-matcher.ts"() {
     "use strict";
     init_ast();
-    init_parseExpectCall();
+    init_parseFnCall();
     prefer_equality_matcher_default = {
       create(context) {
         return {
           CallExpression(node) {
-            const expectCall = parseExpectCall(context, node);
-            if (!expectCall || expectCall.args.length === 0)
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect" || call.matcherArgs.length === 0)
               return;
-            const { args, matcher } = expectCall;
-            const [comparison] = node.arguments;
-            const expectCallEnd = node.range[1];
-            const [matcherArg] = args;
-            if (comparison?.type !== "BinaryExpression" || comparison.operator !== "===" && comparison.operator !== "!==" || !equalityMatchers.has(getStringValue(matcher)) || !isBooleanLiteral(matcherArg)) {
+            const expect = findParent(call.head.node, "CallExpression");
+            if (!expect)
+              return;
+            const [comparison] = expect.arguments;
+            const expectCallEnd = expect.range[1];
+            const [matcherArg] = call.matcherArgs;
+            if (comparison?.type !== "BinaryExpression" || comparison.operator !== "===" && comparison.operator !== "!==" || !equalityMatchers.has(call.matcherName) || !isBooleanLiteral(matcherArg)) {
               return;
             }
             const matcherValue = getRawValue(matcherArg) === "true";
-            const [modifier] = expectCall.modifiers;
-            const hasNot = expectCall.modifiers.some(
+            const [modifier] = call.modifiers;
+            const hasNot = call.modifiers.some(
               (node2) => getStringValue(node2) === "not"
             );
             const addNotModifier = (comparison.operator === "!==" ? !matcherValue : matcherValue) === hasNot;
             context.report({
               messageId: "useEqualityMatcher",
-              node: matcher,
+              node: call.matcher,
               suggest: [...equalityMatchers.keys()].map((equalityMatcher) => ({
                 data: { matcher: equalityMatcher },
                 fix(fixer) {
@@ -2054,7 +2232,7 @@ var init_prefer_equality_matcher = __esm({
                     ),
                     // replace the current matcher & modifier with the preferred matcher
                     fixer.replaceTextRange(
-                      [expectCallEnd, getParent(matcher).range[1]],
+                      [expectCallEnd, getParent(call.matcher).range[1]],
                       `${modifierText}.${equalityMatcher}`
                     ),
                     // replace the matcher argument with the right-hand side of the comparison
@@ -2089,12 +2267,12 @@ var init_prefer_equality_matcher = __esm({
 });
 
 // src/rules/prefer-hooks-in-order.ts
-var HooksOrder, prefer_hooks_in_order_default;
+var order, prefer_hooks_in_order_default;
 var init_prefer_hooks_in_order = __esm({
   "src/rules/prefer-hooks-in-order.ts"() {
     "use strict";
-    init_ast();
-    HooksOrder = ["beforeAll", "beforeEach", "afterEach", "afterAll"];
+    init_parseFnCall();
+    order = ["beforeAll", "beforeEach", "afterEach", "afterAll"];
     prefer_hooks_in_order_default = {
       create(context) {
         let previousHookIndex = -1;
@@ -2103,33 +2281,34 @@ var init_prefer_hooks_in_order = __esm({
           CallExpression(node) {
             if (inHook)
               return;
-            if (!isTestHook(context, node)) {
+            const call = parseFnCall(context, node);
+            if (call?.type !== "hook") {
               previousHookIndex = -1;
               return;
             }
             inHook = true;
-            const currentHook = node.callee.type === "MemberExpression" ? getStringValue(node.callee.property) : "";
-            const currentHookIndex = HooksOrder.indexOf(currentHook);
+            const currentHook = call.name;
+            const currentHookIndex = order.indexOf(currentHook);
             if (currentHookIndex < previousHookIndex) {
-              return context.report({
+              context.report({
                 data: {
                   currentHook,
-                  previousHook: HooksOrder[previousHookIndex]
+                  previousHook: order[previousHookIndex]
                 },
                 messageId: "reorderHooks",
                 node
               });
+              return;
             }
             previousHookIndex = currentHookIndex;
           },
           "CallExpression:exit"(node) {
-            if (isTestHook(context, node)) {
+            if (isTypeOfFnCall(context, node, ["hook"])) {
               inHook = false;
               return;
             }
-            if (inHook) {
+            if (inHook)
               return;
-            }
             previousHookIndex = -1;
           }
         };
@@ -2155,20 +2334,17 @@ var prefer_hooks_on_top_default;
 var init_prefer_hooks_on_top = __esm({
   "src/rules/prefer-hooks-on-top.ts"() {
     "use strict";
-    init_ast();
+    init_parseFnCall();
     prefer_hooks_on_top_default = {
       create(context) {
         const stack = [false];
         return {
           CallExpression(node) {
-            if (isTestCall(context, node)) {
+            if (isTypeOfFnCall(context, node, ["test"])) {
               stack[stack.length - 1] = true;
             }
-            if (stack.at(-1) && isTestHook(context, node)) {
-              context.report({
-                messageId: "noHookOnTop",
-                node
-              });
+            if (stack.at(-1) && isTypeOfFnCall(context, node, ["hook"])) {
+              context.report({ messageId: "noHookOnTop", node });
             }
             stack.push(false);
           },
@@ -2199,6 +2375,7 @@ var init_prefer_lowercase_title = __esm({
   "src/rules/prefer-lowercase-title.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     prefer_lowercase_title_default = {
       create(context) {
         const { allowedPrefixes, ignore, ignoreTopLevelDescribe } = {
@@ -2210,14 +2387,15 @@ var init_prefer_lowercase_title = __esm({
         let describeCount = 0;
         return {
           CallExpression(node) {
-            const method = isDescribeCall(node) ? "test.describe" : isTestCall(context, node) ? "test" : null;
-            if (method === "test.describe") {
+            const call = parseFnCall(context, node);
+            if (call?.type !== "describe" && call?.type !== "test") {
+              return;
+            }
+            if (call.type === "describe") {
               describeCount++;
               if (ignoreTopLevelDescribe && describeCount === 1) {
                 return;
               }
-            } else if (!method) {
-              return;
             }
             const [title] = node.arguments;
             if (!isStringNode(title)) {
@@ -2227,6 +2405,7 @@ var init_prefer_lowercase_title = __esm({
             if (!description || allowedPrefixes.some((name) => description.startsWith(name))) {
               return;
             }
+            const method = call.type === "describe" ? "test.describe" : "test";
             const firstCharacter = description.charAt(0);
             if (!firstCharacter || firstCharacter === firstCharacter.toLowerCase() || ignore.includes(method)) {
               return;
@@ -2246,7 +2425,7 @@ var init_prefer_lowercase_title = __esm({
             });
           },
           "CallExpression:exit"(node) {
-            if (isDescribeCall(node)) {
+            if (isTypeOfFnCall(context, node, ["describe"])) {
               describeCount--;
             }
           }
@@ -2299,22 +2478,24 @@ var init_prefer_strict_equal = __esm({
   "src/rules/prefer-strict-equal.ts"() {
     "use strict";
     init_fixer();
-    init_parseExpectCall();
+    init_parseFnCall();
     prefer_strict_equal_default = {
       create(context) {
         return {
           CallExpression(node) {
-            const expectCall = parseExpectCall(context, node);
-            if (expectCall?.matcherName === "toEqual") {
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect")
+              return;
+            if (call.matcherName === "toEqual") {
               context.report({
                 messageId: "useToStrictEqual",
-                node: expectCall.matcher,
+                node: call.matcher,
                 suggest: [
                   {
                     fix: (fixer) => {
                       return replaceAccessorFixer(
                         fixer,
-                        expectCall.matcher,
+                        call.matcher,
                         "toStrictEqual"
                       );
                     },
@@ -2347,8 +2528,8 @@ var init_prefer_strict_equal = __esm({
 });
 
 // src/rules/prefer-to-be.ts
-function shouldUseToBe(expectCall) {
-  let arg = expectCall.args[0];
+function shouldUseToBe(call) {
+  let arg = call.matcherArgs[0];
   if (arg.type === "UnaryExpression" && arg.operator === "-") {
     arg = arg.argument;
   }
@@ -2357,14 +2538,14 @@ function shouldUseToBe(expectCall) {
   }
   return arg.type === "TemplateLiteral";
 }
-function reportPreferToBe(context, expectCall, whatToBe, notModifier) {
+function reportPreferToBe(context, call, whatToBe, notModifier) {
   context.report({
     fix(fixer) {
       const fixes = [
-        replaceAccessorFixer(fixer, expectCall.matcher, `toBe${whatToBe}`)
+        replaceAccessorFixer(fixer, call.matcher, `toBe${whatToBe}`)
       ];
-      if (expectCall.args?.length && whatToBe !== "") {
-        fixes.push(fixer.remove(expectCall.args[0]));
+      if (call.matcherArgs?.length && whatToBe !== "") {
+        fixes.push(fixer.remove(call.matcherArgs[0]));
       }
       if (notModifier) {
         const [start, end] = notModifier.range;
@@ -2373,7 +2554,7 @@ function reportPreferToBe(context, expectCall, whatToBe, notModifier) {
       return fixes;
     },
     messageId: `useToBe${whatToBe}`,
-    node: expectCall.matcher
+    node: call.matcher
   });
 }
 var prefer_to_be_default;
@@ -2382,42 +2563,42 @@ var init_prefer_to_be = __esm({
     "use strict";
     init_ast();
     init_fixer();
-    init_parseExpectCall();
+    init_parseFnCall();
     prefer_to_be_default = {
       create(context) {
         return {
           CallExpression(node) {
-            const expectCall = parseExpectCall(context, node);
-            if (!expectCall)
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect")
               return;
             const notMatchers = ["toBeUndefined", "toBeDefined"];
-            const notModifier = expectCall.modifiers.find(
+            const notModifier = call.modifiers.find(
               (node2) => getStringValue(node2) === "not"
             );
-            if (notModifier && notMatchers.includes(expectCall.matcherName)) {
+            if (notModifier && notMatchers.includes(call.matcherName)) {
               return reportPreferToBe(
                 context,
-                expectCall,
-                expectCall.matcherName === "toBeDefined" ? "Undefined" : "Defined",
+                call,
+                call.matcherName === "toBeDefined" ? "Undefined" : "Defined",
                 notModifier
               );
             }
-            const firstArg = expectCall.args[0];
-            if (!equalityMatchers.has(expectCall.matcherName) || !firstArg) {
+            const firstArg = call.matcherArgs[0];
+            if (!equalityMatchers.has(call.matcherName) || !firstArg) {
               return;
             }
             if (firstArg.type === "Literal" && firstArg.value === null) {
-              return reportPreferToBe(context, expectCall, "Null");
+              return reportPreferToBe(context, call, "Null");
             }
             if (isIdentifier(firstArg, "undefined")) {
               const name = notModifier ? "Defined" : "Undefined";
-              return reportPreferToBe(context, expectCall, name, notModifier);
+              return reportPreferToBe(context, call, name, notModifier);
             }
             if (isIdentifier(firstArg, "NaN")) {
-              return reportPreferToBe(context, expectCall, "NaN");
+              return reportPreferToBe(context, call, "NaN");
             }
-            if (shouldUseToBe(expectCall) && expectCall.matcherName !== "toBe") {
-              reportPreferToBe(context, expectCall, "");
+            if (shouldUseToBe(call) && call.matcherName !== "toBe") {
+              reportPreferToBe(context, call, "");
             }
           }
         };
@@ -2450,22 +2631,25 @@ var init_prefer_to_contain = __esm({
   "src/rules/prefer-to-contain.ts"() {
     "use strict";
     init_ast();
-    init_parseExpectCall();
+    init_parseFnCall();
     isFixableIncludesCallExpression = (node) => node.type === "CallExpression" && node.callee.type === "MemberExpression" && isPropertyAccessor(node.callee, "includes") && node.arguments.length === 1 && node.arguments[0].type !== "SpreadElement";
     prefer_to_contain_default = {
       create(context) {
         return {
           CallExpression(node) {
-            const expectCall = parseExpectCall(context, node);
-            if (!expectCall || expectCall.args.length === 0)
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect" || call.matcherArgs.length === 0)
+              return;
+            const expect = findParent(call.head.node, "CallExpression");
+            if (!expect)
               return;
-            const { args, matcher, matcherName } = expectCall;
-            const [includesCall] = node.arguments;
-            const [matcherArg] = args;
-            if (!includesCall || matcherArg.type === "SpreadElement" || !equalityMatchers.has(matcherName) || !isBooleanLiteral(matcherArg) || !isFixableIncludesCallExpression(includesCall)) {
+            const [includesCall] = expect.arguments;
+            const { matcher } = call;
+            const [matcherArg] = call.matcherArgs;
+            if (!includesCall || matcherArg.type === "SpreadElement" || !equalityMatchers.has(getStringValue(matcher)) || !isBooleanLiteral(matcherArg) || !isFixableIncludesCallExpression(includesCall)) {
               return;
             }
-            const notModifier = expectCall.modifiers.find(
+            const notModifier = call.modifiers.find(
               (node2) => getStringValue(node2) === "not"
             );
             context.report({
@@ -2484,7 +2668,7 @@ var init_prefer_to_contain = __esm({
                   ),
                   // replace the matcher argument with the value from the "includes"
                   fixer.replaceText(
-                    expectCall.args[0],
+                    call.matcherArgs[0],
                     context.sourceCode.getText(includesCall.arguments[0])
                   )
                 ];
@@ -2528,17 +2712,17 @@ var init_prefer_to_have_count = __esm({
     "use strict";
     init_ast();
     init_fixer();
-    init_parseExpectCall();
+    init_parseFnCall();
     prefer_to_have_count_default = {
       create(context) {
         return {
           CallExpression(node) {
-            const expectCall = parseExpectCall(context, node);
-            if (!expectCall || !equalityMatchers.has(expectCall.matcherName)) {
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect" || !equalityMatchers.has(call.matcherName)) {
               return;
             }
-            const [argument] = node.arguments;
-            if (argument.type !== "AwaitExpression" || argument.argument.type !== "CallExpression" || argument.argument.callee.type !== "MemberExpression" || !isPropertyAccessor(argument.argument.callee, "count")) {
+            const [argument] = call.args;
+            if (argument?.type !== "AwaitExpression" || argument.argument.type !== "CallExpression" || argument.argument.callee.type !== "MemberExpression" || !isPropertyAccessor(argument.argument.callee, "count")) {
               return;
             }
             const callee = argument.argument.callee;
@@ -2556,13 +2740,13 @@ var init_prefer_to_have_count = __esm({
                     argument.argument.range[1]
                   ]),
                   // replace the current matcher with "toHaveCount"
-                  replaceAccessorFixer(fixer, expectCall.matcher, "toHaveCount"),
+                  replaceAccessorFixer(fixer, call.matcher, "toHaveCount"),
                   // insert "await" to before "expect()"
                   fixer.insertTextBefore(node, "await ")
                 ];
               },
               messageId: "useToHaveCount",
-              node: expectCall.matcher
+              node: call.matcher
             });
           }
         };
@@ -2592,16 +2776,16 @@ var init_prefer_to_have_length = __esm({
     "use strict";
     init_ast();
     init_fixer();
-    init_parseExpectCall();
+    init_parseFnCall();
     prefer_to_have_length_default = {
       create(context) {
         return {
           CallExpression(node) {
-            const expectCall = parseExpectCall(context, node);
-            if (!expectCall || !equalityMatchers.has(expectCall.matcherName)) {
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect" || !equalityMatchers.has(call.matcherName)) {
               return;
             }
-            const [argument] = node.arguments;
+            const [argument] = call.args;
             if (argument?.type !== "MemberExpression" || !isPropertyAccessor(argument, "length")) {
               return;
             }
@@ -2614,11 +2798,11 @@ var init_prefer_to_have_length = __esm({
                     argument.range[1]
                   ]),
                   // replace the current matcher with "toHaveLength"
-                  replaceAccessorFixer(fixer, expectCall.matcher, "toHaveLength")
+                  replaceAccessorFixer(fixer, call.matcher, "toHaveLength")
                 ];
               },
               messageId: "useToHaveLength",
-              node: expectCall.matcher
+              node: call.matcher
             });
           }
         };
@@ -2659,7 +2843,7 @@ var init_prefer_web_first_assertions = __esm({
   "src/rules/prefer-web-first-assertions.ts"() {
     "use strict";
     init_ast();
-    init_parseExpectCall();
+    init_parseFnCall();
     methods3 = {
       getAttribute: {
         matcher: "toHaveAttribute",
@@ -2705,24 +2889,26 @@ var init_prefer_web_first_assertions = __esm({
       create(context) {
         return {
           CallExpression(node) {
-            const expectCall = parseExpectCall(context, node);
-            if (!expectCall)
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect")
+              return;
+            const expect = findParent(call.head.node, "CallExpression");
+            if (!expect)
               return;
-            const arg = dereference(context, node.arguments[0]);
+            const arg = dereference(context, call.args[0]);
             if (!arg || arg.type !== "AwaitExpression" || arg.argument.type !== "CallExpression" || arg.argument.callee.type !== "MemberExpression") {
               return;
             }
-            if (!supportedMatchers.has(expectCall.matcherName))
+            if (!supportedMatchers.has(call.matcherName))
               return;
             const method = getStringValue(arg.argument.callee.property);
             const methodConfig = methods3[method];
             if (!methodConfig)
               return;
-            const { args, matcher } = expectCall;
-            const notModifier = expectCall.modifiers.find(
+            const notModifier = call.modifiers.find(
               (mod) => getStringValue(mod) === "not"
             );
-            const isFalsy = methodConfig.type === "boolean" && (!!args.length && isBooleanLiteral(args[0], false) || expectCall.matcherName === "toBeFalsy");
+            const isFalsy = methodConfig.type === "boolean" && (!!call.matcherArgs.length && isBooleanLiteral(call.matcherArgs[0], false) || call.matcherName === "toBeFalsy");
             const isInverse = methodConfig.inverse ? notModifier || isFalsy : notModifier && isFalsy;
             const newMatcher = +!!notModifier ^ +isFalsy && methodConfig.inverse || methodConfig.matcher;
             const { callee } = arg.argument;
@@ -2736,7 +2922,7 @@ var init_prefer_web_first_assertions = __esm({
                 const methodEnd = methodArgs.length ? methodArgs.at(-1).range[1] + 1 : callee.property.range[1] + 2;
                 const fixes = [
                   // Add await to the expect call
-                  fixer.insertTextBefore(node, "await "),
+                  fixer.insertTextBefore(expect, "await "),
                   // Remove the await keyword
                   fixer.replaceTextRange(
                     [arg.range[0], arg.argument.range[0]],
@@ -2753,23 +2939,23 @@ var init_prefer_web_first_assertions = __esm({
                   fixes.push(fixer.removeRange([notRange[0], notRange[1] + 1]));
                 }
                 if (!methodConfig.inverse && !notModifier && isFalsy) {
-                  fixes.push(fixer.insertTextBefore(matcher, "not."));
+                  fixes.push(fixer.insertTextBefore(call.matcher, "not."));
                 }
-                fixes.push(fixer.replaceText(matcher, newMatcher));
-                const [matcherArg] = args ?? [];
+                fixes.push(fixer.replaceText(call.matcher, newMatcher));
+                const [matcherArg] = call.matcherArgs ?? [];
                 if (matcherArg && isBooleanLiteral(matcherArg)) {
                   fixes.push(fixer.remove(matcherArg));
                 } else if (methodConfig.prop && matcherArg) {
                   const propArg = methodConfig.prop;
                   const variable = getStringValue(matcherArg);
-                  const args2 = `{ ${propArg}: ${variable} }`;
-                  fixes.push(fixer.replaceText(matcherArg, args2));
+                  const args = `{ ${propArg}: ${variable} }`;
+                  fixes.push(fixer.replaceText(matcherArg, args));
                 }
                 const hasOtherArgs = !!methodArgs.filter(
                   (arg2) => !isBooleanLiteral(arg2)
                 ).length;
                 if (methodArgs) {
-                  const range = matcher.range;
+                  const range = call.matcher.range;
                   const stringArgs = methodArgs.map((arg2) => getRawValue(arg2)).concat(hasOtherArgs ? "" : []).join(", ");
                   fixes.push(
                     fixer.insertTextAfterRange(
@@ -2781,7 +2967,7 @@ var init_prefer_web_first_assertions = __esm({
                 return fixes;
               },
               messageId: "useWebFirstAssertion",
-              node
+              node: expect
             });
           }
         };
@@ -2809,6 +2995,7 @@ var init_require_hook = __esm({
   "src/rules/require-hook.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     isNullOrUndefined = (node) => {
       return node.type === "Literal" && node.value === null || isIdentifier(node, "undefined");
     };
@@ -2848,7 +3035,7 @@ var init_require_hook = __esm({
         };
         return {
           CallExpression(node) {
-            if (!isDescribeCall(node) || node.arguments.length < 2) {
+            if (!isTypeOfFnCall(context, node, ["describe"]) || node.arguments.length < 2) {
               return;
             }
             const [, testFn] = node.arguments;
@@ -2896,17 +3083,23 @@ var init_require_soft_assertions = __esm({
   "src/rules/require-soft-assertions.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     require_soft_assertions_default = {
       create(context) {
         return {
           CallExpression(node) {
-            if (getExpectType(context, node) === "standalone") {
-              context.report({
-                fix: (fixer) => fixer.insertTextAfter(node.callee, ".soft"),
-                messageId: "requireSoft",
-                node: node.callee
-              });
+            const call = parseFnCall(context, node);
+            if (call?.type !== "expect" || call.modifiers.some((m) => {
+              const name = getStringValue(m);
+              return name === "soft" || name === "poll";
+            })) {
+              return;
             }
+            context.report({
+              fix: (fixer) => fixer.insertTextAfter(call.head.node, ".soft"),
+              messageId: "requireSoft",
+              node: call.head.node
+            });
           }
         };
       },
@@ -2927,13 +3120,54 @@ var init_require_soft_assertions = __esm({
   }
 });
 
+// src/rules/require-to-throw-message.ts
+var require_to_throw_message_default;
+var init_require_to_throw_message = __esm({
+  "src/rules/require-to-throw-message.ts"() {
+    "use strict";
+    init_ast();
+    init_parseFnCall();
+    require_to_throw_message_default = {
+      create(context) {
+        return {
+          CallExpression(node) {
+            const call = parseFnCall(context, node);
+            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 },
+                messageId: "addErrorMessage",
+                node: call.matcher
+              });
+            }
+          }
+        };
+      },
+      meta: {
+        docs: {
+          category: "Best Practices",
+          description: "Require a message for `toThrow()`",
+          recommended: false,
+          url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-to-throw-message.md"
+        },
+        messages: {
+          addErrorMessage: "Add an error message to {{ matcherName }}()"
+        },
+        schema: [],
+        type: "suggestion"
+      }
+    };
+  }
+});
+
 // src/rules/require-top-level-describe.ts
 var require_top_level_describe_default;
 var init_require_top_level_describe = __esm({
   "src/rules/require-top-level-describe.ts"() {
     "use strict";
-    init_ast();
     init_misc();
+    init_parseFnCall();
     require_top_level_describe_default = {
       create(context) {
         const { maxTopLevelDescribes } = {
@@ -2944,7 +3178,10 @@ var init_require_top_level_describe = __esm({
         let describeCount = 0;
         return {
           CallExpression(node) {
-            if (isDescribeCall(node)) {
+            const call = parseFnCall(context, node);
+            if (!call)
+              return;
+            if (call.type === "describe") {
               describeCount++;
               if (describeCount === 1) {
                 topLevelDescribeCount++;
@@ -2957,15 +3194,15 @@ var init_require_top_level_describe = __esm({
                 }
               }
             } else if (!describeCount) {
-              if (isTestCall(context, node)) {
+              if (call.type === "test") {
                 context.report({ messageId: "unexpectedTest", node: node.callee });
-              } else if (isTestHook(context, node)) {
+              } else if (call.type === "hook") {
                 context.report({ messageId: "unexpectedHook", node: node.callee });
               }
             }
           },
           "CallExpression:exit"(node) {
-            if (isDescribeCall(node)) {
+            if (isTypeOfFnCall(context, node, ["describe"])) {
               describeCount--;
             }
           }
@@ -3001,23 +3238,121 @@ var init_require_top_level_describe = __esm({
   }
 });
 
-// src/rules/valid-expect.ts
-function isMatcherCalled(node) {
-  if (node.parent.type !== "MemberExpression") {
-    return {
-      called: node.parent.type === "CallExpression" && node.parent.callee === node,
-      node
+// src/rules/valid-describe-callback.ts
+var paramsLocation, valid_describe_callback_default;
+var init_valid_describe_callback = __esm({
+  "src/rules/valid-describe-callback.ts"() {
+    "use strict";
+    init_ast();
+    init_parseFnCall();
+    paramsLocation = (params) => {
+      const [first] = params;
+      const last = params[params.length - 1];
+      return {
+        end: last.loc.end,
+        start: first.loc.start
+      };
+    };
+    valid_describe_callback_default = {
+      create(context) {
+        return {
+          CallExpression(node) {
+            const call = parseFnCall(context, node);
+            if (call?.type !== "describe")
+              return;
+            if (node.arguments.length < 1) {
+              return context.report({
+                loc: node.loc,
+                messageId: "nameAndCallback"
+              });
+            }
+            const [, callback] = node.arguments;
+            if (!callback) {
+              context.report({
+                loc: paramsLocation(node.arguments),
+                messageId: "nameAndCallback"
+              });
+              return;
+            }
+            if (!isFunction(callback)) {
+              context.report({
+                loc: paramsLocation(node.arguments),
+                messageId: "secondArgumentMustBeFunction"
+              });
+              return;
+            }
+            if (callback.async) {
+              context.report({
+                messageId: "noAsyncDescribeCallback",
+                node: callback
+              });
+            }
+            if (call.members.every((s) => getStringValue(s) !== "each") && callback.params.length) {
+              context.report({
+                loc: paramsLocation(callback.params),
+                messageId: "unexpectedDescribeArgument"
+              });
+            }
+            if (callback.body.type === "CallExpression") {
+              context.report({
+                messageId: "unexpectedReturnInDescribe",
+                node: callback
+              });
+            }
+            if (callback.body.type === "BlockStatement") {
+              callback.body.body.forEach((node2) => {
+                if (node2.type === "ReturnStatement") {
+                  context.report({
+                    messageId: "unexpectedReturnInDescribe",
+                    node: node2
+                  });
+                }
+              });
+            }
+          }
+        };
+      },
+      meta: {
+        docs: {
+          category: "Possible Errors",
+          description: "Enforce valid `describe()` callback",
+          recommended: true,
+          url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-describe-callback.md"
+        },
+        messages: {
+          nameAndCallback: "Describe requires name and callback arguments",
+          noAsyncDescribeCallback: "No async describe callback",
+          secondArgumentMustBeFunction: "Second argument must be function",
+          unexpectedDescribeArgument: "Unexpected argument(s) in describe callback",
+          unexpectedReturnInDescribe: "Unexpected return statement in describe callback"
+        },
+        schema: [],
+        type: "problem"
+      }
     };
   }
-  return isMatcherCalled(node.parent);
-}
-var valid_expect_default;
+});
+
+// src/rules/valid-expect.ts
+var findTopMostMemberExpression, valid_expect_default;
 var init_valid_expect = __esm({
   "src/rules/valid-expect.ts"() {
     "use strict";
     init_ast();
     init_misc();
-    init_parseExpectCall();
+    init_parseFnCall();
+    findTopMostMemberExpression = (node) => {
+      let topMostMemberExpression = node;
+      let parent = getParent(node);
+      while (parent) {
+        if (parent.type !== "MemberExpression") {
+          break;
+        }
+        topMostMemberExpression = parent;
+        parent = parent.parent;
+      }
+      return topMostMemberExpression;
+    };
     valid_expect_default = {
       create(context) {
         const options = {
@@ -3029,32 +3364,70 @@ var init_valid_expect = __esm({
         const maxArgs = Math.max(options.minArgs, options.maxArgs);
         return {
           CallExpression(node) {
-            if (!isExpectCall(context, node))
-              return;
-            const expectCall = parseExpectCall(context, node);
-            if (!expectCall) {
-              context.report({ messageId: "matcherNotFound", node });
-            } else {
-              const result = isMatcherCalled(node);
-              if (!result.called) {
+            const call = parseFnCallWithReason(context, node);
+            if (typeof call === "string") {
+              const reportingNode = node.parent?.type === "MemberExpression" ? findTopMostMemberExpression(node.parent).property : node;
+              if (call === "matcher-not-found") {
                 context.report({
-                  messageId: "matcherNotCalled",
-                  node: result.node.type === "MemberExpression" ? result.node.property : result.node
+                  messageId: "matcherNotFound",
+                  node: reportingNode
                 });
+                return;
               }
+              if (call === "matcher-not-called") {
+                context.report({
+                  messageId: isSupportedAccessor(reportingNode) && modifiers.has(getStringValue(reportingNode)) ? "matcherNotFound" : "matcherNotCalled",
+                  node: reportingNode
+                });
+              }
+              if (call === "modifier-unknown") {
+                context.report({
+                  messageId: "modifierUnknown",
+                  node: reportingNode
+                });
+                return;
+              }
+              return;
+            } else if (call?.type !== "expect") {
+              return;
             }
-            if (node.arguments.length < minArgs) {
+            const expect = findParent(call.head.node, "CallExpression");
+            if (!expect)
+              return;
+            if (expect.arguments.length < minArgs) {
+              const expectLength = getStringValue(call.head.node).length;
+              const loc = {
+                end: {
+                  column: expect.loc.start.column + expectLength + 1,
+                  line: expect.loc.start.line
+                },
+                start: {
+                  column: expect.loc.start.column + expectLength,
+                  line: expect.loc.start.line
+                }
+              };
               context.report({
                 data: getAmountData(minArgs),
+                loc,
                 messageId: "notEnoughArgs",
-                node
+                node: expect
               });
             }
-            if (node.arguments.length > maxArgs) {
+            if (expect.arguments.length > maxArgs) {
+              const { start } = expect.arguments[maxArgs].loc;
+              const { end } = expect.arguments.at(-1).loc;
+              const loc = {
+                end: {
+                  column: end.column,
+                  line: end.line
+                },
+                start
+              };
               context.report({
                 data: getAmountData(maxArgs),
+                loc,
                 messageId: "tooManyArgs",
-                node
+                node: expect
               });
             }
           }
@@ -3095,12 +3468,265 @@ var init_valid_expect = __esm({
   }
 });
 
+// src/rules/valid-expect-in-promise.ts
+var isPromiseChainCall, isTestCaseCallWithCallbackArg, isPromiseMethodThatUsesValue, isValueAwaitedInElements, isValueAwaitedInArguments, getLeftMostCallExpression, isValueAwaitedOrReturned, findFirstBlockBodyUp, isDirectlyWithinTestCaseCall, isVariableAwaitedOrReturned, valid_expect_in_promise_default;
+var init_valid_expect_in_promise = __esm({
+  "src/rules/valid-expect-in-promise.ts"() {
+    "use strict";
+    init_ast();
+    init_parseFnCall();
+    isPromiseChainCall = (node) => {
+      if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && isSupportedAccessor(node.callee.property)) {
+        if (node.arguments.length === 0) {
+          return false;
+        }
+        switch (getStringValue(node.callee.property)) {
+          case "then":
+            return node.arguments.length < 3;
+          case "catch":
+          case "finally":
+            return node.arguments.length < 2;
+        }
+      }
+      return false;
+    };
+    isTestCaseCallWithCallbackArg = (context, node) => {
+      const jestCallFn = parseFnCall(context, node);
+      if (jestCallFn?.type !== "test") {
+        return false;
+      }
+      const isJestEach = jestCallFn.members.some(
+        (s) => getStringValue(s) === "each"
+      );
+      if (isJestEach && node.callee.type !== "TaggedTemplateExpression") {
+        return true;
+      }
+      const [, callback] = node.arguments;
+      const callbackArgIndex = Number(isJestEach);
+      return callback && isFunction(callback) && callback.params.length === 1 + callbackArgIndex;
+    };
+    isPromiseMethodThatUsesValue = (node, identifier) => {
+      const name = getStringValue(identifier);
+      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)) {
+          const [firstArg] = node.argument.arguments;
+          if (firstArg.type === "ArrayExpression" && firstArg.elements.some((nod) => nod && isIdentifier(nod, name))) {
+            return true;
+          }
+        }
+        if (["Promise.resolve", "Promise.reject"].includes(nodeName) && node.argument.arguments.length === 1) {
+          return isIdentifier(node.argument.arguments[0], name);
+        }
+      }
+      return isIdentifier(node.argument, name);
+    };
+    isValueAwaitedInElements = (name, elements) => {
+      for (const element of elements) {
+        if (element?.type === "AwaitExpression" && isIdentifier(element.argument, name)) {
+          return true;
+        }
+        if (element?.type === "ArrayExpression" && isValueAwaitedInElements(name, element.elements)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    isValueAwaitedInArguments = (name, call) => {
+      let node = call;
+      while (node) {
+        if (node.type === "CallExpression") {
+          if (isValueAwaitedInElements(name, node.arguments)) {
+            return true;
+          }
+          node = node.callee;
+        }
+        if (node.type !== "MemberExpression") {
+          break;
+        }
+        node = node.object;
+      }
+      return false;
+    };
+    getLeftMostCallExpression = (call) => {
+      let leftMostCallExpression = call;
+      let node = call;
+      while (node) {
+        if (node.type === "CallExpression") {
+          leftMostCallExpression = node;
+          node = node.callee;
+        }
+        if (node.type !== "MemberExpression") {
+          break;
+        }
+        node = node.object;
+      }
+      return leftMostCallExpression;
+    };
+    isValueAwaitedOrReturned = (context, identifier, body) => {
+      const name = getStringValue(identifier);
+      for (const node of body) {
+        if (node.range[0] <= identifier.range[0]) {
+          continue;
+        }
+        if (node.type === "ReturnStatement") {
+          return isPromiseMethodThatUsesValue(node, identifier);
+        }
+        if (node.type === "ExpressionStatement") {
+          if (node.expression.type === "CallExpression") {
+            if (isValueAwaitedInArguments(name, node.expression)) {
+              return true;
+            }
+            const leftMostCall = getLeftMostCallExpression(node.expression);
+            const call = parseFnCall(context, node.expression);
+            if (call?.type === "expect" && leftMostCall.arguments.length > 0 && isIdentifier(leftMostCall.arguments[0], name)) {
+              if (call.members.some((m) => {
+                const v = getStringValue(m);
+                return v === "resolves" || v === "rejects";
+              })) {
+                return true;
+              }
+            }
+          }
+          if (node.expression.type === "AwaitExpression" && isPromiseMethodThatUsesValue(node.expression, identifier)) {
+            return true;
+          }
+          if (node.expression.type === "AssignmentExpression") {
+            if (isIdentifier(node.expression.left, name) && getNodeName(node.expression.right)?.startsWith(`${name}.`) && isPromiseChainCall(node.expression.right)) {
+              continue;
+            }
+            break;
+          }
+        }
+        if (node.type === "BlockStatement" && isValueAwaitedOrReturned(context, identifier, node.body)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    findFirstBlockBodyUp = (node) => {
+      let parent = node;
+      while (parent) {
+        if (parent.type === "BlockStatement") {
+          return parent.body;
+        }
+        parent = getParent(parent);
+      }
+      throw new Error(
+        `Could not find BlockStatement - please file a github issue at https://github.com/playwright-community/eslint-plugin-playwright`
+      );
+    };
+    isDirectlyWithinTestCaseCall = (context, node) => {
+      let parent = node;
+      while (parent) {
+        if (isFunction(parent)) {
+          parent = parent.parent;
+          return parent?.type === "CallExpression" && isTypeOfFnCall(context, parent, ["test"]);
+        }
+        parent = getParent(parent);
+      }
+      return false;
+    };
+    isVariableAwaitedOrReturned = (context, variable) => {
+      const body = findFirstBlockBodyUp(variable);
+      if (!isIdentifier(variable.id)) {
+        return true;
+      }
+      return isValueAwaitedOrReturned(context, variable.id, body);
+    };
+    valid_expect_in_promise_default = {
+      create(context) {
+        let inTestCaseWithDoneCallback = false;
+        const chains = [];
+        return {
+          CallExpression(node) {
+            if (isTestCaseCallWithCallbackArg(context, node)) {
+              inTestCaseWithDoneCallback = true;
+              return;
+            }
+            if (isPromiseChainCall(node)) {
+              chains.unshift(false);
+              return;
+            }
+            if (chains.length > 0 && isTypeOfFnCall(context, node, ["expect"])) {
+              chains[0] = true;
+            }
+          },
+          "CallExpression:exit"(node) {
+            if (inTestCaseWithDoneCallback) {
+              if (isTypeOfFnCall(context, node, ["test"])) {
+                inTestCaseWithDoneCallback = false;
+              }
+              return;
+            }
+            if (!isPromiseChainCall(node)) {
+              return;
+            }
+            const hasExpectCall = chains.shift();
+            if (!hasExpectCall) {
+              return;
+            }
+            const { parent } = findTopMostCallExpression(node);
+            if (!parent || !isDirectlyWithinTestCaseCall(context, parent)) {
+              return;
+            }
+            switch (parent.type) {
+              case "VariableDeclarator": {
+                if (isVariableAwaitedOrReturned(context, parent)) {
+                  return;
+                }
+                break;
+              }
+              case "AssignmentExpression": {
+                if (parent.left.type === "Identifier" && isValueAwaitedOrReturned(
+                  context,
+                  parent.left,
+                  findFirstBlockBodyUp(parent)
+                )) {
+                  return;
+                }
+                break;
+              }
+              case "ExpressionStatement":
+                break;
+              case "ReturnStatement":
+              case "AwaitExpression":
+              default:
+                return;
+            }
+            context.report({
+              messageId: "expectInFloatingPromise",
+              node: parent
+            });
+          }
+        };
+      },
+      meta: {
+        docs: {
+          category: "Best Practices",
+          description: "Require promises that have expectations in their chain to be valid",
+          recommended: true,
+          url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-expect-in-promise.md"
+        },
+        messages: {
+          expectInFloatingPromise: "This promise should either be returned or awaited to ensure the expects in its chain are called"
+        },
+        schema: [],
+        type: "suggestion"
+      }
+    };
+  }
+});
+
 // src/rules/valid-title.ts
 var doesBinaryExpressionContainStringNode, quoteStringValue, compileMatcherPattern, compileMatcherPatterns, MatcherAndMessageSchema, valid_title_default;
 var init_valid_title = __esm({
   "src/rules/valid-title.ts"() {
     "use strict";
     init_ast();
+    init_parseFnCall();
     doesBinaryExpressionContainStringNode = (binaryExp) => {
       if (isStringNode(binaryExp.right)) {
         return true;
@@ -3154,9 +3780,8 @@ var init_valid_title = __esm({
         const mustMatchPatterns = compileMatcherPatterns(mustMatch ?? {});
         return {
           CallExpression(node) {
-            const isDescribe = isDescribeCall(node);
-            const isTest = isTestCall(context, node);
-            if (!isDescribe && !isTest) {
+            const call = parseFnCall(context, node);
+            if (call?.type !== "test" && call?.type !== "describe") {
               return;
             }
             const [argument] = node.arguments;
@@ -3167,7 +3792,7 @@ var init_valid_title = __esm({
               if (argument.type === "BinaryExpression" && doesBinaryExpressionContainStringNode(argument)) {
                 return;
               }
-              if (!(isDescribe && ignoreTypeOfDescribeName || isTest && ignoreTypeOfTestName) && argument.type !== "TemplateLiteral") {
+              if (!(call.type === "describe" && ignoreTypeOfDescribeName || call.type === "test" && ignoreTypeOfTestName) && argument.type !== "TemplateLiteral") {
                 context.report({
                   loc: argument.loc,
                   messageId: "titleMustBeString"
@@ -3176,10 +3801,10 @@ var init_valid_title = __esm({
               return;
             }
             const title = getStringValue(argument);
-            const functionName = isDescribe ? "describe" : "test";
+            const functionName = call.type;
             if (!title) {
               context.report({
-                data: { functionName },
+                data: { functionName: call.type },
                 messageId: "emptyTitle",
                 node
               });
@@ -3358,8 +3983,11 @@ var require_src = __commonJS({
     init_prefer_web_first_assertions();
     init_require_hook();
     init_require_soft_assertions();
+    init_require_to_throw_message();
     init_require_top_level_describe();
+    init_valid_describe_callback();
     init_valid_expect();
+    init_valid_expect_in_promise();
     init_valid_title();
     var index = {
       configs: {},
@@ -3404,8 +4032,11 @@ var require_src = __commonJS({
         "prefer-web-first-assertions": prefer_web_first_assertions_default,
         "require-hook": require_hook_default,
         "require-soft-assertions": require_soft_assertions_default,
+        "require-to-throw-message": require_to_throw_message_default,
         "require-top-level-describe": require_top_level_describe_default,
+        "valid-describe-callback": valid_describe_callback_default,
         "valid-expect": valid_expect_default,
+        "valid-expect-in-promise": valid_expect_in_promise_default,
         "valid-title": valid_title_default
       }
     };
@@ -3432,7 +4063,9 @@ var require_src = __commonJS({
         "playwright/no-wait-for-selector": "warn",
         "playwright/no-wait-for-timeout": "warn",
         "playwright/prefer-web-first-assertions": "error",
+        "playwright/valid-describe-callback": "error",
         "playwright/valid-expect": "error",
+        "playwright/valid-expect-in-promise": "error",
         "playwright/valid-title": "error"
       }
     };