eslint-plugin-playwright 1.1.2 → 1.3.0

package/dist/index.mjs

@@ -33,9 +33,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);
 }
@@ -58,13 +61,33 @@ 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]);
 }
 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];
@@ -99,7 +122,7 @@ function isPageMethod(node, name) {
 function isFunction(node) {
   return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
 }
-var isTemplateLiteral, describeProperties, testHooks, expectSubCommands;
+var isTemplateLiteral, describeProperties, testHooks, expectSubCommands, equalityMatchers;
 var init_ast = __esm({
   "src/utils/ast.ts"() {
     "use strict";
@@ -114,6 +137,7 @@ var init_ast = __esm({
     ]);
     testHooks = /* @__PURE__ */ new Set(["afterAll", "afterEach", "beforeAll", "beforeEach"]);
     expectSubCommands = /* @__PURE__ */ new Set(["soft", "poll"]);
+    equalityMatchers = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
   }
 });
 
@@ -186,6 +210,76 @@ var init_expect_expect = __esm({
   }
 });
 
+// src/rules/max-expects.ts
+var max_expects_default;
+var init_max_expects = __esm({
+  "src/rules/max-expects.ts"() {
+    "use strict";
+    init_ast();
+    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;
 var init_max_nested_describe = __esm({
@@ -407,6 +501,146 @@ var init_missing_playwright_await = __esm({
   }
 });
 
+// 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;
+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) {
+          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, getTestCallExpressionsFromDeclaredVariables, no_conditional_expect_default;
+var init_no_conditional_expect = __esm({
+  "src/rules/no-conditional-expect.ts"() {
+    "use strict";
+    init_ast();
+    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)
+          )
+        ],
+        []
+      );
+    };
+    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;
 var init_no_conditional_in_test = __esm({
@@ -445,6 +679,58 @@ var init_no_conditional_in_test = __esm({
   }
 });
 
+// src/rules/no-duplicate-hooks.ts
+var no_duplicate_hooks_default;
+var init_no_duplicate_hooks = __esm({
+  "src/rules/no-duplicate-hooks.ts"() {
+    "use strict";
+    init_ast();
+    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];
@@ -680,6 +966,59 @@ var init_no_get_by_title = __esm({
   }
 });
 
+// src/rules/no-hooks.ts
+var no_hooks_default;
+var init_no_hooks = __esm({
+  "src/rules/no-hooks.ts"() {
+    "use strict";
+    init_ast();
+    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;
@@ -1104,6 +1443,102 @@ var init_no_skipped_test = __esm({
   }
 });
 
+// src/rules/no-standalone-expect.ts
+var getBlockType, no_standalone_expect_default;
+var init_no_standalone_expect = __esm({
+  "src/rules/no-standalone-expect.ts"() {
+    "use strict";
+    init_ast();
+    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;
+    };
+    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, truthy;
 var init_misc = __esm({
@@ -1476,6 +1911,288 @@ var init_no_wait_for_timeout = __esm({
   }
 });
 
+// src/rules/prefer-comparison-matcher.ts
+var isString, isComparingToString, invertedOperators, operatorMatcher, determineMatcher, prefer_comparison_matcher_default;
+var init_prefer_comparison_matcher = __esm({
+  "src/rules/prefer-comparison-matcher.ts"() {
+    "use strict";
+    init_ast();
+    init_parseExpectCall();
+    isString = (node) => {
+      return isStringLiteral(node) || node.type === "TemplateLiteral";
+    };
+    isComparingToString = (expression) => {
+      return isString(expression.left) || isString(expression.right);
+    };
+    invertedOperators = {
+      "<": ">=",
+      "<=": ">",
+      ">": "<=",
+      ">=": "<"
+    };
+    operatorMatcher = {
+      "<": "toBeLessThan",
+      "<=": "toBeLessThanOrEqual",
+      ">": "toBeGreaterThan",
+      ">=": "toBeGreaterThanOrEqual"
+    };
+    determineMatcher = (operator, negated) => {
+      const op = negated ? invertedOperators[operator] : operator;
+      return operatorMatcher[op] ?? null;
+    };
+    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;
+var init_prefer_equality_matcher = __esm({
+  "src/rules/prefer-equality-matcher.ts"() {
+    "use strict";
+    init_ast();
+    init_parseExpectCall();
+    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, 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"];
+    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;
+var init_prefer_hooks_on_top = __esm({
+  "src/rules/prefer-hooks-on-top.ts"() {
+    "use strict";
+    init_ast();
+    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;
 var init_prefer_lowercase_title = __esm({
@@ -1685,9 +2402,8 @@ var init_prefer_to_be = __esm({
                 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) {
@@ -1729,13 +2445,12 @@ var init_prefer_to_be = __esm({
 });
 
 // src/rules/prefer-to-contain.ts
-var matchers, isFixableIncludesCallExpression, prefer_to_contain_default;
+var isFixableIncludesCallExpression, prefer_to_contain_default;
 var init_prefer_to_contain = __esm({
   "src/rules/prefer-to-contain.ts"() {
     "use strict";
     init_ast();
     init_parseExpectCall();
-    matchers = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
     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) {
@@ -1747,7 +2462,7 @@ var init_prefer_to_contain = __esm({
             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(
@@ -1807,20 +2522,19 @@ var init_prefer_to_contain = __esm({
 });
 
 // src/rules/prefer-to-have-count.ts
-var matchers2, prefer_to_have_count_default;
+var prefer_to_have_count_default;
 var init_prefer_to_have_count = __esm({
   "src/rules/prefer-to-have-count.ts"() {
     "use strict";
     init_ast();
     init_fixer();
     init_parseExpectCall();
-    matchers2 = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
     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;
@@ -1872,20 +2586,19 @@ var init_prefer_to_have_count = __esm({
 });
 
 // src/rules/prefer-to-have-length.ts
-var lengthMatchers, prefer_to_have_length_default;
+var prefer_to_have_length_default;
 var init_prefer_to_have_length = __esm({
   "src/rules/prefer-to-have-length.ts"() {
     "use strict";
     init_ast();
     init_fixer();
     init_parseExpectCall();
-    lengthMatchers = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
     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;
@@ -2090,6 +2803,93 @@ var init_prefer_web_first_assertions = __esm({
   }
 });
 
+// src/rules/require-hook.ts
+var isNullOrUndefined, shouldBeInHook, require_hook_default;
+var init_require_hook = __esm({
+  "src/rules/require-hook.ts"() {
+    "use strict";
+    init_ast();
+    isNullOrUndefined = (node) => {
+      return node.type === "Literal" && node.value === null || isIdentifier(node, "undefined");
+    };
+    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;
+      }
+    };
+    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;
 var init_require_soft_assertions = __esm({
@@ -2315,17 +3115,17 @@ var init_valid_title = __esm({
       const [matcher, message] = Array.isArray(matcherMaybeWithMessage) ? matcherMaybeWithMessage : [matcherMaybeWithMessage];
       return [new RegExp(matcher, "u"), message];
     };
-    compileMatcherPatterns = (matchers3) => {
-      if (typeof matchers3 === "string" || Array.isArray(matchers3)) {
-        const compiledMatcher = compileMatcherPattern(matchers3);
+    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
       };
     };
     MatcherAndMessageSchema = {
@@ -2519,14 +3319,19 @@ import globals from "globals";
 var require_src = __commonJS({
   "src/index.ts"(exports, module) {
     init_expect_expect();
+    init_max_expects();
     init_max_nested_describe();
     init_missing_playwright_await();
+    init_no_commented_out_tests();
+    init_no_conditional_expect();
     init_no_conditional_in_test();
+    init_no_duplicate_hooks();
     init_no_element_handle();
     init_no_eval();
     init_no_focused_test();
     init_no_force_option();
     init_no_get_by_title();
+    init_no_hooks();
     init_no_nested_step();
     init_no_networkidle();
     init_no_nth_methods();
@@ -2534,11 +3339,16 @@ var require_src = __commonJS({
     init_no_raw_locators();
     init_no_restricted_matchers();
     init_no_skipped_test();
+    init_no_standalone_expect();
     init_no_unsafe_references();
     init_no_useless_await();
     init_no_useless_not();
     init_no_wait_for_selector();
     init_no_wait_for_timeout();
+    init_prefer_comparison_matcher();
+    init_prefer_equality_matcher();
+    init_prefer_hooks_in_order();
+    init_prefer_hooks_on_top();
     init_prefer_lowercase_title();
     init_prefer_strict_equal();
     init_prefer_to_be();
@@ -2546,6 +3356,7 @@ var require_src = __commonJS({
     init_prefer_to_have_count();
     init_prefer_to_have_length();
     init_prefer_web_first_assertions();
+    init_require_hook();
     init_require_soft_assertions();
     init_require_top_level_describe();
     init_valid_expect();
@@ -2554,14 +3365,19 @@ var require_src = __commonJS({
       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,
@@ -2569,11 +3385,16 @@ var require_src = __commonJS({
         "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,
@@ -2581,6 +3402,7 @@ var require_src = __commonJS({
         "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,
@@ -2593,6 +3415,7 @@ var require_src = __commonJS({
         "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",
@@ -2602,6 +3425,7 @@ var require_src = __commonJS({
         "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",