eslint-plugin-no-mistakes 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.6.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/index.js

@@ -1,19 +1,34 @@
 "use strict";
 
 const rules = {
+  "await-array-methods": require("./rules/await-array-methods"),
   "nextjs-static-fetch-method": require("./rules/nextjs-static-fetch-method"),
   "nextjs-static-fetch-url": require("./rules/nextjs-static-fetch-url"),
+  "nextjs-metadata-exports-location": require("./rules/nextjs-metadata-exports-location"),
+  "nextjs-no-manual-script-tags": require("./rules/nextjs-no-manual-script-tags"),
+  "no-delete-property": require("./rules/no-delete-property"),
+  "no-import-only-test-files": require("./rules/no-import-only-test-files"),
+  "no-placeholder-never-type-exports": require("./rules/no-placeholder-never-type-exports"),
+  "no-vitest-sequential": require("./rules/no-vitest-sequential"),
   "playwright-consistent-attribute": require("./rules/playwright-consistent-attribute"),
   "playwright-defaults": require("./rules/playwright-defaults"),
+  "playwright-assertion-timeout-cap": require("./rules/playwright-assertion-timeout-cap"),
   "playwright-literals": require("./rules/playwright-literals"),
   "playwright-naming-convention": require("./rules/playwright-naming-convention"),
   "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-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"),
   "playwright-unique": require("./rules/playwright-unique"),
   "react-no-nullish-react-node": require("./rules/react-no-nullish-react-node"),
+  "react-no-use-promise-resolve": require("./rules/react-no-use-promise-resolve"),
+  "test-no-error-message-matching": require("./rules/test-no-error-message-matching"),
+  "test-no-shared-state": require("./rules/test-no-shared-state"),
   "ts-no-export-renaming": require("./rules/ts-no-export-renaming"),
   "ts-no-function-aliases": require("./rules/ts-no-function-aliases"),
