eslint-plugin-playwright 1.1.2 → 1.3.0

package/dist/index.js

@@ -54,9 +54,12 @@ function isStringNode(node) {
 function isPropertyAccessor(node, name) {
   return getStringValue(node.property) === name;
 }
-function isTestIdentifier(context, node) {
+function getTestNames(context) {
   const aliases = context.settings.playwright?.globalAliases?.test ?? [];
-  const testNames = ["test", ...aliases];
+  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);
 }
@@ -86,14 +89,34 @@ function findParent(node, type) {
   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 && ["ArrowFunctionExpression", "FunctionExpression"].includes(
-    node.arguments[1].type
-  );
+  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]);
 }
 var testHooks = /* @__PURE__ */ new Set(["afterAll", "afterEach", "beforeAll", "beforeEach"]);
 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"
+    };
+  }
+}
 var expectSubCommands = /* @__PURE__ */ new Set(["soft", "poll"]);
 function getExpectType(context, node) {
   const aliases = context.settings.playwright?.globalAliases?.expect ?? [];
@@ -129,6 +152,7 @@ function isPageMethod(node, name) {
 function isFunction(node) {
   return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
 }
+var equalityMatchers = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 
 // src/rules/expect-expect.ts
 function isAssertionCall(context, node, assertFunctionNames) {
@@ -192,6 +216,69 @@ var expect_expect_default = {
   }
 };
 
+// src/rules/max-expects.ts
+var max_expects_default = {
+  create(context) {
+    const options = {
+      max: 5,
+      ...context.options?.[0] ?? {}
+    };
+    let count = 0;
+    const maybeResetCount = (node) => {
+      const parent = getParent(node);
+      const isTestFn = parent?.type !== "CallExpression" || isTestCall(context, parent);
+      if (isTestFn) {
+        count = 0;
+      }
+    };
+    return {
+      ArrowFunctionExpression: maybeResetCount,
+      "ArrowFunctionExpression:exit": maybeResetCount,
+      CallExpression(node) {
+        if (!getExpectType(context, node))
+          return;
+        count += 1;
+        if (count > options.max) {
+          context.report({
+            data: {
+              count: count.toString(),
+              max: options.max.toString()
+            },
+            messageId: "exceededMaxAssertion",
+            node
+          });
+        }
+      },
+      FunctionExpression: maybeResetCount,
+      "FunctionExpression:exit": maybeResetCount
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Enforces a maximum number assertion calls in a test body",
+      recommended: false,
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/max-expects.md"
+    },
+    messages: {
+      exceededMaxAssertion: "Too many assertion calls ({{ count }}) - maximum allowed is {{ max }}"
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          max: {
+            minimum: 1,
+            type: "integer"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  }
+};
+
 // src/rules/max-nested-describe.ts
 var max_nested_describe_default = {
   create(context) {
@@ -399,6 +486,132 @@ var missing_playwright_await_default = {
   }
 };
 
+// src/rules/no-commented-out-tests.ts
+function hasTests(context, node) {
+  const testNames = getTestNames(context);
+  const names = testNames.join("|");
+  const regex = new RegExp(
+    `^\\s*(${names}|describe)(\\.\\w+|\\[['"]\\w+['"]\\])?\\s*\\(`,
+    "mu"
+  );
+  return regex.test(node.value);
+}
+var no_commented_out_tests_default = {
+  create(context) {
+    function checkNode(node) {
+      if (!hasTests(context, node))
+        return;
+      context.report({
+        messageId: "commentedTests",
+        node
+      });
+    }
+    return {
+      Program() {
+        context.sourceCode.getAllComments().forEach(checkNode);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Disallow commented out tests",
+      recommended: true,
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-commented-out-tests.md"
+    },
+    messages: {
+      commentedTests: "Some tests seem to be commented"
+    },
+    type: "problem"
+  }
+};
+
+// 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 }) => getParent(identifier)).filter(
+        (node) => node?.type === "CallExpression" && isTestCall(context, node)
+      )
+    ],
+    []
+  );
+};
+var no_conditional_expect_default = {
+  create(context) {
+    let conditionalDepth = 0;
+    let inTestCase = false;
+    let inPromiseCatch = false;
+    const increaseConditionalDepth = () => inTestCase && conditionalDepth++;
+    const decreaseConditionalDepth = () => inTestCase && conditionalDepth--;
+    return {
+      CallExpression(node) {
+        if (isTestCall(context, node)) {
+          inTestCase = true;
+        }
+        if (isCatchCall(node)) {
+          inPromiseCatch = true;
+        }
+        const expectType = getExpectType(context, node);
+        if (inTestCase && expectType && conditionalDepth > 0) {
+          context.report({
+            messageId: "conditionalExpect",
+            node
+          });
+        }
+        if (inPromiseCatch && expectType) {
+          context.report({
+            messageId: "conditionalExpect",
+            node
+          });
+        }
+      },
+      "CallExpression:exit"(node) {
+        if (isTestCall(context, node)) {
+          inTestCase = false;
+        }
+        if (isCatchCall(node)) {
+          inPromiseCatch = false;
+        }
+      },
+      CatchClause: increaseConditionalDepth,
+      "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,
+      "LogicalExpression:exit": decreaseConditionalDepth,
+      SwitchStatement: increaseConditionalDepth,
+      "SwitchStatement:exit": decreaseConditionalDepth
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Disallow calling `expect` conditionally",
+      recommended: true,
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-expect.md"
+    },
+    messages: {
+      conditionalExpect: "Avoid calling `expect` conditionally`"
+    },
+    type: "problem"
+  }
+};
+
 // src/rules/no-conditional-in-test.ts
 var no_conditional_in_test_default = {
   create(context) {
@@ -430,6 +643,51 @@ var no_conditional_in_test_default = {
   }
 };
 
+// src/rules/no-duplicate-hooks.ts
+var no_duplicate_hooks_default = {
+  create(context) {
+    const hookContexts = [{}];
+    return {
+      CallExpression(node) {
+        if (isDescribeCall(node)) {
+          hookContexts.push({});
+        }
+        if (!isTestHook(context, node)) {
+          return;
+        }
+        const currentLayer = hookContexts[hookContexts.length - 1];
+        const name = node.callee.type === "MemberExpression" ? getStringValue(node.callee.property) : "";
+        currentLayer[name] || (currentLayer[name] = 0);
+        currentLayer[name] += 1;
+        if (currentLayer[name] > 1) {
+          context.report({
+            data: { hook: name },
+            messageId: "noDuplicateHook",
+            node
+          });
+        }
+      },
+      "CallExpression:exit"(node) {
+        if (isDescribeCall(node)) {
+          hookContexts.pop();
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Disallow duplicate setup and teardown hooks",
+      recommended: false,
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-duplicate-hooks.md"
+    },
+    messages: {
+      noDuplicateHook: "Duplicate {{ hook }} in describe block"
+    },
+    type: "suggestion"
+  }
+};
+
 // src/rules/no-element-handle.ts
 function getPropertyRange(node) {
   return node.type === "Identifier" ? node.range : [node.range[0] + 1, node.range[1] - 1];
@@ -630,6 +888,52 @@ var no_get_by_title_default = {
   }
 };
 
+// src/rules/no-hooks.ts
+var no_hooks_default = {
+  create(context) {
+    const options = {
+      allow: [],
+      ...context.options?.[0] ?? {}
+    };
+    return {
+      CallExpression(node) {
+        const call = parseFnCall(context, node);
+        if (call?.type === "hook" && !options.allow.includes(call.name)) {
+          context.report({
+            data: { hookName: call.name },
+            messageId: "unexpectedHook",
+            node
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Disallow setup and teardown hooks",
+      recommended: false,
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-hooks.md"
+    },
+    messages: {
+      unexpectedHook: "Unexpected '{{ hookName }}' hook"
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allow: {
+            contains: ["beforeAll", "beforeEach", "afterAll", "afterEach"],
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  }
+};
+
 // src/rules/no-nested-step.ts
 function isStepCall(node) {
   const inner = node.type === "CallExpression" ? node.callee : node;
@@ -997,6 +1301,95 @@ var no_skipped_test_default = {
   }
 };
 
+// src/rules/no-standalone-expect.ts
+var getBlockType = (statement) => {
+  const func = getParent(statement);
+  if (!func) {
+    throw new Error(
+      `Unexpected BlockStatement. No parent defined. - please file a github issue at https://github.com/playwright-community/eslint-plugin-playwright`
+    );
+  }
+  if (func.type === "FunctionDeclaration") {
+    return "function";
+  }
+  if (isFunction(func) && func.parent) {
+    const expr = func.parent;
+    if (expr.type === "VariableDeclarator" || expr.type === "MethodDefinition") {
+      return "function";
+    }
+    if (expr.type === "CallExpression" && isDescribeCall(expr)) {
+      return "describe";
+    }
+  }
+  return null;
+};
+var no_standalone_expect_default = {
+  create(context) {
+    const callStack = [];
+    return {
+      ArrowFunctionExpression(node) {
+        if (node.parent?.type !== "CallExpression") {
+          callStack.push("arrow");
+        }
+      },
+      "ArrowFunctionExpression:exit"() {
+        if (callStack[callStack.length - 1] === "arrow") {
+          callStack.pop();
+        }
+      },
+      BlockStatement(statement) {
+        const blockType = getBlockType(statement);
+        if (blockType) {
+          callStack.push(blockType);
+        }
+      },
+      "BlockStatement:exit"(statement) {
+        if (callStack[callStack.length - 1] === getBlockType(statement)) {
+          callStack.pop();
+        }
+      },
+      CallExpression(node) {
+        if (getExpectType(context, node)) {
+          const parent = callStack.at(-1);
+          if (!parent || parent === "describe") {
+            const root = findParent(node, "CallExpression");
+            context.report({
+              messageId: "unexpectedExpect",
+              node: root ?? node
+            });
+          }
+          return;
+        }
+        if (isTestCall(context, node)) {
+          callStack.push("test");
+        }
+        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") {
+          callStack.pop();
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Disallow using `expect` outside of `test` blocks",
+      recommended: false,
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-standalone-expect.md"
+    },
+    fixable: "code",
+    messages: {
+      unexpectedExpect: "Expect must be inside of a test block"
+    },
+    type: "suggestion"
+  }
+};
+
 // src/utils/misc.ts
 var getAmountData = (amount) => ({
   amount: amount.toString(),
@@ -1319,6 +1712,258 @@ var no_wait_for_timeout_default = {
   }
 };
 
+// src/rules/prefer-comparison-matcher.ts
+var isString = (node) => {
+  return isStringLiteral(node) || node.type === "TemplateLiteral";
+};
+var isComparingToString = (expression) => {
+  return isString(expression.left) || isString(expression.right);
+};
+var invertedOperators = {
+  "<": ">=",
+  "<=": ">",
+  ">": "<=",
+  ">=": "<"
+};
+var operatorMatcher = {
+  "<": "toBeLessThan",
+  "<=": "toBeLessThanOrEqual",
+  ">": "toBeGreaterThan",
+  ">=": "toBeGreaterThanOrEqual"
+};
+var determineMatcher = (operator, negated) => {
+  const op = negated ? invertedOperators[operator] : operator;
+  return operatorMatcher[op] ?? null;
+};
+var prefer_comparison_matcher_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        const expectCall = parseExpectCall(context, node);
+        if (!expectCall || expectCall.args.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)) {
+          return;
+        }
+        const hasNot = expectCall.modifiers.some(
+          (node2) => getStringValue(node2) === "not"
+        );
+        const preferredMatcher = determineMatcher(
+          comparison.operator,
+          getRawValue(matcherArg) === hasNot.toString()
+        );
+        if (!preferredMatcher) {
+          return;
+        }
+        context.report({
+          data: { preferredMatcher },
+          fix(fixer) {
+            const [modifier] = expectCall.modifiers;
+            const modifierText = modifier && getStringValue(modifier) !== "not" ? `.${getStringValue(modifier)}` : "";
+            return [
+              // Replace the comparison argument with the left-hand side of the comparison
+              fixer.replaceText(
+                comparison,
+                context.sourceCode.getText(comparison.left)
+              ),
+              // Replace the current matcher & modifier with the preferred matcher
+              fixer.replaceTextRange(
+                [expectCallEnd, getParent(matcher).range[1]],
+                `${modifierText}.${preferredMatcher}`
+              ),
+              // Replace the matcher argument with the right-hand side of the comparison
+              fixer.replaceText(
+                matcherArg,
+                context.sourceCode.getText(comparison.right)
+              )
+            ];
+          },
+          messageId: "useToBeComparison",
+          node: matcher
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Suggest using the built-in comparison matchers",
+      recommended: false
+    },
+    fixable: "code",
+    messages: {
+      useToBeComparison: "Prefer using `{{ preferredMatcher }}` instead"
+    },
+    type: "suggestion"
+  }
+};
+
+// src/rules/prefer-equality-matcher.ts
+var prefer_equality_matcher_default = {
+  create(context) {
+    return {
+      CallExpression(node) {
+        const expectCall = parseExpectCall(context, node);
+        if (!expectCall || expectCall.args.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)) {
+          return;
+        }
+        const matcherValue = getRawValue(matcherArg) === "true";
+        const [modifier] = expectCall.modifiers;
+        const hasNot = expectCall.modifiers.some(
+          (node2) => getStringValue(node2) === "not"
+        );
+        const addNotModifier = (comparison.operator === "!==" ? !matcherValue : matcherValue) === hasNot;
+        context.report({
+          messageId: "useEqualityMatcher",
+          node: matcher,
+          suggest: [...equalityMatchers.keys()].map((equalityMatcher) => ({
+            data: { matcher: equalityMatcher },
+            fix(fixer) {
+              let modifierText = modifier && getStringValue(modifier) !== "not" ? `.${getStringValue(modifier)}` : "";
+              if (addNotModifier) {
+                modifierText += `.not`;
+              }
+              return [
+                // replace the comparison argument with the left-hand side of the comparison
+                fixer.replaceText(
+                  comparison,
+                  context.sourceCode.getText(comparison.left)
+                ),
+                // replace the current matcher & modifier with the preferred matcher
+                fixer.replaceTextRange(
+                  [expectCallEnd, getParent(matcher).range[1]],
+                  `${modifierText}.${equalityMatcher}`
+                ),
+                // replace the matcher argument with the right-hand side of the comparison
+                fixer.replaceText(
+                  matcherArg,
+                  context.sourceCode.getText(comparison.right)
+                )
+              ];
+            },
+            messageId: "suggestEqualityMatcher"
+          }))
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Suggest using the built-in equality matchers",
+      recommended: false,
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-equality-matcher.md"
+    },
+    hasSuggestions: true,
+    messages: {
+      suggestEqualityMatcher: "Use `{{ matcher }}`",
+      useEqualityMatcher: "Prefer using one of the equality matchers instead"
+    },
+    type: "suggestion"
+  }
+};
+
+// src/rules/prefer-hooks-in-order.ts
+var HooksOrder = ["beforeAll", "beforeEach", "afterEach", "afterAll"];
+var prefer_hooks_in_order_default = {
+  create(context) {
+    let previousHookIndex = -1;
+    let inHook = false;
+    return {
+      CallExpression(node) {
+        if (inHook)
+          return;
+        if (!isTestHook(context, node)) {
+          previousHookIndex = -1;
+          return;
+        }
+        inHook = true;
+        const currentHook = node.callee.type === "MemberExpression" ? getStringValue(node.callee.property) : "";
+        const currentHookIndex = HooksOrder.indexOf(currentHook);
+        if (currentHookIndex < previousHookIndex) {
+          return context.report({
+            data: {
+              currentHook,
+              previousHook: HooksOrder[previousHookIndex]
+            },
+            messageId: "reorderHooks",
+            node
+          });
+        }
+        previousHookIndex = currentHookIndex;
+      },
+      "CallExpression:exit"(node) {
+        if (isTestHook(context, node)) {
+          inHook = false;
+          return;
+        }
+        if (inHook) {
+          return;
+        }
+        previousHookIndex = -1;
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Prefer having hooks in a consistent order",
+      recommended: false,
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-in-order.md"
+    },
+    messages: {
+      reorderHooks: "`{{ currentHook }}` hooks should be before any `{{ previousHook }}` hooks"
+    },
+    type: "suggestion"
+  }
+};
+
+// src/rules/prefer-hooks-on-top.ts
+var prefer_hooks_on_top_default = {
+  create(context) {
+    const stack = [false];
+    return {
+      CallExpression(node) {
+        if (isTestCall(context, node)) {
+          stack[stack.length - 1] = true;
+        }
+        if (stack.at(-1) && isTestHook(context, node)) {
+          context.report({
+            messageId: "noHookOnTop",
+            node
+          });
+        }
+        stack.push(false);
+      },
+      "CallExpression:exit"() {
+        stack.pop();
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Suggest having hooks before any test cases",
+      recommended: false,
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-on-top.md"
+    },
+    messages: {
+      noHookOnTop: "Hooks should come before test cases"
+    },
+    type: "suggestion"
+  }
+};
+
 // src/rules/prefer-lowercase-title.ts
 var prefer_lowercase_title_default = {
   create(context) {
@@ -1506,9 +2151,8 @@ var prefer_to_be_default = {
             notModifier
           );
         }
-        const argumentMatchers = ["toBe", "toEqual", "toStrictEqual"];
         const firstArg = expectCall.args[0];
-        if (!argumentMatchers.includes(expectCall.matcherName) || !firstArg) {
+        if (!equalityMatchers.has(expectCall.matcherName) || !firstArg) {
           return;
         }
         if (firstArg.type === "Literal" && firstArg.value === null) {
@@ -1548,7 +2192,6 @@ var prefer_to_be_default = {
 };
 
 // src/rules/prefer-to-contain.ts
-var matchers = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var isFixableIncludesCallExpression = (node) => node.type === "CallExpression" && node.callee.type === "MemberExpression" && isPropertyAccessor(node.callee, "includes") && node.arguments.length === 1 && node.arguments[0].type !== "SpreadElement";
 var prefer_to_contain_default = {
   create(context) {
@@ -1560,7 +2203,7 @@ var prefer_to_contain_default = {
         const { args, matcher, matcherName } = expectCall;
         const [includesCall] = node.arguments;
         const [matcherArg] = args;
-        if (!includesCall || matcherArg.type === "SpreadElement" || !matchers.has(matcherName) || !isBooleanLiteral(matcherArg) || !isFixableIncludesCallExpression(includesCall)) {
+        if (!includesCall || matcherArg.type === "SpreadElement" || !equalityMatchers.has(matcherName) || !isBooleanLiteral(matcherArg) || !isFixableIncludesCallExpression(includesCall)) {
           return;
         }
         const notModifier = expectCall.modifiers.find(
@@ -1618,13 +2261,12 @@ var prefer_to_contain_default = {
 };
 
 // src/rules/prefer-to-have-count.ts
-var matchers2 = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var prefer_to_have_count_default = {
   create(context) {
     return {
       CallExpression(node) {
         const expectCall = parseExpectCall(context, node);
-        if (!expectCall || !matchers2.has(expectCall.matcherName)) {
+        if (!expectCall || !equalityMatchers.has(expectCall.matcherName)) {
           return;
         }
         const [argument] = node.arguments;
@@ -1674,13 +2316,12 @@ var prefer_to_have_count_default = {
 };
 
 // src/rules/prefer-to-have-length.ts
-var lengthMatchers = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var prefer_to_have_length_default = {
   create(context) {
     return {
       CallExpression(node) {
         const expectCall = parseExpectCall(context, node);
-        if (!expectCall || !lengthMatchers.has(expectCall.matcherName)) {
+        if (!expectCall || !equalityMatchers.has(expectCall.matcherName)) {
           return;
         }
         const [argument] = node.arguments;
@@ -1875,6 +2516,86 @@ var prefer_web_first_assertions_default = {
   }
 };
 
+// src/rules/require-hook.ts
+var isNullOrUndefined = (node) => {
+  return node.type === "Literal" && node.value === null || isIdentifier(node, "undefined");
+};
+var shouldBeInHook = (context, node, allowedFunctionCalls = []) => {
+  switch (node.type) {
+    case "ExpressionStatement":
+      return shouldBeInHook(context, node.expression, allowedFunctionCalls);
+    case "CallExpression":
+      return !(parseFnCall(context, node) || allowedFunctionCalls.includes(getStringValue(node.callee)));
+    case "VariableDeclaration": {
+      if (node.kind === "const") {
+        return false;
+      }
+      return node.declarations.some(
+        ({ init }) => init != null && !isNullOrUndefined(init)
+      );
+    }
+    default:
+      return false;
+  }
+};
+var require_hook_default = {
+  create(context) {
+    const options = {
+      allowedFunctionCalls: [],
+      ...context.options?.[0] ?? {}
+    };
+    const checkBlockBody = (body) => {
+      for (const statement of body) {
+        if (shouldBeInHook(context, statement, options.allowedFunctionCalls)) {
+          context.report({
+            messageId: "useHook",
+            node: statement
+          });
+        }
+      }
+    };
+    return {
+      CallExpression(node) {
+        if (!isDescribeCall(node) || node.arguments.length < 2) {
+          return;
+        }
+        const [, testFn] = node.arguments;
+        if (!isFunction(testFn) || testFn.body.type !== "BlockStatement") {
+          return;
+        }
+        checkBlockBody(testFn.body.body);
+      },
+      Program(program) {
+        checkBlockBody(program.body);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Require setup and teardown code to be within a hook",
+      recommended: false,
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-hook.md"
+    },
+    messages: {
+      useHook: "This should be done within a hook"
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowedFunctionCalls: {
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  }
+};
+
 // src/rules/require-soft-assertions.ts
 var require_soft_assertions_default = {
   create(context) {
@@ -2071,17 +2792,17 @@ var compileMatcherPattern = (matcherMaybeWithMessage) => {
   const [matcher, message] = Array.isArray(matcherMaybeWithMessage) ? matcherMaybeWithMessage : [matcherMaybeWithMessage];
   return [new RegExp(matcher, "u"), message];
 };
-var compileMatcherPatterns = (matchers3) => {
-  if (typeof matchers3 === "string" || Array.isArray(matchers3)) {
-    const compiledMatcher = compileMatcherPattern(matchers3);
+var compileMatcherPatterns = (matchers) => {
+  if (typeof matchers === "string" || Array.isArray(matchers)) {
+    const compiledMatcher = compileMatcherPattern(matchers);
     return {
       describe: compiledMatcher,
       test: compiledMatcher
     };
   }
   return {
-    describe: matchers3.describe ? compileMatcherPattern(matchers3.describe) : null,
-    test: matchers3.test ? compileMatcherPattern(matchers3.test) : null
+    describe: matchers.describe ? compileMatcherPattern(matchers.describe) : null,
+    test: matchers.test ? compileMatcherPattern(matchers.test) : null
   };
 };
 var MatcherAndMessageSchema = {
@@ -2273,14 +2994,19 @@ var index = {
   configs: {},
   rules: {
     "expect-expect": expect_expect_default,
+    "max-expects": max_expects_default,
     "max-nested-describe": max_nested_describe_default,
     "missing-playwright-await": missing_playwright_await_default,
+    "no-commented-out-tests": no_commented_out_tests_default,
+    "no-conditional-expect": no_conditional_expect_default,
     "no-conditional-in-test": no_conditional_in_test_default,
+    "no-duplicate-hooks": no_duplicate_hooks_default,
     "no-element-handle": no_element_handle_default,
     "no-eval": no_eval_default,
     "no-focused-test": no_focused_test_default,
     "no-force-option": no_force_option_default,
     "no-get-by-title": no_get_by_title_default,
+    "no-hooks": no_hooks_default,
     "no-nested-step": no_nested_step_default,
     "no-networkidle": no_networkidle_default,
     "no-nth-methods": no_nth_methods_default,
@@ -2288,11 +3014,16 @@ var index = {
     "no-raw-locators": no_raw_locators_default,
     "no-restricted-matchers": no_restricted_matchers_default,
     "no-skipped-test": no_skipped_test_default,
+    "no-standalone-expect": no_standalone_expect_default,
     "no-unsafe-references": no_unsafe_references_default,
     "no-useless-await": no_useless_await_default,
     "no-useless-not": no_useless_not_default,
     "no-wait-for-selector": no_wait_for_selector_default,
     "no-wait-for-timeout": no_wait_for_timeout_default,
+    "prefer-comparison-matcher": prefer_comparison_matcher_default,
+    "prefer-equality-matcher": prefer_equality_matcher_default,
+    "prefer-hooks-in-order": prefer_hooks_in_order_default,
+    "prefer-hooks-on-top": prefer_hooks_on_top_default,
     "prefer-lowercase-title": prefer_lowercase_title_default,
     "prefer-strict-equal": prefer_strict_equal_default,
     "prefer-to-be": prefer_to_be_default,
@@ -2300,6 +3031,7 @@ var index = {
     "prefer-to-have-count": prefer_to_have_count_default,
     "prefer-to-have-length": prefer_to_have_length_default,
     "prefer-web-first-assertions": prefer_web_first_assertions_default,
+    "require-hook": require_hook_default,
     "require-soft-assertions": require_soft_assertions_default,
     "require-top-level-describe": require_top_level_describe_default,
     "valid-expect": valid_expect_default,
@@ -2312,6 +3044,7 @@ var sharedConfig = {
     "playwright/expect-expect": "warn",
     "playwright/max-nested-describe": "warn",
     "playwright/missing-playwright-await": "error",
+    "playwright/no-conditional-expect": "warn",
     "playwright/no-conditional-in-test": "warn",
     "playwright/no-element-handle": "warn",
     "playwright/no-eval": "warn",
@@ -2321,6 +3054,7 @@ var sharedConfig = {
     "playwright/no-networkidle": "error",
     "playwright/no-page-pause": "warn",
     "playwright/no-skipped-test": "warn",
+    "playwright/no-standalone-expect": "error",
     "playwright/no-unsafe-references": "error",
     "playwright/no-useless-await": "warn",
     "playwright/no-useless-not": "warn",