eslint-plugin-no-mistakes 0.61.11 → 0.63.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.61.11",
+  "version": "0.63.0",
   "description": "ESLint and Oxlint rules that keep code static enough for no-mistakes analyzers and coding agents",
   "license": "MIT",
   "repository": {
@@ -21,11 +21,11 @@
     "test": "vitest run --coverage"
   },
   "devDependencies": {
-    "@typescript-eslint/parser": "^8.68.0",
-    "@vitest/coverage-v8": "^4.1.11",
-    "eslint": "^10.9.1",
-    "oxlint": "^1.80.0",
-    "vitest": "^4.1.11"
+    "@typescript-eslint/parser": "^8.69.0",
+    "@vitest/coverage-v8": "^5.0.0",
+    "eslint": "^10.10.0",
+    "oxlint": "^1.82.0",
+    "vitest": "^5.0.0"
   },
   "peerDependencies": {
     "eslint": ">=9"

package/src/exported-components.js

@@ -195,4 +195,5 @@ module.exports = {
   collectExportedComponents,
   normalizedComponentOptions,
   shouldCheckComponent,
+  uniqueComponents,
 };

package/src/rules/module-mock-integration.js

@@ -210,4 +210,5 @@ function integrationAllows(specifier, factory, mock, context, options) {
 
 module.exports = {
   integrationAllows,
+  mockedExportNames,
 };

package/src/rules/nextjs-metadata-exports-location.js

@@ -48,49 +48,52 @@ function collectPatternNames(node, names = new Set()) {
   return names;
 }
 
-module.exports = rule(
-  {
-    type: "problem",
-    docs: {
-      description: "restrict Next.js metadata exports to route segment files",
-      recommended: false,
+module.exports = Object.assign(
+  rule(
+    {
+      type: "problem",
+      docs: {
+        description: "restrict Next.js metadata exports to route segment files",
+        recommended: false,
+      },
+      schema: [],
+      messages: {
+        location:
+          "metadata and generateMetadata exports are only allowed in Next.js route segment files.",
+      },
     },
-    schema: [],
-    messages: {
-      location:
-        "metadata and generateMetadata exports are only allowed in Next.js route segment files.",
-    },
-  },
-  (context) => ({
-    ExportNamedDeclaration(node) {
-      if (!isNextFile(context.filename)) return;
-      if (isAllowedFile(context.filename)) return;
-      if (node.declaration?.type === "VariableDeclaration") {
+    (context) => ({
+      ExportNamedDeclaration(node) {
+        if (!isNextFile(context.filename)) return;
+        if (isAllowedFile(context.filename)) return;
+        if (node.declaration?.type === "VariableDeclaration") {
+          if (
+            node.declaration.declarations.some((declaration) =>
+              [...collectPatternNames(declaration.id), declarationName(declaration)].some((name) =>
+                METADATA_EXPORTS.has(name),
+              ),
+            )
+          ) {
+            context.report({ node, messageId: "location" });
+          }
+        }
         if (
-          node.declaration.declarations.some((declaration) =>
-            [...collectPatternNames(declaration.id), declarationName(declaration)].some((name) =>
-              METADATA_EXPORTS.has(name),
-            ),
+          node.declaration?.type === "FunctionDeclaration" &&
+          METADATA_EXPORTS.has(declarationName(node.declaration))
+        ) {
+          context.report({ node, messageId: "location" });
+        }
+        if (
+          node.exportKind !== "type" &&
+          node.specifiers?.some(
+            (specifier) =>
+              specifier.exportKind !== "type" && METADATA_EXPORTS.has(specifierName(specifier)),
           )
         ) {
           context.report({ node, messageId: "location" });
         }
-      }
-      if (
-        node.declaration?.type === "FunctionDeclaration" &&
-        METADATA_EXPORTS.has(declarationName(node.declaration))
-      ) {
-        context.report({ node, messageId: "location" });
-      }
-      if (
-        node.exportKind !== "type" &&
-        node.specifiers?.some(
-          (specifier) =>
-            specifier.exportKind !== "type" && METADATA_EXPORTS.has(specifierName(specifier)),
-        )
-      ) {
-        context.report({ node, messageId: "location" });
-      }
-    },
-  }),
+      },
+    }),
+  ),
+  { __test: { specifierName, collectPatternNames } },
 );

package/src/rules/nextjs-no-manual-script-tags.js

@@ -65,39 +65,42 @@ function isAllowedInlineScript(node, options, patterns) {
   );
 }
 
-module.exports = rule(
-  {
-    type: "problem",
-    docs: { description: "prefer next/script over raw script JSX tags", recommended: false },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          allowInlineScriptIds: { type: "array", items: { type: "string" } },
-          allowInlineScriptIdPatterns: { type: "array", items: { type: "string" } },
+module.exports = Object.assign(
+  rule(
+    {
+      type: "problem",
+      docs: { description: "prefer next/script over raw script JSX tags", recommended: false },
+      schema: [
+        {
+          type: "object",
+          properties: {
+            allowInlineScriptIds: { type: "array", items: { type: "string" } },
+            allowInlineScriptIdPatterns: { type: "array", items: { type: "string" } },
+          },
+          additionalProperties: false,
         },
-        additionalProperties: false,
-      },
-    ],
-    messages: { script: "Use next/script instead of a raw <script> tag." },
-  },
-  (context) => {
-    const options = context.options[0] || {};
-    const patterns = allowedIdPatterns(options);
-    let isNextFile = isNextPath(context.filename);
-    return {
-      ImportDeclaration(node) {
-        if (typeof node.source.value === "string" && node.source.value.startsWith("next/")) {
-          isNextFile = true;
-        }
-      },
-      JSXOpeningElement(node) {
-        if (!isNextFile) return;
-        if (node.name.type !== "JSXIdentifier" || node.name.name !== "script") return;
-        if (isJsonLdScript(node)) return;
-        if (isAllowedInlineScript(node, options, patterns)) return;
-        context.report({ node, messageId: "script" });
-      },
-    };
-  },
+      ],
+      messages: { script: "Use next/script instead of a raw <script> tag." },
+    },
+    (context) => {
+      const options = context.options[0] || {};
+      const patterns = allowedIdPatterns(options);
+      let isNextFile = isNextPath(context.filename);
+      return {
+        ImportDeclaration(node) {
+          if (typeof node.source.value === "string" && node.source.value.startsWith("next/")) {
+            isNextFile = true;
+          }
+        },
+        JSXOpeningElement(node) {
+          if (!isNextFile) return;
+          if (node.name.type !== "JSXIdentifier" || node.name.name !== "script") return;
+          if (isJsonLdScript(node)) return;
+          if (isAllowedInlineScript(node, options, patterns)) return;
+          context.report({ node, messageId: "script" });
+        },
+      };
+    },
+  ),
+  { __test: { attributeValue } },
 );

package/src/rules/no-banned-import-outside-allowed-paths-aliases.js

@@ -190,4 +190,6 @@ module.exports = {
   recordAssignmentTag,
   recordVariableTag,
   setOrClearTag,
+  collectPossibleTag,
+  applyObjectPatternTagAddOnly,
 };

package/src/rules/no-banned-import-outside-allowed-paths-scopes.js

@@ -84,7 +84,7 @@ function createAliasScopeTracker() {
   }
 
   function exitsSwitchCase(node) {
-    return node.consequent?.some(terminatesCase) ?? false;
+    return node.consequent?.some(terminatesCase) === true;
   }
 
   function exitSwitchCase(node) {

package/src/rules/no-global-fetch-outside-helper.js

@@ -112,7 +112,7 @@ module.exports = Object.assign(
               child.type === "BreakStatement" ||
               child.type === "ReturnStatement" ||
               child.type === "ThrowStatement",
-          ) ?? false
+          ) === true
         );
       }
 

package/src/rules/no-placeholder-never-type-exports.js

@@ -6,46 +6,49 @@ function specifierName(specifier) {
   return specifier.local?.name || specifier.exported?.name || specifier.exported?.value;
 }
 
-module.exports = rule(
-  {
-    type: "problem",
-    docs: { description: "disallow exported never placeholder type aliases", recommended: false },
-    schema: [],
-    messages: {
-      placeholder:
-        "Do not export placeholder never types. Define the real type or remove the export.",
-    },
-  },
-  (context) => {
-    const neverTypes = new Set();
-    const exportSpecifiers = [];
-    return {
-      "Program > TSTypeAliasDeclaration"(node) {
-        if (node.typeAnnotation?.type === "TSNeverKeyword") neverTypes.add(node.id.name);
+module.exports = Object.assign(
+  rule(
+    {
+      type: "problem",
+      docs: { description: "disallow exported never placeholder type aliases", recommended: false },
+      schema: [],
+      messages: {
+        placeholder:
+          "Do not export placeholder never types. Define the real type or remove the export.",
       },
-      "Program:exit"() {
-        for (const node of exportSpecifiers) {
-          if (node.specifiers.some((specifier) => neverTypes.has(specifierName(specifier)))) {
+    },
+    (context) => {
+      const neverTypes = new Set();
+      const exportSpecifiers = [];
+      return {
+        "Program > TSTypeAliasDeclaration"(node) {
+          if (node.typeAnnotation?.type === "TSNeverKeyword") neverTypes.add(node.id.name);
+        },
+        "Program:exit"() {
+          for (const node of exportSpecifiers) {
+            if (node.specifiers.some((specifier) => neverTypes.has(specifierName(specifier)))) {
+              context.report({ node, messageId: "placeholder" });
+            }
+          }
+        },
+        ExportNamedDeclaration(node) {
+          const declaration = node.declaration;
+          if (declaration?.type === "TSTypeAliasDeclaration") {
+            if (declaration.typeAnnotation?.type !== "TSNeverKeyword") return;
             context.report({ node, messageId: "placeholder" });
+            return;
           }
-        }
-      },
-      ExportNamedDeclaration(node) {
-        const declaration = node.declaration;
-        if (declaration?.type === "TSTypeAliasDeclaration") {
-          if (declaration.typeAnnotation?.type !== "TSNeverKeyword") return;
-          context.report({ node, messageId: "placeholder" });
-          return;
-        }
-        if (
-          !node.source &&
-          node.specifiers?.some(
-            (specifier) => node.exportKind === "type" || specifier.exportKind === "type",
-          )
-        ) {
-          exportSpecifiers.push(node);
-        }
-      },
-    };
-  },
+          if (
+            !node.source &&
+            node.specifiers?.some(
+              (specifier) => node.exportKind === "type" || specifier.exportKind === "type",
+            )
+          ) {
+            exportSpecifiers.push(node);
+          }
+        },
+      };
+    },
+  ),
+  { __test: { specifierName } },
 );

package/src/rules/no-vitest-sequential.js

@@ -49,29 +49,32 @@ function hasSequentialOption(node) {
     );
 }
 
-module.exports = rule(
-  {
-    type: "problem",
-    docs: { description: "disallow Vitest sequential test modifiers", recommended: false },
-    schema: [],
-    messages: { sequential: "Use parallel tests instead of .sequential." },
-  },
-  (context) => {
-    let usesVitestImport = false;
-    return {
-      ImportDeclaration(node) {
-        if (node.source.value === "vitest") usesVitestImport = true;
-      },
-      CallExpression(node) {
-        if (!isTestFile(context.filename) && !usesVitestImport) return;
-        if (!TEST_NAMES.has(rootTestName(node.callee))) return;
-        if (node.callee.type === "MemberExpression" && hasSequentialMember(node.callee)) {
+module.exports = Object.assign(
+  rule(
+    {
+      type: "problem",
+      docs: { description: "disallow Vitest sequential test modifiers", recommended: false },
+      schema: [],
+      messages: { sequential: "Use parallel tests instead of .sequential." },
+    },
+    (context) => {
+      let usesVitestImport = false;
+      return {
+        ImportDeclaration(node) {
+          if (node.source.value === "vitest") usesVitestImport = true;
+        },
+        CallExpression(node) {
+          if (!isTestFile(context.filename) && !usesVitestImport) return;
+          if (!TEST_NAMES.has(rootTestName(node.callee))) return;
+          if (node.callee.type === "MemberExpression" && hasSequentialMember(node.callee)) {
+            context.report({ node: node.callee, messageId: "sequential" });
+            return;
+          }
+          if (!hasSequentialOption(node)) return;
           context.report({ node: node.callee, messageId: "sequential" });
-          return;
-        }
-        if (!hasSequentialOption(node)) return;
-        context.report({ node: node.callee, messageId: "sequential" });
-      },
-    };
-  },
+        },
+      };
+    },
+  ),
+  { __test: { hasSequentialMember } },
 );

package/src/rules/playwright-assertion-timeout-cap.js

@@ -52,48 +52,50 @@ function numericLiteral(node) {
 }
 
 function propertyName(node) {
-  if (!node) return null;
   if (node.type === "Identifier") return node.name;
   return node.type === "Literal" ? String(node.value) : null;
 }
 
-module.exports = rule(
-  {
-    type: "problem",
-    docs: { description: "cap Playwright assertion timeouts", recommended: false },
-    schema: [
-      {
-        type: "object",
-        properties: { max: { type: "number" } },
-        additionalProperties: false,
+module.exports = Object.assign(
+  rule(
+    {
+      type: "problem",
+      docs: { description: "cap Playwright assertion timeouts", recommended: false },
+      schema: [
+        {
+          type: "object",
+          properties: { max: { type: "number" } },
+          additionalProperties: false,
+        },
+      ],
+      messages: {
+        timeout:
+          "Assertion timeout must not exceed {{max}} ms. Increase the test timeout or fix the slow condition instead.",
       },
-    ],
-    messages: {
-      timeout:
-        "Assertion timeout must not exceed {{max}} ms. Increase the test timeout or fix the slow condition instead.",
     },
-  },
-  (context) => {
-    const max = context.options[0]?.max ?? DEFAULT_MAX_TIMEOUT_MS;
-    let isPlaywrightFile = isPlaywrightPath(context.filename);
-    return {
-      ImportDeclaration(node) {
-        if (node.source.value === "@playwright/test") isPlaywrightFile = true;
-      },
-      CallExpression(node) {
-        if (!isPlaywrightFile) return;
-        if (node.callee.type !== "MemberExpression" || !isExpectChain(node.callee)) return;
-        const method = propertyName(node.callee.property);
-        if (!TIMEOUT_MATCHERS.has(method)) return;
-        const options = node.arguments.at(-1);
-        if (options?.type !== "ObjectExpression") return;
-        const timeout = options.properties.find(
-          (property) => property.type === "Property" && propertyName(property.key) === "timeout",
-        );
-        if (numericLiteral(timeout?.value) > max) {
-          context.report({ node, messageId: "timeout", data: { max } });
-        }
-      },
-    };
-  },
+    (context) => {
+      const max = context.options[0]?.max ?? DEFAULT_MAX_TIMEOUT_MS;
+      let isPlaywrightFile = isPlaywrightPath(context.filename);
+      return {
+        ImportDeclaration(node) {
+          if (node.source.value === "@playwright/test") isPlaywrightFile = true;
+        },
+        CallExpression(node) {
+          if (!isPlaywrightFile) return;
+          if (node.callee.type !== "MemberExpression" || !isExpectChain(node.callee)) return;
+          const method = propertyName(node.callee.property);
+          if (!TIMEOUT_MATCHERS.has(method)) return;
+          const options = node.arguments.at(-1);
+          if (options?.type !== "ObjectExpression") return;
+          const timeout = options.properties.find(
+            (property) => property.type === "Property" && propertyName(property.key) === "timeout",
+          );
+          if (numericLiteral(timeout?.value) > max) {
+            context.report({ node, messageId: "timeout", data: { max } });
+          }
+        },
+      };
+    },
+  ),
+  { __test: { propertyName } },
 );

package/src/rules/playwright-no-raw-scroll-pagination.js

@@ -28,7 +28,6 @@ function isPlaywrightPath(filename) {
 }
 
 function propertyName(node) {
-  if (!node) return null;
   return node.type === "Literal" ? String(node.value) : node.name;
 }
 
@@ -132,7 +131,6 @@ function hasQueryParamBoundary(literal, param, isRegex) {
 // runtime and must not be mistaken for an actual cursor-param check. The value-wrapper expressions
 // above recurse into their runtime `.expression` only, never a type operand.
 function collectLiteralStrings(node, results) {
-  if (!node) return;
   if (node.type.startsWith("TS")) {
     if (TS_VALUE_WRAPPER_TYPES.has(node.type)) collectLiteralStrings(node.expression, results);
     return;
@@ -158,7 +156,6 @@ function staticStringValue(node) {
 }
 
 function collectSearchParamsAccessorArgs(node, results) {
-  if (!node) return;
   if (node.type === "CallExpression" && isSearchParamsAccessorCall(node)) {
     const value = staticStringValue(node.arguments[0]);
     if (value !== null) results.push(value);

package/src/rules/playwright-require-interactive-test-id.js

@@ -126,3 +126,5 @@ function matchesAny(name, matchers) {
     }),
   );
 }
+
+module.exports.__test = { compileMatchers };

package/src/rules/react-no-nullish-react-node.js

@@ -13,7 +13,7 @@ function isIdentifier(node) {
 
 function definePattern(pattern, props, defineBinding, defineReactNode) {
   if (!isObjectPattern(pattern)) return;
-  for (const property of pattern.properties || []) {
+  for (const property of pattern.properties) {
     if (property.type !== "Property") continue;
     const name = keyName(property.key);
     if (isIdentifier(property.value)) {
@@ -63,7 +63,7 @@ module.exports = rule(
     function propsForType(type) {
       if (type && type.type === "TSTypeLiteral") {
         const props = new Set();
-        for (const member of type.members || []) {
+        for (const member of type.members) {
           if (member.type !== "TSPropertySignature" || !isReactNodeType(typeAnnotation(member))) {
             continue;
           }
@@ -161,7 +161,7 @@ module.exports = rule(
 
     function enterFunction(node) {
       pushScope("function");
-      for (const param of node.params || []) {
+      for (const param of node.params) {
         defineParam(param);
       }
     }

package/src/rules/test-no-delayed-rejects-loop-jumps.js

@@ -164,4 +164,4 @@ function possibleResourceExitBeforeMatcher(node, matcher, resourceLoop) {
   return false;
 }
 
-module.exports = { possibleResourceExitBeforeMatcher };
+module.exports = { possibleResourceExitBeforeMatcher, branchOutcome };

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

@@ -146,3 +146,5 @@ module.exports = rule(
     };
   },
 );
+
+module.exports.__test = { propertyName };

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

@@ -41,48 +41,51 @@ function isDefaultReExportAlias(node, specifier) {
   return exportName(specifier.local) === "default" && Boolean(node.source);
 }
 
-module.exports = rule(
-  {
-    type: "problem",
-    docs: {
-      description: "disallow value export renaming",
-      recommended: true,
-    },
-    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,
+module.exports = Object.assign(
+  rule(
+    {
+      type: "problem",
+      docs: {
+        description: "disallow value export renaming",
+        recommended: true,
       },
-    ],
-  },
-  (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" });
-          }
-        }
+      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) => {
+      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" });
+            }
+          }
+        },
+      };
+    },
+  ),
+  { __test: { exportName } },
 );

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

@@ -63,14 +63,7 @@ function isSelfCall(node, call) {
   if (!callee) return false;
   const wrapper = variableWrapperName(node);
   if (wrapper) return wrapper === callee;
-  if (node.id && node.id.name === callee) return true;
-  const parent = node.parent;
-  return (
-    parent &&
-    parent.type === "VariableDeclarator" &&
-    parent.id.type === "Identifier" &&
-    parent.id.name === callee
-  );
+  return Boolean(node.id && node.id.name === callee);
 }
 
 function assignmentWrapperName(node) {
@@ -112,28 +105,31 @@ function reportIfAlias(node, context) {
   }
 }
 
-module.exports = rule(
-  {
-    type: "problem",
-    docs: {
-      description: "disallow function wrappers that only alias another function",
-      recommended: true,
+module.exports = Object.assign(
+  rule(
+    {
+      type: "problem",
+      docs: {
+        description: "disallow function wrappers that only alias another function",
+        recommended: true,
+      },
+      schema: [],
+      messages: {
+        alias:
+          "Do not create a function that only aliases another function call. Export or call the original function name directly so agents can trace behavior.",
+      },
     },
-    schema: [],
-    messages: {
-      alias:
-        "Do not create a function that only aliases another function call. Export or call the original function name directly so agents can trace behavior.",
-    },
-  },
-  (context) => ({
-    ArrowFunctionExpression(node) {
-      reportIfAlias(node, context);
-    },
-    FunctionDeclaration(node) {
-      reportIfAlias(node, context);
-    },
-    FunctionExpression(node) {
-      reportIfAlias(node, context);
-    },
-  }),
+    (context) => ({
+      ArrowFunctionExpression(node) {
+        reportIfAlias(node, context);
+      },
+      FunctionDeclaration(node) {
+        reportIfAlias(node, context);
+      },
+      FunctionExpression(node) {
+        reportIfAlias(node, context);
+      },
+    }),
+  ),
+  { __test: { onlyCallExpression, isSelfCall } },
 );

package/src/rules/ts-preserve-null-option-defaults.js

@@ -58,7 +58,7 @@ module.exports = Object.assign(
       const popScope = () => scopes.pop();
       function enterFunction(node) {
         scopes.push(createScope("function"));
-        for (const param of node.params || []) defineParam(param);
+        for (const param of node.params) defineParam(param);
       }
       function defineBinding(name, scope = currentScope()) {
         scope.bindings.add(name);
@@ -82,7 +82,7 @@ module.exports = Object.assign(
         }
       }
       function definePatternBindings(pattern, props, scope = currentScope(), useExisting = false) {
-        for (const property of pattern.properties || []) {
+        for (const property of pattern.properties) {
           if (property.type === "RestElement" && isIdentifier(property.argument)) {
             defineObject(property.argument.name, props, scope);
             continue;