+  "vitest-mock-test-file-naming": require("./rules/vitest-mock-test-file-naming"),
 };
 
 const plugin = {
@@ -32,6 +47,8 @@ plugin.configs.recommended = {
   rules: {
     "no-mistakes/nextjs-static-fetch-method": "error",
     "no-mistakes/nextjs-static-fetch-url": "error",
+    "no-mistakes/no-delete-property": "error",
+    "no-mistakes/no-placeholder-never-type-exports": "error",
     "no-mistakes/playwright-defaults": "error",
     "no-mistakes/playwright-literals": "error",
     "no-mistakes/playwright-no-empty": "error",
@@ -48,10 +65,23 @@ plugin.configs.strict = {
   },
   rules: {
     ...plugin.configs.recommended.rules,
+    "no-mistakes/await-array-methods": "error",
+    "no-mistakes/nextjs-metadata-exports-location": "error",
+    "no-mistakes/nextjs-no-manual-script-tags": "error",
+    "no-mistakes/no-import-only-test-files": "error",
+    "no-mistakes/no-vitest-sequential": "error",
+    "no-mistakes/playwright-assertion-timeout-cap": "error",
     "no-mistakes/playwright-consistent-attribute": ["error", { canonicalAttribute: "data-pw" }],
     "no-mistakes/playwright-naming-convention": "error",
+    "no-mistakes/playwright-no-set-timeout": "error",
     "no-mistakes/playwright-prefer-get-by-test-id": "warn",
     "no-mistakes/playwright-require-interactive-test-id": "warn",
+    "no-mistakes/playwright-selector-priority": "error",
+    "no-mistakes/react-no-iife-in-jsx": "error",
+    "no-mistakes/react-no-use-promise-resolve": "error",
+    "no-mistakes/test-no-error-message-matching": "error",
+    "no-mistakes/test-no-shared-state": "error",
+    "no-mistakes/vitest-mock-test-file-naming": "error",
   },
 };
 

package/src/rules/await-array-methods.js

@@ -0,0 +1,84 @@
+"use strict";
+
+const { callMethodName, rule } = require("../helpers");
+
+const BANNED_METHODS = new Set(["sort", "toSorted", "every", "findIndex", "slice", "toSpliced"]);
+
+function methodName(node) {
+  if (node.callee.type !== "MemberExpression") return callMethodName(node);
+  if (!node.callee.computed) return node.callee.property.name;
+  return node.callee.property.type === "Literal" ? String(node.callee.property.value) : null;
+}
+
+function unwrapChain(node) {
+  return node?.type === "ChainExpression" ? node.expression : node;
+}
+
+function findVariable(node, context) {
+  let scope = context.sourceCode.getScope(node);
+  while (scope) {
+    const variable = scope.variables.find((candidate) => candidate.name === node.name);
+    if (variable) return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+
+function isReassignedBeforeUse(variable, node) {
+  const definitionNames = new Set(variable.defs.map((def) => def.name));
+  return variable.references.some(
+    (reference) =>
+      reference.isWrite() &&
+      !definitionNames.has(reference.identifier) &&
+      reference.identifier.range[0] < node.range[0],
+  );
+}
+
+function isKnownArrayReceiver(node, context) {
+  node = unwrapChain(node);
+  if (node.type === "ArrayExpression") return true;
+  if (node.type !== "Identifier") return false;
+  const variable = findVariable(node, context);
+  return Boolean(
+    variable &&
+    variable.defs.some(
+      (def) =>
+        def.type === "Variable" &&
+        def.node?.id?.type === "Identifier" &&
+        def.node.init?.type === "ArrayExpression",
+    ) &&
+    !isReassignedBeforeUse(variable, node),
+  );
+}
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description: "disallow awaiting synchronous array methods",
+      recommended: false,
+    },
+    schema: [],
+    messages: {
+      awaited:
+        "Do not await {{method}}(). This array method returns a synchronous value; remove await or await the async work explicitly.",
+    },
+  },
+  (context) => {
+    return {
+      AwaitExpression(node) {
+        const argument = unwrapChain(node.argument);
+        if (argument.type !== "CallExpression") return;
+        const method = methodName(argument);
+        if (!BANNED_METHODS.has(method)) return;
+        if (
+          argument.callee.type !== "MemberExpression" ||
+          !isKnownArrayReceiver(argument.callee.object, context)
+        ) {
+          return;
+        }
+        context.report({ node, messageId: "awaited", data: { method } });
+      },
+    };
+  },
+);

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

@@ -0,0 +1,96 @@
+"use strict";
+
+const { rule } = require("../helpers");
+
+const ALLOWED_SUFFIXES = [
+  "/page.tsx",
+  "/page.ts",
+  "/page.jsx",
+  "/page.js",
+  "/layout.tsx",
+  "/layout.ts",
+  "/layout.jsx",
+  "/layout.js",
+];
+const METADATA_EXPORTS = new Set(["metadata", "generateMetadata"]);
+const NEXT_FILE_PATTERN = /(?:^|[/\\])(?:app|pages)(?:[/\\]|$)/;
+
+function isAllowedFile(filename) {
+  const normalized = filename.replace(/\\/g, "/");
+  return (
+    (normalized.startsWith("app/") || normalized.includes("/app/")) &&
+    ALLOWED_SUFFIXES.some((suffix) => normalized.endsWith(suffix))
+  );
+}
+
+function isNextFile(filename) {
+  return NEXT_FILE_PATTERN.test(filename.replace(/\\/g, "/"));
+}
+
+function specifierName(specifier) {
+  return specifier.exported?.name || specifier.exported?.value || specifier.local?.name;
+}
+
+function declarationName(declaration) {
+  return declaration.id?.type === "Identifier" ? declaration.id.name : null;
+}
+
+function collectPatternNames(node, names = new Set()) {
+  if (!node) return names;
+  if (node.type === "Identifier") names.add(node.name);
+  if (node.type === "ObjectPattern") {
+    for (const property of node.properties) collectPatternNames(property.value, names);
+  }
+  if (node.type === "ArrayPattern") {
+    for (const element of node.elements) collectPatternNames(element, names);
+  }
+  if (node.type === "RestElement") collectPatternNames(node.argument, names);
+  return names;
+}
+
+module.exports = 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.",
+    },
+  },
+  (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?.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" });
+      }
+    },
+  }),
+);

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

@@ -0,0 +1,103 @@
+"use strict";
+
+const { literalString, rule } = require("../helpers");
+
+const NEXT_FILE_PATTERN = /(?:^|[/\\])(?:app|pages)(?:[/\\]|$)/;
+
+function isNextPath(filename) {
+  return NEXT_FILE_PATTERN.test(filename.replace(/\\/g, "/"));
+}
+
+function isJsonLdScript(node) {
+  return node.attributes.some((attribute) => {
+    if (
+      attribute.type !== "JSXAttribute" ||
+      attribute.name.type !== "JSXIdentifier" ||
+      attribute.name.name !== "type"
+    ) {
+      return false;
+    }
+    const value =
+      attribute.value?.type === "JSXExpressionContainer"
+        ? attribute.value.expression
+        : attribute.value;
+    return value?.type === "Literal" && value.value === "application/ld+json";
+  });
+}
+
+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: [
+      {
+        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) {
+        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" });
+      },
+    };
+  },
+);

