eslint-plugin-no-mistakes 0.8.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "ESLint and Oxlint rules for deterministic no-mistakes code analysis",
   "license": "MIT",
   "repository": {

package/src/component-functions.js

@@ -0,0 +1,76 @@
+"use strict";
+
+function nonEmptyStrings(value, fallback) {
+  if (!Array.isArray(value)) {
+    return fallback;
+  }
+  const strings = value.filter((item) => typeof item === "string" && item.length > 0);
+  return strings.length > 0 ? strings : fallback;
+}
+
+function functionFromExpression(node, opts) {
+  const unwrapped = unwrapExpression(node, opts);
+  return isFunctionNode(unwrapped) ? unwrapped : null;
+}
+
+function unwrapExpression(node, opts) {
+  if (!node) {
+    return null;
+  }
+  if (isExpressionWrapper(node)) {
+    return unwrapExpression(node.expression, opts);
+  }
+  if (node.type !== "CallExpression" || !isConfiguredWrapper(node.callee, opts)) {
+    return node;
+  }
+  for (const arg of node.arguments) {
+    const unwrapped = unwrapExpression(arg, opts);
+    if (isFunctionNode(unwrapped)) {
+      return unwrapped;
+    }
+  }
+  return node;
+}
+
+function isConfiguredWrapper(callee, opts) {
+  const name = calleeName(callee);
+  return Boolean(name && opts.wrappers.has(name));
+}
+
+function calleeName(node) {
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+  if (node.type === "MemberExpression" && !node.computed) {
+    return node.property.name;
+  }
+  return null;
+}
+
+function isFunctionNode(node) {
+  return Boolean(
+    node &&
+    (node.type === "FunctionDeclaration" ||
+      node.type === "FunctionExpression" ||
+      node.type === "ArrowFunctionExpression"),
+  );
+}
+
+function isExpressionWrapper(node) {
+  return [
+    "ChainExpression",
+    "ParenthesizedExpression",
+    "TSAsExpression",
+    "TSSatisfiesExpression",
+    "TSNonNullExpression",
+    "TSTypeAssertion",
+    "TypeCastExpression",
+  ].includes(node.type);
+}
+
+module.exports = {
+  functionFromExpression,
+  isExpressionWrapper,
+  isFunctionNode,
+  nonEmptyStrings,
+};

package/src/exported-components.js

@@ -0,0 +1,198 @@
+"use strict";
+
+const { functionFromExpression, nonEmptyStrings } = require("./component-functions");
+
+const DEFAULT_COMPONENT_NAME_PATTERN = "^[A-Z]";
+const DEFAULT_WRAPPERS = ["memo", "forwardRef", "observer"];
+const DEFAULT_EXPORT_TYPES = ["named", "default"];
+
+function normalizedComponentOptions(option) {
+  return {
+    componentNamePattern: compilePattern(
+      option.componentNamePattern,
+      DEFAULT_COMPONENT_NAME_PATTERN,
+    ),
+    components: compileMatchers(option.components),
+    ignoreComponents: compileMatchers(option.ignoreComponents),
+    wrappers: new Set(nonEmptyStrings(option.wrappers, DEFAULT_WRAPPERS)),
+    exportTypes: new Set(nonEmptyStrings(option.exportTypes, DEFAULT_EXPORT_TYPES)),
+    checkAnonymousDefault: option.checkAnonymousDefault === true,
+  };
+}
+
+function compilePattern(value, fallback) {
+  return new RegExp(typeof value === "string" && value.length > 0 ? value : fallback);
+}
+
+function compileMatchers(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return values
+    .filter((value) => typeof value === "string" && value.length > 0)
+    .map((value) => {
+      const regex = regexLiteral(value);
+      return regex ? { regex } : { exact: value };
+    });
+}
+
+function regexLiteral(value) {
+  if (!value.startsWith("/") || value.lastIndexOf("/") === 0) {
+    return null;
+  }
+  const lastSlash = value.lastIndexOf("/");
+  return new RegExp(value.slice(1, lastSlash), value.slice(lastSlash + 1));
+}
+
+function shouldCheckComponent(component, opts) {
+  if (component.anonymousDefault) {
+    return opts.checkAnonymousDefault;
+  }
+  if (opts.ignoreComponents.some((matcher) => matchesName(component.name, matcher))) {
+    return false;
+  }
+  if (opts.components.length > 0) {
+    return opts.components.some((matcher) => matchesName(component.name, matcher));
+  }
+  return opts.componentNamePattern.test(component.name);
+}
+
+function matchesName(name, matcher) {
+  return matcher.regex ? matcher.regex.test(name) : matcher.exact === name;
+}
+
+function collectExportedComponents(program, opts) {
+  const definitions = new Map();
+  const namedExports = new Set();
+  const defaultExports = new Set();
+  const components = [];
+
+  for (const statement of program.body) {
+    collectTopLevelDefinition(statement, definitions, opts);
+    if (statement.type === "ExportNamedDeclaration") {
+      collectNamedExport(statement, definitions, namedExports, defaultExports, components, opts);
+    }
+    if (statement.type === "ExportDefaultDeclaration") {
+      collectDefaultExport(statement, definitions, defaultExports, components, opts);
+    }
+  }
+
+  pushExportedDefinitions(namedExports, definitions, components, opts.exportTypes.has("named"));
+  pushExportedDefinitions(defaultExports, definitions, components, opts.exportTypes.has("default"));
+  return uniqueComponents(components);
+}
+
+function pushExportedDefinitions(names, definitions, components, enabled) {
+  if (!enabled) {
+    return;
+  }
+  for (const name of names) {
+    const definition = definitions.get(name);
+    if (definition) {
+      components.push(definition);
+    }
+  }
+}
+
+function collectTopLevelDefinition(statement, definitions, opts) {
+  if (statement.type === "FunctionDeclaration" && statement.id) {
+    definitions.set(statement.id.name, { name: statement.id.name, fn: statement });
+    return;
+  }
+  if (statement.type !== "VariableDeclaration") {
+    return;
+  }
+  for (const declaration of statement.declarations) {
+    if (declaration.id.type !== "Identifier") {
+      continue;
+    }
+    const fn = functionFromExpression(declaration.init, opts);
+    if (fn) {
+      definitions.set(declaration.id.name, { name: declaration.id.name, fn });
+    }
+  }
+}
+
+function collectNamedExport(
+  statement,
+  definitions,
+  namedExports,
+  defaultExports,
+  components,
+  opts,
+) {
+  if (statement.source) {
+    return;
+  }
+  if (statement.declaration?.type === "FunctionDeclaration" && statement.declaration.id) {
+    const name = statement.declaration.id.name;
+    definitions.set(name, { name, fn: statement.declaration });
+    if (opts.exportTypes.has("named")) {
+      components.push(definitions.get(name));
+    }
+    return;
+  }
+  if (statement.declaration?.type === "VariableDeclaration") {
+    collectTopLevelDefinition(statement.declaration, definitions, opts);
+    for (const declaration of statement.declaration.declarations) {
+      const definition = definitions.get(declaration.id.name);
+      if (declaration.id.type === "Identifier" && definition && opts.exportTypes.has("named")) {
+        components.push(definition);
+      }
+    }
+    return;
+  }
+  for (const specifier of statement.specifiers || []) {
+    if (specifier.local?.type === "Identifier") {
+      if (specifier.exported?.name === "default") {
+        defaultExports.add(specifier.local.name);
+      } else {
+        namedExports.add(specifier.local.name);
+      }
+    }
+  }
+}
+
+function collectDefaultExport(statement, definitions, defaultExports, components, opts) {
+  if (!opts.exportTypes.has("default")) {
+    return;
+  }
+  const declaration = statement.declaration;
+  if (declaration.type === "Identifier") {
+    defaultExports.add(declaration.name);
+    return;
+  }
+  if (declaration.type === "FunctionDeclaration") {
+    const name = declaration.id?.name || "default";
+    if (declaration.id || opts.checkAnonymousDefault) {
+      components.push({ name, fn: declaration, anonymousDefault: !declaration.id });
+    }
+    return;
+  }
+  const fn = functionFromExpression(declaration, opts);
+  if (fn && opts.checkAnonymousDefault) {
+    components.push({ name: fn.id?.name || "default", fn, anonymousDefault: !fn.id });
+  }
+  if (fn?.id) {
+    definitions.set(fn.id.name, { name: fn.id.name, fn });
+    defaultExports.add(fn.id.name);
+  }
+}
+
+function uniqueComponents(components) {
+  const seen = new Set();
+  return components.filter((component) => {
+    const key = `${component.name}:${component.fn.range?.[0] ?? component.fn.loc?.start?.line ?? ""}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+
+module.exports = {
+  collectExportedComponents,
+  normalizedComponentOptions,
+  shouldCheckComponent,
+};

package/src/index.js

@@ -18,6 +18,7 @@ const rules = {
   "playwright-no-empty": require("./rules/playwright-no-empty"),
   "playwright-no-set-timeout": require("./rules/playwright-no-set-timeout"),
   "playwright-prefer-get-by-test-id": require("./rules/playwright-prefer-get-by-test-id"),
+  "playwright-require-exported-component-attribute": require("./rules/playwright-require-exported-component-attribute"),
   "playwright-require-interactive-test-id": require("./rules/playwright-require-interactive-test-id"),
   "playwright-selector-priority": require("./rules/playwright-selector-priority"),
   "react-no-iife-in-jsx": require("./rules/react-no-iife-in-jsx"),

package/src/returned-jsx.js

@@ -0,0 +1,119 @@
+"use strict";
+
+const { attributeName } = require("./helpers");
+const { isExpressionWrapper, isFunctionNode } = require("./component-functions");
+
+function returnedJsxBranches(fn) {
+  if (fn.type === "ArrowFunctionExpression" && fn.body.type !== "BlockStatement") {
+    return jsxBranches(fn.body);
+  }
+  const branches = [];
+  collectReturnBranches(fn.body, branches);
+  return branches;
+}
+
+function collectReturnBranches(node, branches) {
+  if (!node || (node.type !== "BlockStatement" && isFunctionNode(node))) {
+    return;
+  }
+  if (node.type === "ReturnStatement") {
+    branches.push(...jsxBranches(node.argument));
+    return;
+  }
+  if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+    return;
+  }
+  for (const child of childNodes(node)) {
+    collectReturnBranches(child, branches);
+  }
+}
+
+function jsxBranches(node) {
+  const unwrapped = unwrapSyntaxExpression(node);
+  if (!unwrapped || isNullLiteral(unwrapped)) {
+    return [];
+  }
+  if (isJsxNode(unwrapped)) {
+    return [unwrapped];
+  }
+  if (unwrapped.type === "ConditionalExpression") {
+    return [...jsxBranches(unwrapped.consequent), ...jsxBranches(unwrapped.alternate)];
+  }
+  if (unwrapped.type === "LogicalExpression") {
+    return [...jsxBranches(unwrapped.left), ...jsxBranches(unwrapped.right)];
+  }
+  if (unwrapped.type === "SequenceExpression") {
+    return jsxBranches(unwrapped.expressions.at(-1));
+  }
+  if (unwrapped.type === "ArrayExpression") {
+    return unwrapped.elements.flatMap((element) => jsxBranches(element));
+  }
+  return [];
+}
+
+function unwrapSyntaxExpression(node) {
+  let current = node;
+  while (current && isExpressionWrapper(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+
+function isNullLiteral(node) {
+  return node.type === "Literal" && node.value === null;
+}
+
+function isJsxNode(node) {
+  return node.type === "JSXElement" || node.type === "JSXFragment";
+}
+
+function jsxTreeHasAttribute(node, opts) {
+  let found = false;
+  visitNode(node, (current) => {
+    if (found || current.type !== "JSXOpeningElement") {
+      return;
+    }
+    found = current.attributes.some((attribute) => {
+      if (attribute.type === "JSXSpreadAttribute") {
+        return opts.allowSpreadAttributes;
+      }
+      const name = attributeName(attribute);
+      return Boolean(name && opts.attributes.includes(name));
+    });
+  });
+  return found;
+}
+
+function visitNode(node, callback) {
+  if (!node || typeof node.type !== "string") {
+    return;
+  }
+  callback(node);
+  for (const child of childNodes(node)) {
+    visitNode(child, callback);
+  }
+}
+
+function childNodes(node) {
+  const children = [];
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "parent" || key === "tokens" || key === "comments") {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      children.push(...value.filter(isAstNode));
+    } else if (isAstNode(value)) {
+      children.push(value);
+    }
+  }
+  return children;
+}
+
+function isAstNode(value) {
+  return Boolean(value && typeof value.type === "string");
+}
+
+module.exports = {
+  jsxTreeHasAttribute,
+  returnedJsxBranches,
+};

package/src/rules/playwright-require-exported-component-attribute.js

@@ -0,0 +1,77 @@
+"use strict";
+
+const {
+  collectExportedComponents,
+  normalizedComponentOptions,
+  shouldCheckComponent,
+} = require("../exported-components");
+const { nonEmptyStrings } = require("../component-functions");
+const { options, rule } = require("../helpers");
+const { jsxTreeHasAttribute, returnedJsxBranches } = require("../returned-jsx");
+
+const DEFAULT_ATTRIBUTES = ["data-pw"];
+
+module.exports = rule(
+  {
+    type: "suggestion",
+    docs: {
+      description: "require configured attributes in exported component JSX trees",
+      recommended: false,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          attributes: { type: "array", items: { type: "string" } },
+          componentNamePattern: { type: "string" },
+          components: { type: "array", items: { type: "string" } },
+          ignoreComponents: { type: "array", items: { type: "string" } },
+          wrappers: { type: "array", items: { type: "string" } },
+          allowSpreadAttributes: { type: "boolean" },
+          exportTypes: {
+            type: "array",
+            items: { enum: ["named", "default"] },
+          },
+          checkAnonymousDefault: { type: "boolean" },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      missing: "Exported component '{{name}}' must return JSX containing one of: {{attributes}}.",
+    },
+  },
+  (context) => ({
+    Program(node) {
+      const opts = normalizedOptions(options(context));
+      for (const component of collectExportedComponents(node, opts)) {
+        reportMissingBranches(context, component, opts);
+      }
+    },
+  }),
+);
+
+function normalizedOptions(option) {
+  return {
+    ...normalizedComponentOptions(option),
+    attributes: nonEmptyStrings(option.attributes, DEFAULT_ATTRIBUTES),
+    allowSpreadAttributes: option.allowSpreadAttributes === true,
+  };
+}
+
+function reportMissingBranches(context, component, opts) {
+  if (shouldCheckComponent(component, opts)) {
+    for (const jsx of returnedJsxBranches(component.fn)) {
+      if (!jsxTreeHasAttribute(jsx, opts)) {
+        context.report({
+          node: jsx,
+          messageId: "missing",
+          data: {
+            name: component.name,
+            attributes: opts.attributes.join(", "),
+          },
+        });
+      }
+    }
+  }
+}

package/src/rules/test-no-error-message-matching.js

@@ -62,6 +62,10 @@ function isStaticAnalysisPath(filename) {
   );
 }
 
+function isGeneratedTestPath(filename) {
+  return filename.replace(/\\/g, "/").includes(".generated.");
+}
+
 function isExpectCall(node) {
   const current = unwrap(node);
   if (current?.type !== "CallExpression") return false;
@@ -99,7 +103,7 @@ module.exports = rule(
     messages: { message: "Do not assert on err.message; check the error type or code instead." },
   },
   (context) => {
-    if (isStaticAnalysisPath(context.filename)) return {};
+    if (isStaticAnalysisPath(context.filename) || isGeneratedTestPath(context.filename)) return {};
     let testDepth = 0;
     return {
       CallExpression(node) {

package/src/rules/test-no-shared-state-analysis.js

@@ -0,0 +1,130 @@
+"use strict";
+
+const {
+  childNodes,
+  isCalledFunction,
+  isFunctionNode,
+  isInlineSetupCallback,
+  isInlineTestCallback,
+} = require("./test-no-shared-state-helpers");
+
+function isInsideUncalledNestedFunction(node, testDepth, setupDepth) {
+  if (testDepth === 0 && setupDepth === 0) return false;
+  let current = node.parent;
+  while (current) {
+    const isUncalledFunction =
+      isFunctionNode(current) &&
+      !isInlineSetupCallback(current) &&
+      !isInlineTestCallback(current) &&
+      !isCalledFunction(current);
+    if (isUncalledFunction) return true;
+    current = current.parent;
+  }
+  return false;
+}
+
+function isModuleMutable(context, mutableTopLevel, node, name) {
+  let scope = context.sourceCode.getScope(node);
+  while (scope) {
+    const variable = scope.variables.find((candidate) => candidate.name === name);
+    if (variable) {
+      return (
+        mutableTopLevel.has(variable.name) &&
+        (variable.scope.type === "module" || variable.scope.block.type === "Program")
+      );
+    }
+    scope = scope.upper;
+  }
+  return false;
+}
+
+function isResetAssignment(node, isMutableInitializer) {
+  if (node.left.type === "Identifier") return isMutableInitializer(node.right);
+  return (
+    node.left.type === "MemberExpression" &&
+    !node.left.computed &&
+    node.left.property.type === "Identifier" &&
+    node.left.property.name === "length" &&
+    node.right.type === "Literal" &&
+    node.right.value === 0
+  );
+}
+
+function walkSharedMutations(node, handlers) {
+  if (isFunctionNode(node) && !isCalledFunction(node)) return;
+  if (node.type === "AssignmentExpression") {
+    handlers.onAssignment(node);
+  } else if (node.type === "UpdateExpression") {
+    handlers.onUpdate(node);
+  } else if (node.type === "CallExpression") {
+    handlers.onCall(node);
+  }
+  for (const child of childNodes(node)) walkSharedMutations(child, handlers);
+}
+
+function createViMockTracker(context, mutableTopLevel) {
+  const factoryReferences = new Set();
+  const capturedMutables = new Set();
+
+  function markIfCaptured(name) {
+    if (name.startsWith("mock") && mutableTopLevel.has(name) && factoryReferences.has(name)) {
+      capturedMutables.add(name);
+    }
+  }
+
+  return {
+    collectFactoryReferences(node) {
+      if (
+        node.callee.type !== "MemberExpression" ||
+        node.callee.object.type !== "Identifier" ||
+        node.callee.object.name !== "vi" ||
+        node.callee.property.type !== "Identifier" ||
+        node.callee.property.name !== "mock"
+      ) {
+        return;
+      }
+      const factory = node.arguments[1];
+      if (!isFunctionNode(factory)) return;
+      for (const { identifier } of context.sourceCode.getScope(factory).through) {
+        factoryReferences.add(identifier.name);
+        markIfCaptured(identifier.name);
+      }
+    },
+    isCaptured(name) {
+      return capturedMutables.has(name);
+    },
+    markIfCaptured,
+  };
+}
+
+function createRegistryReports(context, mutableTopLevel, cleanupTracker, isCaptured) {
+  const pending = [];
+
+  return {
+    flush() {
+      for (const { node, path, suiteKey } of pending) {
+        if (!cleanupTracker.has(path, suiteKey)) context.report({ node, messageId: "shared" });
+      }
+    },
+    remember(node, name, path, testDepth, setupDepth) {
+      if (
+        name &&
+        testDepth > 0 &&
+        setupDepth === 0 &&
+        !isCaptured(name) &&
+        isModuleMutable(context, mutableTopLevel, node, name)
+      ) {
+        pending.push({ node, path, suiteKey: cleanupTracker.currentSuiteKey() });
+      }
+    },
+  };
+}
+
+module.exports = {
+  createRegistryReports,
+  createViMockTracker,
+  isInsideUncalledNestedFunction,
+  isModuleMutable,
+  isResetAssignment,
+  walkSharedMutations,
+};

package/src/rules/test-no-shared-state-helpers.js

@@ -23,6 +23,15 @@ function isTestCall(node) {
   return TEST_CALLEES.has(calleeName(node.callee));
 }
 
+function setupCallbackKind(node) {
+  const name = calleeName(node.callee);
+  return name === "beforeEach" || name === "afterEach"
+    ? "per-test"
+    : name === "beforeAll" || name === "afterAll"
+      ? "once"
+      : null;
+}
+
 function isSetupCall(node) {
   return SETUP_CALLEES.has(calleeName(node.callee));
 }
@@ -57,11 +66,30 @@ function propertyName(node) {
   return node.type === "Literal" ? String(node.value) : node.name;
 }
 
-function mutatingCallRootName(node) {
-  return node.callee.type === "MemberExpression" &&
-    MUTATING_METHODS.has(propertyName(node.callee.property))
-    ? mutationRootName(node.callee.object)
-    : null;
+function mutationPath(node) {
+  if (node.type === "Identifier") return node.name;
+  if (node.type !== "MemberExpression") return null;
+  const objectPath = mutationPath(node.object);
+  const property =
+    node.computed && node.property.type !== "Literal" ? null : propertyName(node.property);
+  return objectPath && property ? `${objectPath}.${property}` : null;
+}
+
+function mutatingCallTarget(node) {
+  if (
+    node.callee.type !== "MemberExpression" ||
+    !MUTATING_METHODS.has(propertyName(node.callee.property))
+  ) {
+    return { name: null, path: null };
+  }
+  return {
+    name: mutationRootName(node.callee.object),
+    path: mutationPath(node.callee.object),
+  };
+}
+
+function mutatingCallPropertyName(node) {
+  return node.callee.type === "MemberExpression" ? propertyName(node.callee.property) : null;
 }
 
 function isFunctionNode(node) {
@@ -72,6 +100,10 @@ function isInlineTestCallback(node) {
   return node.parent?.type === "CallExpression" && isTestCall(node.parent);
 }
 
+function isInlineSetupCallback(node) {
+  return node.parent?.type === "CallExpression" && isSetupCall(node.parent);
+}
+
 function isCalledFunction(node) {
   if (node.parent?.type === "CallExpression" && node.parent.callee === node) return true;
   const declarator = node.parent?.type === "VariableDeclarator" ? node.parent : null;
@@ -116,16 +148,78 @@ function namedCallbackArgument(args) {
   }
 }
 
+function firstNamedCallbackArgument(args) {
+  return args[0]?.type === "Identifier" ? args[0] : undefined;
+}
+
+function createCleanupTracker() {
+  const pathsBySuite = new Map();
+  const suiteStack = [];
+  let activeSuiteKey;
+  let replaySuiteKey;
+  let nextSuiteId = 0;
+
+  function currentSuiteKey() {
+    return replaySuiteKey ?? suiteStack.join("/");
+  }
+
+  function has(path, suiteKey) {
+    if (!path) return false;
+    for (const [cleanupSuiteKey, paths] of pathsBySuite) {
+      if (!paths.has(path)) continue;
+      if (!cleanupSuiteKey || suiteKey === cleanupSuiteKey) return true;
+      if (suiteKey.startsWith(`${cleanupSuiteKey}/`)) return true;
+    }
+    return false;
+  }
+
+  return {
+    beginSetup(kind, suiteKey = currentSuiteKey()) {
+      activeSuiteKey = kind === "per-test" ? suiteKey : undefined;
+    },
+    clearReplaySuite() {
+      replaySuiteKey = undefined;
+    },
+    currentSuiteKey,
+    endSetup() {
+      activeSuiteKey = undefined;
+    },
+    enterSuite() {
+      suiteStack.push(String(nextSuiteId++));
+    },
+    exitSuite() {
+      suiteStack.pop();
+    },
+    has,
+    remember(path) {
+      if (!path || activeSuiteKey === undefined) return;
+      const paths = pathsBySuite.get(activeSuiteKey) ?? new Set();
+      paths.add(path);
+      pathsBySuite.set(activeSuiteKey, paths);
+    },
+    setReplaySuite(suiteKey) {
+      replaySuiteKey = suiteKey;
+    },
+  };
+}
+
 module.exports = {
   childNodes,
   collectPatternNames,
+  createCleanupTracker,
+  firstNamedCallbackArgument,
   isCalledFunction,
   isFunctionNode,
+  isInlineSetupCallback,
   isInlineTestCallback,
   isMutableInitializer,
+  calleeName,
   isSetupCall,
   isTestCall,
-  mutatingCallRootName,
+  mutatingCallPropertyName,
+  mutatingCallTarget,
+  mutationPath,
   mutationRootName,
   namedCallbackArgument,
+  setupCallbackKind,
 };

package/src/rules/test-no-shared-state.js

@@ -2,17 +2,27 @@
 
 const { rule } = require("../helpers");
 const {
-  childNodes,
+  createRegistryReports,
+  createViMockTracker,
+  isInsideUncalledNestedFunction,
+  isModuleMutable,
+  isResetAssignment,
+  walkSharedMutations,
+} = require("./test-no-shared-state-analysis");
+const {
+  calleeName,
   collectPatternNames,
-  isCalledFunction,
+  createCleanupTracker,
+  firstNamedCallbackArgument,
   isFunctionNode,
-  isInlineTestCallback,
   isMutableInitializer,
-  isSetupCall,
   isTestCall,
-  mutatingCallRootName,
+  mutatingCallPropertyName,
+  mutatingCallTarget,
+  mutationPath,
   mutationRootName,
   namedCallbackArgument,
+  setupCallbackKind,
 } = require("./test-no-shared-state-helpers");
 
 module.exports = rule(
@@ -27,45 +37,26 @@ module.exports = rule(
   },
   (context) => {
     const mutableTopLevel = new Set();
-    const functionDeclarations = new Map();
     const pendingNamedCallbacks = [];
-    const viMockFactoryReferences = new Set();
-    const viMockCapturedMutables = new Set();
+    const pendingNamedSetupCallbacks = [];
+    const cleanupTracker = createCleanupTracker();
+    const viMockTracker = createViMockTracker(context, mutableTopLevel);
+    const registryReports = createRegistryReports(
+      context,
+      mutableTopLevel,
+      cleanupTracker,
+      (name) => viMockTracker.isCaptured(name),
+    );
     let testDepth = 0;
     let setupDepth = 0;
 
-    function markViMockCapturedMutable(name) {
-      if (
-        name.startsWith("mock") &&
-        mutableTopLevel.has(name) &&
-        viMockFactoryReferences.has(name)
-      ) {
-        viMockCapturedMutables.add(name);
-      }
-    }
-
-    function isModuleMutable(node, name) {
-      let scope = context.sourceCode.getScope(node);
-      while (scope) {
-        const variable = scope.variables.find((candidate) => candidate.name === name);
-        if (variable) {
-          return (
-            mutableTopLevel.has(variable.name) &&
-            (variable.scope.type === "module" || variable.scope.block.type === "Program")
-          );
-        }
-        scope = scope.upper;
-      }
-      return false;
-    }
-
     function reportIfShared(node, name) {
       if (
         name &&
         testDepth > 0 &&
         setupDepth === 0 &&
-        !viMockCapturedMutables.has(name) &&
-        isModuleMutable(node, name)
+        !viMockTracker.isCaptured(name) &&
+        isModuleMutable(context, mutableTopLevel, node, name)
       ) {
         context.report({ node, messageId: "shared" });
       }
@@ -77,95 +68,141 @@ module.exports = rule(
       reportIfShared(node, mutationRootName(node.left));
     }
 
+    function rememberSetupCleanup(node, name, path) {
+      if (
+        name &&
+        setupDepth > 0 &&
+        mutableTopLevel.has(name) &&
+        isModuleMutable(context, mutableTopLevel, node, name)
+      ) {
+        cleanupTracker.remember(path);
+      }
+    }
+
+    function rememberCall(node) {
+      const { name, path } = mutatingCallTarget(node);
+      if (mutatingCallPropertyName(node) === "clear") {
+        rememberSetupCleanup(node, name, path);
+      }
+      registryReports.remember(node, name, path, testDepth, setupDepth);
+    }
+
+    function rememberAssignmentCleanup(node) {
+      if (setupDepth === 0) return;
+      if (!isResetAssignment(node, isMutableInitializer)) return;
+      if (node.left.type === "Identifier") {
+        rememberSetupCleanup(node, node.left.name, node.left.name);
+        return;
+      }
+      rememberSetupCleanup(node, mutationRootName(node.left), mutationPath(node.left.object));
+    }
+
+    function resolveFunctionCallback(node, callback) {
+      let scope = context.sourceCode.getScope(node);
+      while (scope) {
+        const variable = scope.variables.find((candidate) => candidate.name === callback.name);
+        const declaration = variable?.defs[0]?.node;
+        if (declaration?.type === "FunctionDeclaration") return declaration;
+        if (declaration?.type === "VariableDeclarator" && isFunctionNode(declaration.init)) {
+          return declaration.init;
+        }
+        scope = scope.upper;
+      }
+      return null;
+    }
+
     return {
       "Program > VariableDeclaration"(node) {
         for (const declaration of node.declarations) {
-          if (declaration.id.type === "Identifier" && isFunctionNode(declaration.init)) {
-            functionDeclarations.set(declaration.id.name, declaration.init);
-          }
           if (node.kind === "const" && !isMutableInitializer(declaration.init)) continue;
           for (const name of collectPatternNames(declaration.id)) {
             mutableTopLevel.add(name);
-            markViMockCapturedMutable(name);
+            viMockTracker.markIfCaptured(name);
           }
         }
       },
-      "Program > FunctionDeclaration"(node) {
-        if (node.id?.name) functionDeclarations.set(node.id.name, node);
-      },
       "Program:exit"() {
+        for (const { declaration, suiteKey, kind } of pendingNamedSetupCallbacks) {
+          if (!declaration) continue;
+          const previousSetupDepth = setupDepth;
+          setupDepth = 1;
+          cleanupTracker.beginSetup(kind, suiteKey);
+          checkSharedMutations(declaration.body);
+          setupDepth = previousSetupDepth;
+          cleanupTracker.endSetup();
+        }
         testDepth = 1;
-        for (const name of pendingNamedCallbacks) {
-          const declaration = functionDeclarations.get(name);
-          if (declaration) checkSharedMutations(declaration.body);
+        for (const { declaration, suiteKey } of pendingNamedCallbacks) {
+          if (!declaration) continue;
+          cleanupTracker.setReplaySuite(suiteKey);
+          checkSharedMutations(declaration.body);
+          cleanupTracker.clearReplaySuite();
         }
+        registryReports.flush();
       },
       CallExpression(node) {
-        collectViMockFactoryReferences(node);
+        viMockTracker.collectFactoryReferences(node);
+        if (calleeName(node.callee) === "describe") cleanupTracker.enterSuite();
         if (isTestCall(node)) {
           testDepth += 1;
           const callback = namedCallbackArgument(node.arguments);
-          if (callback) pendingNamedCallbacks.push(callback.name);
+          if (callback) {
+            pendingNamedCallbacks.push({
+              declaration: resolveFunctionCallback(node, callback),
+              suiteKey: cleanupTracker.currentSuiteKey(),
+            });
+          }
+        }
+        const setupKind = setupCallbackKind(node);
+        if (setupKind) {
+          const callback = firstNamedCallbackArgument(node.arguments);
+          if (callback) {
+            pendingNamedSetupCallbacks.push({
+              declaration: resolveFunctionCallback(node, callback),
+              suiteKey: cleanupTracker.currentSuiteKey(),
+              kind: setupKind,
+            });
+          }
+        }
+        if (setupKind) {
+          setupDepth += 1;
+          cleanupTracker.beginSetup(setupKind);
         }
-        if (isSetupCall(node)) setupDepth += 1;
       },
       AssignmentExpression(node) {
-        if (isInsideUncalledNestedFunction(node)) return;
+        if (isInsideUncalledNestedFunction(node, testDepth, setupDepth)) return;
+        rememberAssignmentCleanup(node);
         reportAssignment(node);
       },
       UpdateExpression(node) {
-        if (isInsideUncalledNestedFunction(node)) return;
+        if (isInsideUncalledNestedFunction(node, testDepth, setupDepth)) return;
         reportIfShared(node, mutationRootName(node.argument));
       },
       "CallExpression:exit"(node) {
         if (isTestCall(node)) testDepth -= 1;
-        if (isSetupCall(node)) setupDepth -= 1;
-        if (isInsideUncalledNestedFunction(node)) return;
-        reportIfShared(node, mutatingCallRootName(node));
+        if (setupCallbackKind(node)) {
+          setupDepth -= 1;
+          cleanupTracker.endSetup();
+        }
+        const isInsideNested = isInsideUncalledNestedFunction(node, testDepth, setupDepth);
+        if (!isInsideNested) {
+          rememberCall(node);
+        }
+        if (calleeName(node.callee) === "describe") cleanupTracker.exitSuite();
       },
     };
 
-    function isInsideUncalledNestedFunction(node) {
-      if (testDepth === 0) return false;
-      let current = node.parent;
-      while (current) {
-        const isUncalledFunction =
-          isFunctionNode(current) && !isInlineTestCallback(current) && !isCalledFunction(current);
-        if (isUncalledFunction) return true;
-        current = current.parent;
-      }
-      return false;
-    }
-
     function checkSharedMutations(node) {
-      if (isFunctionNode(node) && !isCalledFunction(node)) return;
-      if (node.type === "AssignmentExpression") {
-        reportAssignment(node);
-      } else if (node.type === "UpdateExpression") {
-        reportIfShared(node, mutationRootName(node.argument));
-      } else if (node.type === "CallExpression") {
-        reportIfShared(node, mutatingCallRootName(node));
-      }
-      for (const child of childNodes(node)) checkSharedMutations(child);
-    }
-
-    function collectViMockFactoryReferences(node) {
-      if (
-        node.callee.type !== "MemberExpression" ||
-        node.callee.object.type !== "Identifier" ||
-        node.callee.object.name !== "vi" ||
-        node.callee.property.type !== "Identifier" ||
-        node.callee.property.name !== "mock"
-      ) {
-        return;
-      }
-      const factory = node.arguments[1];
-      if (!isFunctionNode(factory)) return;
-      for (const { identifier } of context.sourceCode.getScope(factory).through) {
-        const name = identifier.name;
-        viMockFactoryReferences.add(name);
-        markViMockCapturedMutable(name);
-      }
+      walkSharedMutations(node, {
+        onAssignment: (assignment) => {
+          rememberAssignmentCleanup(assignment);
+          reportAssignment(assignment);
+        },
+        onCall: (call) => {
+          rememberCall(call);
+        },
+        onUpdate: (update) => reportIfShared(update, mutationRootName(update.argument)),
+      });
     }
   },
 );

package/src/rules/ts-no-export-renaming.js

@@ -12,6 +12,35 @@ function isTypeExport(node, specifier) {
   return node.exportKind === "type" || specifier.exportKind === "type";
 }
 
+function pathPatterns(options) {
+  return (options.includePathPatterns || []).flatMap((pattern) => {
+    try {
+      return [new RegExp(pattern)];
+    } catch {
+      return [];
+    }
+  });
+}
+
+function normalizedPaths(context) {
+  const normalized = context.filename.replace(/\\/g, "/");
+  const cwd = context.cwd?.replace(/\\/g, "/");
+  if (cwd && normalized.startsWith(`${cwd}/`)) {
+    return [normalized.slice(cwd.length + 1), normalized];
+  }
+  return [normalized];
+}
+
+function shouldCheckFile(context, options, patterns) {
+  if ((options.includePathPatterns || []).length > 0 && patterns.length === 0) return false;
+  if (patterns.length === 0) return true;
+  return normalizedPaths(context).some((path) => patterns.some((pattern) => pattern.test(path)));
+}
+
+function isDefaultReExportAlias(node, specifier) {
+  return exportName(specifier.local) === "default" && Boolean(node.source);
+}
+
 module.exports = rule(
   {
     type: "problem",
@@ -19,24 +48,41 @@ module.exports = rule(
       description: "disallow value export renaming",
       recommended: true,
     },
-    schema: [],
     messages: {
       renamed:
         "Do not rename value exports. Export the original name or rename the declaration itself so agents can trace symbols directly.",
     },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowDefaultReExports: { type: "boolean" },
+          includePathPatterns: { type: "array", items: { type: "string" } },
+        },
+        additionalProperties: false,
+      },
+    ],
   },
-  (context) => ({
-    ExportNamedDeclaration(node) {
-      for (const specifier of node.specifiers || []) {
-        if (specifier.type !== "ExportSpecifier" || isTypeExport(node, specifier)) {
-          continue;
-        }
-        const local = exportName(specifier.local);
-        const exported = exportName(specifier.exported);
-        if (local && exported && local !== exported) {
-          context.report({ node: specifier, messageId: "renamed" });
+  (context) => {
+    const options = context.options[0] || {};
+    const patterns = pathPatterns(options);
+    if (!shouldCheckFile(context, options, patterns)) return {};
+    return {
+      ExportNamedDeclaration(node) {
+        for (const specifier of node.specifiers || []) {
+          if (specifier.type !== "ExportSpecifier" || isTypeExport(node, specifier)) {
+            continue;
+          }
+          if (options.allowDefaultReExports && isDefaultReExportAlias(node, specifier)) {
+            continue;
+          }
+          const local = exportName(specifier.local);
+          const exported = exportName(specifier.exported);
+          if (local && exported && local !== exported) {
+            context.report({ node: specifier, messageId: "renamed" });
+          }
         }
-      }
-    },
-  }),
+      },
+    };
+  },
 );

package/src/rules/ts-no-function-aliases.js

@@ -56,6 +56,8 @@ function isSameArgumentList(params, args) {
 
 function isSelfCall(node, call) {
   if (call.callee.type !== "Identifier") return false;
+  const wrapper = variableWrapperName(node);
+  if (wrapper) return wrapper === call.callee.name;
   if (node.id && node.id.name === call.callee.name) return true;
   const parent = node.parent;
   return (
@@ -66,7 +68,36 @@ function isSelfCall(node, call) {
   );
 }
 
+function assignmentWrapperName(node) {
+  if (node.parent?.type !== "AssignmentExpression" || node.parent.right !== node) return null;
+  const left = node.parent.left;
+  if (left.type === "Identifier") return left.name;
+  if (left.type === "MemberExpression" && !left.computed) return identifierName(left.property);
+  if (left.type === "MemberExpression" && left.property.type === "Literal") {
+    return String(left.property.value);
+  }
+  return null;
+}
+
+function variableWrapperName(node) {
+  return node.parent?.type === "VariableDeclarator" && node.parent.id.type === "Identifier"
+    ? node.parent.id.name
+    : null;
+}
+
+function wrapperName(node) {
+  return variableWrapperName(node) || assignmentWrapperName(node);
+}
+
+function isNamedWrapper(node) {
+  if (node.type === "FunctionDeclaration") {
+    return true;
+  }
+  return Boolean(wrapperName(node));
+}
+
 function reportIfAlias(node, context) {
+  if (!isNamedWrapper(node)) return;
   const call = onlyCallExpression(node.body);
   if (!call || call.type !== "CallExpression") return;
   if (isSelfCall(node, call)) return;

package/src/rules/vitest-mock-test-file-naming.js

@@ -5,6 +5,7 @@ const { rule } = require("../helpers");
 const TEST_FILE_PATTERN = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
 const MOCK_TEST_FILE_PATTERN = /\.mock\.test\.[cm]?[jt]sx?$/;
 const MOCK_METHODS = new Set([
+  "fn",
   "mock",
   "doMock",
   "unmock",