eslint-plugin-no-mistakes 0.7.0 → 0.8.0

package/package.json

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

package/src/helpers.js

@@ -109,7 +109,7 @@ function cssSelectorValues(source, attrs) {
   for (const attr of attrs) {
     const escaped = attr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const regex = new RegExp(
-      `\\[\\s*${escaped}\\s*([*^$]?=)\\s*(?:"([^"]*)"|'([^']*)'|([^\\s\\]]+))\\s*(?:[is])?\\s*\\]`,
+      `\\[\\s*${escaped}\\s*([*^$]?=)\\s*(?:"([^"]*)"|'([^']*)'|([^\\s\\]]+))(?:[is]|\\s+[is])?\\s*\\]`,
       "g",
     );
     let match = regex.exec(source);

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

@@ -1,6 +1,6 @@
 "use strict";
 
-const { rule } = require("../helpers");
+const { literalString, rule } = require("../helpers");
 
 const NEXT_FILE_PATTERN = /(?:^|[/\\])(?:app|pages)(?:[/\\]|$)/;
 
@@ -25,14 +25,65 @@ function isJsonLdScript(node) {
   });
 }
 
+function jsxAttribute(node, name) {
+  return node.attributes.find(
+    (attribute) =>
+      attribute.type === "JSXAttribute" &&
+      attribute.name.type === "JSXIdentifier" &&
+      attribute.name.name === name,
+  );
+}
+
+function attributeValue(attribute) {
+  const value =
+    attribute?.value?.type === "JSXExpressionContainer"
+      ? attribute.value.expression
+      : attribute?.value;
+  return value ? literalString(value) : null;
+}
+
+function hasAttribute(node, name) {
+  return Boolean(jsxAttribute(node, name));
+}
+
+function allowedIdPatterns(options) {
+  return (options.allowInlineScriptIdPatterns || []).flatMap((pattern) => {
+    try {
+      return [new RegExp(pattern)];
+    } catch {
+      return [];
+    }
+  });
+}
+
+function isAllowedInlineScript(node, options, patterns) {
+  if (!hasAttribute(node, "dangerouslySetInnerHTML")) return false;
+  const id = attributeValue(jsxAttribute(node, "id"));
+  if (!id) return false;
+  return (
+    (options.allowInlineScriptIds || []).includes(id) || patterns.some((regex) => regex.test(id))
+  );
+}
+
 module.exports = rule(
   {
     type: "problem",
     docs: { description: "prefer next/script over raw script JSX tags", recommended: false },
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowInlineScriptIds: { type: "array", items: { type: "string" } },
+          allowInlineScriptIdPatterns: { type: "array", items: { type: "string" } },
+        },
+        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) {
@@ -44,6 +95,7 @@ module.exports = rule(
         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" });
       },
     };

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