package/src/rules/no-delete-property.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const { rule } = require("../helpers");
+
+function unwrapExpression(node) {
+  let current = node;
+  while (
+    current &&
+    ["ChainExpression", "TSAsExpression", "TSNonNullExpression", "TSTypeAssertion"].includes(
+      current.type,
+    )
+  ) {
+    current = current.expression;
+  }
+  return current;
+}
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: { description: "disallow deleting object properties", recommended: false },
+    schema: [],
+    messages: {
+      delete:
+        "Avoid deleting object properties. Use an omitted copy or an explicit nullable value so object shape changes stay traceable.",
+    },
+  },
+  (context) => ({
+    UnaryExpression(node) {
+      if (node.operator !== "delete") return;
+      const argument = unwrapExpression(node.argument);
+      if (argument?.type !== "MemberExpression") return;
+      context.report({ node, messageId: "delete" });
+    },
+  }),
+);

package/src/rules/no-import-only-test-files.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const { rule } = require("../helpers");
+
+const TEST_FILE_PATTERN = /\.(?:mock\.)?(?:test|spec)\.[cm]?[jt]sx?$/;
+const TEST_IMPORT_PATTERN = /\.(?:mock\.)?(?:test|spec)(?:\.[cm]?[jt]sx?)?$/;
+
+function isTestFile(filename) {
+  return TEST_FILE_PATTERN.test(filename.replace(/\\/g, "/"));
+}
+
+function isTestImportSource(source) {
+  return typeof source === "string" && TEST_IMPORT_PATTERN.test(source);
+}
+
+function isTestRequire(statement) {
+  if (
+    statement.type === "ExpressionStatement" &&
+    statement.expression.type === "CallExpression" &&
+    statement.expression.callee.type === "Identifier" &&
+    statement.expression.callee.name === "require" &&
+    isTestImportSource(statement.expression.arguments[0]?.value)
+  ) {
+    return true;
+  }
+  return (
+    statement.type === "VariableDeclaration" &&
+    statement.declarations.length > 0 &&
+    statement.declarations.every(
+      (declaration) =>
+        declaration.init?.type === "CallExpression" &&
+        declaration.init.callee.type === "Identifier" &&
+        declaration.init.callee.name === "require" &&
+        isTestImportSource(declaration.init.arguments[0]?.value),
+    )
+  );
+}
+
+function isTestImport(statement) {
+  return statement.type === "ImportDeclaration" && isTestImportSource(statement.source?.value);
+}
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description: "disallow aggregate test files that only import tests",
+      recommended: false,
+    },
+    schema: [],
+    messages: {
+      aggregate:
+        "Do not create aggregate test files that only import other test files; let the test runner discover those files directly.",
+    },
+  },
+  (context) => ({
+    Program(node) {
+      if (!isTestFile(context.filename) || node.body.length === 0) return;
+      const statements = node.body.filter((statement) => statement.directive === undefined);
+      if (statements.length === 0) return;
+      if (!statements.every((statement) => isTestImport(statement) || isTestRequire(statement)))
+        return;
+      context.report({ node, messageId: "aggregate" });
+    },
+  }),
+);

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

@@ -0,0 +1,51 @@
+"use strict";
+
+const { rule } = require("../helpers");
+
+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);
+      },
+      "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;
+        }
+        if (
+          !node.source &&
+          node.specifiers?.some(
+            (specifier) => node.exportKind === "type" || specifier.exportKind === "type",
+          )
+        ) {
+          exportSpecifiers.push(node);
+        }
+      },
+    };
+  },
+);

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

@@ -0,0 +1,77 @@
+"use strict";
+
+const { rule } = require("../helpers");
+
+const TEST_NAMES = new Set(["test", "it", "describe"]);
+const TEST_FILE_PATTERN = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
+
+function isTestFile(filename) {
+  return TEST_FILE_PATTERN.test(filename.replace(/\\/g, "/"));
+}
+
+function propertyName(node, computed = false) {
+  if (node.type === "Literal") return String(node.value);
+  if (computed) return null;
+  return node.name;
+}
+
+function rootTestName(node) {
+  if (node?.type === "Identifier") return node.name;
+  if (node?.type === "MemberExpression") return rootTestName(node.object);
+  if (node?.type === "CallExpression") return rootTestName(node.callee);
+  return null;
+}
+
+function hasSequentialMember(node) {
+  if (node?.type === "MemberExpression") {
+    return (
+      propertyName(node.property, node.computed) === "sequential" ||
+      hasSequentialMember(node.object)
+    );
+  }
+  if (node?.type === "CallExpression") return hasSequentialMember(node.callee);
+  return false;
+}
+
+function hasSequentialOption(node) {
+  return node.arguments
+    .slice(1)
+    .some(
+      (argument) =>
+        argument.type === "ObjectExpression" &&
+        argument.properties.some(
+          (property) =>
+            property.type === "Property" &&
+            propertyName(property.key) === "sequential" &&
+            property.value.type === "Literal" &&
+            property.value.value === true,
+        ),
+    );
+}
+
+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)) {
+          context.report({ node: node.callee, messageId: "sequential" });
+          return;
+        }
+        if (!hasSequentialOption(node)) return;
+        context.report({ node: node.callee, messageId: "sequential" });
+      },
+    };
+  },
+);