@slip-stream-kit/eslint-plugin 0.13.0 → 0.15.0

package/dist/index.js

@@ -659,6 +659,165 @@ var resolvePackageType = (packageRoot) => {
   return type;
 };
 
+// src/utils/playwright-call.ts
+var TEST_MODIFIERS = /* @__PURE__ */ new Set(["only", "skip", "fixme", "fail"]);
+var DESCRIBE_MODIFIERS = /* @__PURE__ */ new Set(["only", "skip", "fixme", "serial", "parallel"]);
+var calleeNames = (callee) => {
+  if (callee.type === "Identifier") {
+    return [callee.name];
+  }
+  if (callee.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier") {
+    return null;
+  }
+  const head = calleeNames(callee.object);
+  return head === null ? null : [...head, callee.property.name];
+};
+var playwrightCallKind = (node) => {
+  const names = calleeNames(node.callee);
+  if (names === null || names[0] !== "test") {
+    return null;
+  }
+  const [, second, ...rest] = names;
+  if (second === void 0) {
+    return "test";
+  }
+  if (second === "describe") {
+    const isDescribe = rest.every((name) => {
+      return DESCRIBE_MODIFIERS.has(name);
+    });
+    return isDescribe ? "describe" : null;
+  }
+  return rest.length === 0 && TEST_MODIFIERS.has(second) ? "test" : null;
+};
+var detailsArgument = (node) => {
+  const details = node.arguments[1];
+  return node.arguments.length >= 3 && details?.type === "ObjectExpression" ? details : null;
+};
+var staticTitle = (node) => {
+  const title = node.arguments[0];
+  if (title?.type === "Literal" && typeof title.value === "string") {
+    return title.value;
+  }
+  if (title?.type === "TemplateLiteral" && title.expressions.length === 0) {
+    return title.quasis[0]?.value.cooked ?? null;
+  }
+  return null;
+};
+var testStatementNames = (statement) => {
+  if (statement.type !== "ExpressionStatement" || statement.expression.type !== "CallExpression") {
+    return null;
+  }
+  const names = calleeNames(statement.expression.callee);
+  return names?.[0] === "test" ? names : null;
+};
+var isInE2ePackage = (context) => {
+  const packageRoot = findPackageRoot(context.filename.split("\\").join("/"));
+  return packageRoot !== null && resolvePackageType(packageRoot) === "e2e";
+};
+
+// src/rules/e2e-describe-order/e2e-describe-order.ts
+var SPEC_FILE = /\.spec\.[cm]?[jt]sx?$/;
+var SETUP_RANK = 0;
+var BODY_RANK = 5;
+var HOOK_RANK = { beforeAll: 1, beforeEach: 2, afterEach: 3, afterAll: 4 };
+var SETUP_CALLS = /* @__PURE__ */ new Set(["use", "configure", "setTimeout", "slow"]);
+var ANNOTATION_CALLS = /* @__PURE__ */ new Set(["skip", "fixme", "fail"]);
+var RANK_NAMES = ["setup", "beforeAll hook", "beforeEach hook", "afterEach hook", "afterAll hook", "test"];
+var isFunction = (node) => {
+  return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+};
+var rankFor = (method, call) => {
+  if (method in HOOK_RANK) {
+    return HOOK_RANK[method];
+  }
+  const declaresTest = call.arguments.slice(1).some(isFunction);
+  return SETUP_CALLS.has(method) || ANNOTATION_CALLS.has(method) && !declaresTest ? SETUP_RANK : BODY_RANK;
+};
+var rankOf = (statement) => {
+  const names = testStatementNames(statement);
+  if (names === null) {
+    return null;
+  }
+  const call = statement.expression;
+  const rank = rankFor(names.at(-1), call);
+  const title = rank === BODY_RANK ? staticTitle(call) : null;
+  const label = title === null ? `\`${names.join(".")}\`` : `\`${names.join(".")}('${title}')\``;
+  return { rank, label: `${label} (${RANK_NAMES[rank]})` };
+};
+var describeBody = (call) => {
+  const callback = call.arguments.at(-1);
+  if (callback?.type !== "ArrowFunctionExpression" && callback?.type !== "FunctionExpression") {
+    return null;
+  }
+  return callback.body.type === "BlockStatement" ? callback.body.body : null;
+};
+var e2eDescribeOrder = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Order an e2e `test.describe` body: `test.use` / `configure` / annotations, then hooks beforeAll \u2192 beforeEach \u2192 afterEach \u2192 afterAll, then tests and nested describes.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#e2e-describe-order"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional globs; the rule is skipped for matching files."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      outOfOrder: "{{label}} comes after {{afterLabel}} in describe {{describe}}. Order a describe body: `test.use` / `test.describe.configure` / annotations, then hooks beforeAll \u2192 beforeEach \u2192 afterEach \u2192 afterAll, then tests and nested describes."
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const filename = context.filename.split("\\").join("/");
+    if (!SPEC_FILE.test(filename) || options.ignore?.length && matchesAnyGlob(filename, options.ignore)) {
+      return {};
+    }
+    if (!isInE2ePackage(context)) {
+      return {};
+    }
+    return {
+      CallExpression(node) {
+        const body = playwrightCallKind(node) === "describe" ? describeBody(node) : null;
+        if (body === null) {
+          return;
+        }
+        const title = staticTitle(node);
+        const describe = title === null ? "block" : `'${title}'`;
+        let latest = null;
+        for (const statement of body) {
+          const ranked = rankOf(statement);
+          if (ranked === null) {
+            continue;
+          }
+          if (latest !== null && ranked.rank < latest.rank) {
+            context.report({
+              node: statement,
+              messageId: "outOfOrder",
+              data: {
+                label: ranked.label,
+                afterLabel: latest.label,
+                describe
+              }
+            });
+          } else {
+            latest = ranked;
+          }
+        }
+      }
+    };
+  }
+};
+
 // src/rules/e2e-file-layout/e2e-file-layout.ts
 var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
 var LEGACY_TEST_SUFFIX = /\.test(\.[cm]?[jt]sx?)$/;