@@ -24,8 +24,8 @@ const MODIFIERS = new Set(
 const TEST_CALLEES = new Set(["it", "test"]);
 
 function propertyName(node) {
-  if (node.type === "Identifier") return node.name;
-  return node.type === "Literal" ? String(node.value) : null;
+  if (node?.type === "Identifier") return node.name;
+  return node?.type === "Literal" ? String(node.value) : null;
 }
 
 function unwrap(node) {
@@ -43,7 +43,23 @@ function unwrap(node) {
 
 function isMessageMember(node) {
   const current = unwrap(node);
-  return current?.type === "MemberExpression" && propertyName(current.property) === "message";
+  return (
+    current?.type === "MemberExpression" &&
+    propertyName(current.property) === "message" &&
+    !isBodyMember(current.object)
+  );
+}
+
+function isBodyMember(node) {
+  const current = unwrap(node);
+  return current?.type === "MemberExpression" && propertyName(current.property) === "body";
+}
+
+function isStaticAnalysisPath(filename) {
+  const normalized = filename.replace(/\\/g, "/");
+  return (
+    normalized.startsWith("static-code-analysis/") || normalized.includes("/static-code-analysis/")
+  );
 }
 
 function isExpectCall(node) {
@@ -83,6 +99,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 {};
     let testDepth = 0;
     return {
       CallExpression(node) {

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

@@ -1,6 +1,7 @@
 "use strict";
 
 const TEST_CALLEES = new Set(["it", "test", "describe"]);
+const SETUP_CALLEES = new Set(["beforeEach", "afterEach", "beforeAll", "afterAll"]);
 const MUTATING_METHODS = new Set(
   "add clear copyWithin delete fill pop push reverse set shift sort splice unshift".split(" "),
 );
@@ -22,6 +23,10 @@ function isTestCall(node) {
   return TEST_CALLEES.has(calleeName(node.callee));
 }
 
+function isSetupCall(node) {
+  return SETUP_CALLEES.has(calleeName(node.callee));
+}
+
 function collectPatternNames(node, names = new Set()) {
   if (!node) return names;
   if (node.type === "Identifier") {
@@ -118,6 +123,7 @@ module.exports = {
   isFunctionNode,
   isInlineTestCallback,
   isMutableInitializer,
+  isSetupCall,
   isTestCall,
   mutatingCallRootName,
   mutationRootName,

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

@@ -8,6 +8,7 @@ const {
   isFunctionNode,
   isInlineTestCallback,
   isMutableInitializer,
+  isSetupCall,
   isTestCall,
   mutatingCallRootName,
   mutationRootName,
@@ -28,7 +29,20 @@ module.exports = rule(
     const mutableTopLevel = new Set();
     const functionDeclarations = new Map();
     const pendingNamedCallbacks = [];
+    const viMockFactoryReferences = new Set();
+    const viMockCapturedMutables = new Set();
     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);
@@ -46,8 +60,15 @@ module.exports = rule(
     }
 
     function reportIfShared(node, name) {
-      if (name && testDepth > 0 && isModuleMutable(node, name))
+      if (
+        name &&
+        testDepth > 0 &&
+        setupDepth === 0 &&
+        !viMockCapturedMutables.has(name) &&
+        isModuleMutable(node, name)
+      ) {
         context.report({ node, messageId: "shared" });
+      }
     }
 
     function reportAssignment(node) {
@@ -63,7 +84,10 @@ module.exports = rule(
             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);
+          for (const name of collectPatternNames(declaration.id)) {
+            mutableTopLevel.add(name);
+            markViMockCapturedMutable(name);
+          }
         }
       },
       "Program > FunctionDeclaration"(node) {
@@ -77,11 +101,13 @@ module.exports = rule(
         }
       },
       CallExpression(node) {
+        collectViMockFactoryReferences(node);
         if (isTestCall(node)) {
           testDepth += 1;
           const callback = namedCallbackArgument(node.arguments);
           if (callback) pendingNamedCallbacks.push(callback.name);
         }
+        if (isSetupCall(node)) setupDepth += 1;
       },
       AssignmentExpression(node) {
         if (isInsideUncalledNestedFunction(node)) return;
@@ -93,6 +119,7 @@ module.exports = rule(
       },
       "CallExpression:exit"(node) {
         if (isTestCall(node)) testDepth -= 1;
+        if (isSetupCall(node)) setupDepth -= 1;
         if (isInsideUncalledNestedFunction(node)) return;
         reportIfShared(node, mutatingCallRootName(node));
       },
@@ -121,5 +148,24 @@ module.exports = rule(
       }
       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);
+      }
+    }
   },
 );

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

@@ -10,11 +10,11 @@ const MOCK_METHODS = new Set([
   "unmock",
   "doUnmock",
   "spyOn",
-  "fn",
   "clearAllMocks",
   "resetAllMocks",
   "restoreAllMocks",
   "stubEnv",
+  "stubGlobal",
   "setSystemTime",
 ]);