@@ -763,53 +922,469 @@ var e2eFileLayout = {
   }
 };
 
-// src/utils/playwright-call.ts
-var TEST_MODIFIERS = /* @__PURE__ */ new Set(["only", "skip", "fixme", "fail"]);
-var DESCRIBE_MODIFIERS = /* @__PURE__ */ new Set(["only", "skip", "fixme", "serial", "parallel"]);
-var calleeNames = (callee) => {
+// src/utils/attached-comments.ts
+var attachedStart = (sourceCode, node) => {
+  const previousEndLine = sourceCode.getTokenBefore(node)?.loc.end.line ?? 0;
+  let start = node.range[0];
+  let startLine = node.loc.start.line;
+  for (const comment of sourceCode.getCommentsBefore(node).toReversed()) {
+    if (comment.loc.end.line < startLine - 1 || comment.loc.start.line <= previousEndLine) {
+      break;
+    }
+    start = comment.range[0];
+    startLine = comment.loc.start.line;
+  }
+  return start;
+};
+
+// src/rules/e2e-file-order/e2e-file-order.ts
+var FILE_KIND = [
+  [/\.(?:page|component)\.[cm]?[jt]sx?$/, "pageObject"],
+  [/\.fixture\.[cm]?[jt]sx?$/, "fixture"],
+  [/\.spec\.[cm]?[jt]sx?$/, "spec"],
+  [/\.mock\.[cm]?[jt]sx?$/, "mock"]
+];
+var LIB_DIR = /\/lib\//;
+var UNORDERED_FILE = /\.data\.[cm]?[jt]sx?$/;
+var KIND_OPENING = {
+  pageObject: "a page object file opens with its imports, then the class",
+  fixture: "a fixture file opens with its imports, then the fixtures type and the `extend` call",
+  spec: "a spec file opens with its imports, then its `test.*` calls",
+  mock: "a mock file opens with its imports, then the exported mock function",
+  lib: "a lib file opens with its imports, then its exports"
+};
+var fileKindOf = (filename) => {
+  const match = FILE_KIND.find(([pattern]) => {
+    return pattern.test(filename);
+  });
+  if (match) {
+    return match[1];
+  }
+  return LIB_DIR.test(filename) && !UNORDERED_FILE.test(filename) ? "lib" : null;
+};
+var unwrapExport2 = (statement) => {
+  const isExport = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration";
+  return isExport && statement.declaration ? statement.declaration : statement;
+};
+var calleeRoot = (callee) => {
   if (callee.type === "Identifier") {
-    return [callee.name];
+    return callee.name;
   }
-  if (callee.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier") {
+  if (callee.type === "MemberExpression") {
+    return calleeRoot(callee.object);
+  }
+  return callee.type === "CallExpression" ? calleeRoot(callee.callee) : null;
+};
+var typeNamesOf = (node) => {
+  if (node === void 0) {
+    return [];
+  }
+  if (node.type === "TSTypeReference" && node.typeName?.type === "Identifier") {
+    return [node.typeName.name];
+  }
+  return (node.types ?? []).flatMap(typeNamesOf);
+};
+var pageObjectAnchor = (declaration, index) => {
+  if (declaration.type !== "ClassDeclaration") {
     return null;
   }
-  const head = calleeNames(callee.object);
-  return head === null ? null : [...head, callee.property.name];
+  return { index, label: `class \`${declaration.id?.name ?? "default"}\``, headerTypes: /* @__PURE__ */ new Set() };
 };
-var playwrightCallKind = (node) => {
-  const names = calleeNames(node.callee);
-  if (names === null || names[0] !== "test") {
+var fixtureAnchor = (declaration, index) => {
+  if (declaration.type !== "VariableDeclaration") {
     return null;
   }
-  const [, second, ...rest] = names;
-  if (second === void 0) {
-    return "test";
+  const [declarator] = declaration.declarations;
+  const init = declarator?.init;
+  if (init?.type !== "CallExpression" || init.callee.type !== "MemberExpression") {
+    return null;
   }
-  if (second === "describe") {
-    const isDescribe = rest.every((name) => {
-      return DESCRIBE_MODIFIERS.has(name);
-    });
-    return isDescribe ? "describe" : null;
+  const property = init.callee.property;
+  if (property.type !== "Identifier" || property.name !== "extend") {
+    return null;
   }
-  return rest.length === 0 && TEST_MODIFIERS.has(second) ? "test" : null;
+  const name = declarator.id.type === "Identifier" ? declarator.id.name : "test";
+  const typeArguments = init.typeArguments?.params ?? [];
+  return { index, label: `fixture \`${name}\``, headerTypes: new Set(typeArguments.flatMap(typeNamesOf)) };
 };
-var detailsArgument = (node) => {
-  const details = node.arguments[1];
-  return node.arguments.length >= 3 && details?.type === "ObjectExpression" ? details : null;
+var specAnchor = (statement, index) => {
+  if (statement.type !== "ExpressionStatement" || statement.expression.type !== "CallExpression") {
+    return null;
+  }
+  if (calleeRoot(statement.expression.callee) !== "test") {
+    return null;
+  }
+  return { index, label: "the first `test.*` call", headerTypes: /* @__PURE__ */ new Set() };
 };
-var staticTitle = (node) => {
-  const title = node.arguments[0];
-  if (title?.type === "Literal" && typeof title.value === "string") {
-    return title.value;
+var isFunctionValue = (node) => {
+  return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+};
+var mockAnchor = (statement, index) => {
+  if (statement.type !== "ExportNamedDeclaration" && statement.type !== "ExportDefaultDeclaration") {
+    return null;
   }
-  if (title?.type === "TemplateLiteral" && title.expressions.length === 0) {
-    return title.quasis[0]?.value.cooked ?? null;
+  const declaration = unwrapExport2(statement);
+  if (declaration.type === "FunctionDeclaration") {
+    return { index, label: `mock \`${declaration.id?.name ?? "default"}\``, headerTypes: /* @__PURE__ */ new Set() };
+  }
+  const declarator = declaration.type === "VariableDeclaration" ? declaration.declarations[0] : void 0;
+  if (declarator?.id.type !== "Identifier" || !isFunctionValue(declarator.init)) {
+    return null;
+  }
+  return { index, label: `mock \`${declarator.id.name}\``, headerTypes: /* @__PURE__ */ new Set() };
+};
+var ANCHOR_FINDERS = {
+  pageObject: (statement, index) => {
+    return pageObjectAnchor(unwrapExport2(statement), index);
+  },
+  fixture: (statement, index) => {
+    return fixtureAnchor(unwrapExport2(statement), index);
+  },
+  spec: specAnchor,
+  mock: mockAnchor
+};
+var findAnchor = (body, kind) => {
+  for (const [index, statement] of body.entries()) {
+    const anchor = ANCHOR_FINDERS[kind](statement, index);
+    if (anchor !== null) {
+      return anchor;
+    }
   }
   return null;
 };
-var isInE2ePackage = (context) => {
-  const packageRoot = findPackageRoot(context.filename.split("\\").join("/"));
-  return packageRoot !== null && resolvePackageType(packageRoot) === "e2e";
+var isDirective = (statement) => {
+  return statement.type === "ExpressionStatement" && statement.expression.type === "Literal" && typeof statement.expression.value === "string";
+};
+var anchoredCandidates = (body, kind) => {
+  const anchor = findAnchor(body, kind);
+  if (anchor === null) {
+    return null;
+  }
+  const candidates = body.slice(0, anchor.index).flatMap((statement, index) => {
+    const declaration = unwrapExport2(statement);
+    const isHeader = statement.type === "ImportDeclaration" || isDirective(statement) || declaration.id?.name !== void 0 && anchor.headerTypes.has(declaration.id.name);
+    return isHeader ? [] : [index];
+  });
+  return { candidates, target: anchor.label };
+};
+var locallyExportedNames = (body) => {
+  const names = body.flatMap((statement) => {
+    if (statement.type !== "ExportNamedDeclaration" || statement.source) {
+      return [];
+    }
+    return statement.specifiers.flatMap((specifier) => {
+      return specifier.local.type === "Identifier" ? [specifier.local.name] : [];
+    });
+  });
+  return new Set(names);
+};
+var declaredNames = (statement) => {
+  const declaration = unwrapExport2(statement);
+  if (declaration.type === "VariableDeclaration") {
+    return declaration.declarations.flatMap((declarator) => {
+      return declarator.id.type === "Identifier" ? [declarator.id.name] : [];
+    });
+  }
+  return declaration.id?.name ? [declaration.id.name] : [];
+};
+var libCandidates = (body) => {
+  const exportedNames = locallyExportedNames(body);
+  const isExported = (statement) => {
+    return statement.type.startsWith("Export") || declaredNames(statement).some((name) => {
+      return exportedNames.has(name);
+    });
+  };
+  const lastExport = body.findLastIndex(isExported);
+  if (lastExport === -1) {
+    return null;
+  }
+  const candidates = body.slice(0, lastExport).flatMap((statement, index) => {
+    return statement.type === "ImportDeclaration" || isDirective(statement) || isExported(statement) ? [] : [index];
+  });
+  return { candidates, target: "the exports" };
+};
+var misplacedStatements = (body, kind) => {
+  return kind === "lib" ? libCandidates(body) : anchoredCandidates(body, kind);
+};
+var runsWithCall = (fn, call) => {
+  if (call.callee === fn || playwrightCallKind(call) === "describe") {
+    return true;
+  }
+  return calleeRoot(call.callee) !== "test";
+};
+var isFunctionNode = (node) => {
+  return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration";
+};
+var runsAtLoad = (node) => {
+  let child = node;
+  let parent = node.parent;
+  while (parent) {
+    if (isFunctionNode(child)) {
+      if (parent.type !== "CallExpression" || !runsWithCall(child, parent)) {
+        return false;
+      }
+    }
+    const tsParent = parent;
+    if (tsParent.type === "PropertyDefinition" && tsParent.value === child && !tsParent.static) {
+      return false;
+    }
+    child = parent;
+    parent = parent.parent;
+  }
+  return true;
+};
+var topLevelIndex = (node, body) => {
+  let current = node;
+  while (current.parent && current.parent.type !== "Program") {
+    current = current.parent;
+  }
+  return body.indexOf(current);
+};
+var valueReferences = (sourceCode, statement) => {
+  return sourceCode.getDeclaredVariables(unwrapExport2(statement)).flatMap((variable) => {
+    return variable.references.filter((reference) => {
+      const tsReference = reference;
+      return tsReference.isValueReference !== false && reference.identifier !== variable.identifiers[0];
+    });
+  });
+};
+var movableStrays = (sourceCode, body, candidates) => {
+  const movable = new Set(candidates);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const index of movable) {
+      const pinned = valueReferences(sourceCode, body[index]).some((reference) => {
+        const from = topLevelIndex(reference.identifier, body);
+        return !movable.has(from) && (candidates.includes(from) || runsAtLoad(reference.identifier));
+      });
+      if (pinned) {
+        movable.delete(index);
+        changed = true;
+      }
+    }
+  }
+  return movable;
+};
+var describeStatement = (statement) => {
+  const names = declaredNames(statement);
+  if (names.length > 0) {
+    return names.map((name) => {
+      return `\`${name}\``;
+    }).join(", ");
+  }
+  return `a ${unwrapExport2(statement).type} statement`;
+};
+var statementSpan = (sourceCode, statement) => {
+  const trailing = sourceCode.getCommentsAfter(statement).filter((comment) => {
+    return comment.loc.start.line === statement.loc.end.line;
+  });
+  return [attachedStart(sourceCode, statement), (trailing.at(-1) ?? statement).range[1]];
+};
+var buildFix = (sourceCode, body, movable) => {
+  return (fixer) => {
+    const spans = movable.map((index) => {
+      return statementSpan(sourceCode, body[index]);
+    });
+    const moved = spans.map(([start, end2]) => {
+      return sourceCode.text.slice(start, end2);
+    });
+    const end = sourceCode.text.length;
+    const separator = sourceCode.text.endsWith("\n") ? "\n" : "\n\n";
+    return [
+      ...spans.map(([start, stop]) => {
+        const next = sourceCode.text.slice(stop).search(/\S/);
+        return fixer.removeRange([start, next === -1 ? end : stop + next]);
+      }),
+      fixer.insertTextAfterRange([end, end], `${separator}${moved.join("\n\n")}
+`)
+    ];
+  };
+};
+var e2eFileOrder = {
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      description: "Require e2e page objects, fixtures, specs, mocks and lib files to open with their imports followed by the class, the `extend` call, the `test.*` calls, the mock function or the exports \u2014 helpers and constants go below.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#e2e-file-order"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional globs; the rule is skipped for matching files."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      strayBeforeAnchor: "{{name}} sits between the imports and {{anchor}}. Move it below {{anchor}}: {{opening}}. The autofix moves it to the end of the file."
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const filename = context.filename.split("\\").join("/");
+    const kind = fileKindOf(filename);
+    if (kind === null || options.ignore?.length && matchesAnyGlob(filename, options.ignore)) {
+      return {};
+    }
+    if (!isInE2ePackage(context)) {
+      return {};
+    }
+    return {
+      Program(program) {
+        const body = program.body;
+        const misplaced = misplacedStatements(body, kind);
+        if (misplaced === null) {
+          return;
+        }
+        const movable = [...movableStrays(context.sourceCode, body, misplaced.candidates)].toSorted((a, b) => {
+          return a - b;
+        });
+        if (movable.length === 0) {
+          return;
+        }
+        const fix = buildFix(context.sourceCode, body, movable);
+        for (const index of movable) {
+          context.report({
+            node: body[index],
+            messageId: "strayBeforeAnchor",
+            data: { name: describeStatement(body[index]), anchor: misplaced.target, opening: KIND_OPENING[kind] },
+            fix
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/rules/e2e-page-object-member-order/e2e-page-object-member-order.ts
+var PAGE_OBJECT_FILE = /\.(?:page|component)\.[cm]?[jt]sx?$/;
+var GROUPS = ["field", "constructor", "getter", "public method", "private method"];
+var isPrivate = (member) => {
+  return member.accessibility === "private" || member.accessibility === "protected" || member.key?.type === "PrivateIdentifier";
+};
+var groupOf = (member) => {
+  if (member.kind === "constructor") {
+    return "constructor";
+  }
+  if (member.type !== "MethodDefinition") {
+    return "field";
+  }
+  if (isPrivate(member)) {
+    return "private method";
+  }
+  return member.kind === "get" || member.kind === "set" ? "getter" : "public method";
+};
+var memberName = (member) => {
+  if (member.kind === "constructor") {
+    return "the constructor";
+  }
+  const key = member.key;
+  if (key?.type === "Identifier") {
+    return `\`${key.name}\``;
+  }
+  return key?.type === "PrivateIdentifier" ? `\`#${key.name}\`` : "a computed member";
+};
+var buildFix2 = (sourceCode, members) => {
+  return (fixer) => {
+    const spans = members.map((_, index) => {
+      return [attachedStart(sourceCode, members[index]), members[index].range[1]];
+    });
+    const texts = spans.map(([start, end]) => {
+      return sourceCode.text.slice(start, end);
+    });
+    const order = members.map((member, index) => {
+      return { index, rank: GROUPS.indexOf(groupOf(member)) };
+    }).toSorted((a, b) => {
+      return a.rank - b.rank || a.index - b.index;
+    });
+    return spans.map((span, slot) => {
+      return fixer.replaceTextRange(span, texts[order[slot].index]);
+    });
+  };
+};
+var findViolations = (members) => {
+  const violations = [];
+  let latest = null;
+  for (const member of members) {
+    const group = groupOf(member);
+    if (latest !== null && GROUPS.indexOf(group) < GROUPS.indexOf(latest.group)) {
+      violations.push({ member, group, after: latest.member, afterGroup: latest.group });
+    } else {
+      latest = { member, group };
+    }
+  }
+  return violations;
+};
+var e2ePageObjectMemberOrder = {
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      description: "Order the members of an e2e page object: fields, the constructor, getters, public methods, then private methods.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#e2e-page-object-member-order"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional globs; the rule is skipped for matching files."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      outOfOrder: "The {{group}} {{name}} comes after the {{afterGroup}} {{afterName}} in class `{{className}}`. Order a page object: fields, constructor, getters, public methods, private methods."
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const filename = context.filename.split("\\").join("/");
+    if (!PAGE_OBJECT_FILE.test(filename) || options.ignore?.length && matchesAnyGlob(filename, options.ignore)) {
+      return {};
+    }
+    if (!isInE2ePackage(context)) {
+      return {};
+    }
+    const check = (node) => {
+      const members = node.body.body;
+      const violations = findViolations(members);
+      if (violations.length === 0) {
+        return;
+      }
+      const fix = buildFix2(context.sourceCode, members);
+      for (const violation of violations) {
+        context.report({
+          node: violation.member,
+          messageId: "outOfOrder",
+          data: {
+            group: violation.group,
+            name: memberName(violation.member),
+            afterGroup: violation.afterGroup,
+            afterName: memberName(violation.after),
+            className: node.id?.name ?? "anonymous"
+          },
+          fix
+        });
+      }
+    };
+    return {
+      ClassDeclaration: check,
+      ClassExpression: check
+    };
+  }
 };
 
 // src/rules/e2e-test-tags/e2e-test-tags.ts
@@ -915,6 +1490,150 @@ var e2eTestTitle = {
   }
 };
 
+// src/rules/e2e-top-level-describe/e2e-top-level-describe.ts
+var SPEC_FILE2 = /\.spec\.[cm]?[jt]sx?$/;
+var DEFAULT_MAX = 1;
+var topLevelCalls = (body) => {
+  return body.flatMap((statement) => {
+    const names = testStatementNames(statement);
+    if (names === null) {
+      return [];
+    }
+    const expressionStatement = statement;
+    return [{ statement: expressionStatement, call: expressionStatement.expression, names }];
+  });
+};
+var describeLabel = (call) => {
+  const title = staticTitle(call);
+  return title === null ? "the `test.describe` block" : `\`test.describe('${title}')\``;
+};
+var callbackBlock = (call) => {
+  const callback = call.arguments.at(-1);
+  if (callback?.type !== "ArrowFunctionExpression" && callback?.type !== "FunctionExpression") {
+    return null;
+  }
+  return callback.body.type === "BlockStatement" ? callback.body : null;
+};
+var removalRange = (sourceCode, statement) => {
+  const end = statement.range[1];
+  const next = sourceCode.text.slice(end).search(/\S/);
+  return [attachedStart(sourceCode, statement), next === -1 ? sourceCode.text.length : end + next];
+};
+var buildFix3 = (sourceCode, moved, block) => {
+  return (fixer) => {
+    const indent = " ".repeat(block.body[0]?.loc?.start.column ?? 2);
+    const texts = moved.map(({ statement }) => {
+      const [start] = removalRange(sourceCode, statement);
+      return sourceCode.text.slice(start, statement.range[1]).split("\n").map((line) => {
+        return line === "" ? line : `${indent}${line}`;
+      }).join("\n");
+    });
+    return [
+      ...moved.map(({ statement }) => {
+        return fixer.removeRange(removalRange(sourceCode, statement));
+      }),
+      fixer.insertTextAfterRange([block.range[0], block.range[0] + 1], `
+${texts.join("\n\n")}
+`)
+    ];
+  };
+};
+var e2eTopLevelDescribe = {
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      description: "Require an e2e spec to hold one top-level `test.describe`, with its `test.use`, `configure`, hooks and tests inside it.",
+      recommended: true,
+      url: "https://github.com/ArthurSaenz/infra-kit/tree/main/apps/infra-kit/eslint-plugin#e2e-top-level-describe"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional globs; the rule is skipped for matching files."
+          },
+          max: {
+            type: "integer",
+            minimum: 1,
+            description: "Top-level `test.describe` blocks a spec may hold."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      extraDescribe: "{{describe}} is top-level describe number {{count}} in this spec; the limit is {{max}}. Move it to its own spec file, or nest it inside {{first}}.",
+      outsideDescribe: "`{{call}}` sits at the top level of the spec. Move it inside {{describe}}: a spec holds one top-level describe, and its setup, hooks and tests live inside it.",
+      testOutsideDescribe: "Test {{test}} sits at the top level of the spec. Wrap the spec\u2019s tests in a `test.describe` named after the feature they cover."
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const filename = context.filename.split("\\").join("/");
+    if (!SPEC_FILE2.test(filename) || options.ignore?.length && matchesAnyGlob(filename, options.ignore)) {
+      return {};
+    }
+    if (!isInE2ePackage(context)) {
+      return {};
+    }
+    const max = options.max ?? DEFAULT_MAX;
+    return {
+      Program(program) {
+        const calls = topLevelCalls(program.body);
+        const describes = calls.filter(({ call }) => {
+          return playwrightCallKind(call) === "describe";
+        });
+        const tests = calls.filter(({ call }) => {
+          return playwrightCallKind(call) === "test" && call.arguments.slice(1).some((argument) => {
+            return argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression";
+          });
+        });
+        const setup = calls.filter((entry) => {
+          return !describes.includes(entry) && !tests.includes(entry);
+        });
+        for (const [index, extra] of describes.slice(max).entries()) {
+          context.report({
+            node: extra.statement,
+            messageId: "extraDescribe",
+            data: {
+              describe: describeLabel(extra.call),
+              count: String(max + index + 1),
+              max: String(max),
+              first: describeLabel(describes[0].call)
+            }
+          });
+        }
+        for (const test of tests) {
+          const title = staticTitle(test.call);
+          context.report({
+            node: test.statement,
+            messageId: "testOutsideDescribe",
+            data: { test: title === null ? `\`${test.names.join(".")}\`` : `'${title}'` }
+          });
+        }
+        const [only] = describes;
+        const block = describes.length === 1 && only ? callbackBlock(only.call) : null;
+        const fix = block === null ? void 0 : buildFix3(context.sourceCode, setup, block);
+        for (const entry of setup) {
+          context.report({
+            node: entry.statement,
+            messageId: "outsideDescribe",
+            data: {
+              call: entry.names.join("."),
+              describe: only ? describeLabel(only.call) : "a `test.describe` block"
+            },
+            fix
+          });
+        }
+      }
+    };
+  }
+};
+
 // src/rules/max-components-per-file/max-components-per-file.ts
 var DEFAULT_MAX_COMPONENTS = 4;
 var ANONYMOUS_NAME2 = "component";
@@ -2396,7 +3115,7 @@ var locationViolation = (dirs, basename) => {
     data: { basename, target: [...fromSrc(dirs), TESTS_DIR, basename].join("/") }
   };
 };
-var findViolations = (filename, ignore) => {
+var findViolations2 = (filename, ignore) => {
   if (!TEST_FILE2.test(filename) || ignore.length > 0 && matchesAnyGlob(filename, ignore)) {
     return [];
   }
@@ -2441,7 +3160,7 @@ var testLocation = {
   },
   create(context) {
     const options = context.options[0] ?? {};
-    const violations = findViolations(context.filename.split("\\").join("/"), options.ignore ?? []);
+    const violations = findViolations2(context.filename.split("\\").join("/"), options.ignore ?? []);
     if (violations.length === 0) {
       return {};
     }
@@ -2473,6 +3192,10 @@ var rules = {
   "package-structure": packageStructure,
   "test-location": testLocation,
   "e2e-file-layout": e2eFileLayout,
+  "e2e-file-order": e2eFileOrder,
+  "e2e-page-object-member-order": e2ePageObjectMemberOrder,
+  "e2e-describe-order": e2eDescribeOrder,
+  "e2e-top-level-describe": e2eTopLevelDescribe,
   "e2e-test-tags": e2eTestTags,
   "e2e-test-title": e2eTestTitle
 };
@@ -2482,7 +3205,7 @@ var PLUGIN_NAME = "@wl";
 var plugin = {
   meta: {
     name: "@wl/eslint-plugin",
-    version: "0.13.0"
+    version: "0.15.0"
   },
   rules,
   configs: {}
@@ -2592,6 +3315,10 @@ plugin.configs.recommended = [
     },
     rules: {
       [`${PLUGIN_NAME}/e2e-file-layout`]: "error",
+      [`${PLUGIN_NAME}/e2e-file-order`]: "error",
+      [`${PLUGIN_NAME}/e2e-page-object-member-order`]: "error",
+      [`${PLUGIN_NAME}/e2e-describe-order`]: "error",
+      [`${PLUGIN_NAME}/e2e-top-level-describe`]: "error",
       [`${PLUGIN_NAME}/e2e-test-tags`]: "error",
       [`${PLUGIN_NAME}/e2e-test-title`]: "error"
     }