eslint-plugin-no-mistakes 0.6.0

package/src/rules/nextjs-static-fetch-url.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const { isFetchCall, isStaticString, rule } = require("../helpers");
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description: "require static fetch() URL arguments",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      dynamic:
+        "fetch() URL must be a string literal or an expression-free template literal so it can be statically analyzed.",
+    },
+  },
+  (context) => ({
+    CallExpression(node) {
+      if (!isFetchCall(node, context)) return;
+      const url = node.arguments[0];
+      if (!isStaticString(url)) {
+        context.report({ node: url ?? node, messageId: "dynamic" });
+      }
+    },
+  }),
+);

package/src/rules/playwright-consistent-attribute.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const { canonicalAttribute, options, rule } = require("../helpers");
+const { selectorAttributeVisitors } = require("../selector-visitor");
+
+module.exports = rule(
+  {
+    type: "suggestion",
+    docs: { description: "require a canonical test ID attribute", recommended: false },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          selectorAttributes: { type: "array", items: { type: "string" } },
+          canonicalAttribute: { type: "string" },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: { attribute: "Use '{{expected}}' instead of '{{actual}}' for test IDs." },
+  },
+  (context) =>
+    selectorAttributeVisitors(context, (node, name) => {
+      const expected = canonicalAttribute(options(context));
+      if (name !== expected) {
+        context.report({
+          node: node.name,
+          messageId: "attribute",
+          data: { actual: name, expected },
+        });
+      }
+    }),
+);

package/src/rules/playwright-defaults.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const { rule, selectorValueNode } = require("../helpers");
+const { isDefaultedPropReference } = require("../defaulted-props");
+const { selectorAttributeVisitors } = require("../selector-visitor");
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description: "require literal defaults for prop-passed test IDs",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: { selectorAttributes: { type: "array", items: { type: "string" } } },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      default: "Test ID prop passthrough must have a literal default.",
+    },
+  },
+  (context) =>
+    selectorAttributeVisitors(context, (node) => {
+      const valueNode = selectorValueNode(node);
+      if (valueNode?.type === "Identifier" && !isDefaultedPropReference(valueNode, context)) {
+        context.report({ node, messageId: "default" });
+      }
+    }),
+);

package/src/rules/playwright-literals.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const {
+  attributeName,
+  callMethodName,
+  isSelectorAttribute,
+  options,
+  rule,
+  selectorAttributes,
+  selectorValueNode,
+} = require("../helpers");
+const { isLiteralLike } = require("../defaulted-props");
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description: "require literal Playwright test IDs",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          selectorAttributes: { type: "array", items: { type: "string" } },
+          allowDefaultedProps: { type: "boolean" },
+          allowStaticTemplates: { type: "boolean" },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      literal: "Use a literal test ID, a static template, or a prop with a literal default.",
+    },
+  },
+  (context) => {
+    const opts = {
+      allowDefaultedProps: options(context).allowDefaultedProps !== false,
+      allowStaticTemplates: options(context).allowStaticTemplates === true,
+    };
+    const attrs = selectorAttributes(options(context));
+    return {
+      JSXAttribute(node) {
+        const name = attributeName(node);
+        if (!name || !isSelectorAttribute(name, attrs)) {
+          return;
+        }
+        const valueNode = selectorValueNode(node);
+        if (!valueNode || !isLiteralLike(valueNode, opts, context)) {
+          context.report({ node, messageId: "literal" });
+        }
+      },
+      CallExpression(node) {
+        if (callMethodName(node) !== "getByTestId") {
+          return;
+        }
+        const arg = node.arguments[0];
+        if (!arg || !isLiteralLike(arg, opts, context)) {
+          context.report({ node: arg || node, messageId: "literal" });
+        }
+      },
+    };
+  },
+);

package/src/rules/playwright-naming-convention.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const { DEFAULT_NAMING_PATTERN, options, rule, selectorLiteral } = require("../helpers");
+const { selectorAttributeVisitors } = require("../selector-visitor");
+
+module.exports = rule(
+  {
+    type: "suggestion",
+    docs: { description: "require a naming convention for literal test IDs", recommended: false },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          selectorAttributes: { type: "array", items: { type: "string" } },
+          pattern: { type: "string" },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: { naming: "Test ID '{{value}}' does not match {{pattern}}." },
+  },
+  (context) => {
+    const pattern = options(context).pattern || DEFAULT_NAMING_PATTERN;
+    const regex = new RegExp(pattern);
+    return selectorAttributeVisitors(context, (node) => {
+      const value = selectorLiteral(node);
+      if (value !== null && !regex.test(value)) {
+        context.report({ node, messageId: "naming", data: { value, pattern } });
+      }
+    });
+  },
+);

package/src/rules/playwright-no-empty.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const { rule, selectorLiteral } = require("../helpers");
+const { selectorAttributeVisitors } = require("../selector-visitor");
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: { description: "disallow empty test IDs", recommended: true },
+    schema: [
+      {
+        type: "object",
+        properties: { selectorAttributes: { type: "array", items: { type: "string" } } },
+        additionalProperties: false,
+      },
+    ],
+    messages: { empty: "Test ID must not be empty." },
+  },
+  (context) =>
+    selectorAttributeVisitors(context, (node) => {
+      if (selectorLiteral(node) === "") {
+        context.report({ node, messageId: "empty" });
+      }
+    }),
+);

package/src/rules/playwright-prefer-get-by-test-id.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const {
+  callMethodName,
+  cssSelectorValues,
+  isSelectorCall,
+  literalString,
+  options,
+  rule,
+  selectorAttributes,
+} = require("../helpers");
+
+module.exports = rule(
+  {
+    type: "suggestion",
+    docs: { description: "prefer getByTestId over CSS test-id selectors", recommended: false },
+    schema: [
+      {
+        type: "object",
+        properties: { selectorAttributes: { type: "array", items: { type: "string" } } },
+        additionalProperties: false,
+      },
+    ],
+    messages: { prefer: "Prefer getByTestId('{{value}}') for exact test ID selectors." },
+  },
+  (context) => {
+    const attrs = selectorAttributes(options(context));
+    return {
+      CallExpression(node) {
+        const methodName = callMethodName(node);
+        if (!isSelectorCall(node) || methodName === "getByTestId") {
+          return;
+        }
+        for (const arg of node.arguments.slice(0, methodName === "dragAndDrop" ? 2 : 1)) {
+          const source = literalString(arg);
+          if (typeof source !== "string" || source === "") {
+            continue;
+          }
+          for (const selector of cssSelectorValues(source, attrs)) {
+            if (selector.operator === "=") {
+              context.report({ node: arg, messageId: "prefer", data: { value: selector.value } });
+            }
+          }
+        }
+      },
+    };
+  },
+);

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

@@ -0,0 +1,69 @@
+"use strict";
+
+const {
+  attributeName,
+  INTERACTIVE_ELEMENTS,
+  isSelectorAttribute,
+  options,
+  rule,
+  selectorAttributes,
+  selectorLiteral,
+} = require("../helpers");
+
+module.exports = rule(
+  {
+    type: "suggestion",
+    docs: { description: "require test IDs on interactive JSX elements", recommended: false },
+    schema: [
+      {
+        type: "object",
+        properties: { selectorAttributes: { type: "array", items: { type: "string" } } },
+        additionalProperties: false,
+      },
+    ],
+    messages: { missing: "Interactive elements should have a test ID." },
+  },
+  (context) => {
+    const attrs = selectorAttributes(options(context));
+    return {
+      JSXOpeningElement(node) {
+        const elementName = node.name.type === "JSXIdentifier" ? node.name.name : null;
+        const hasSelector = node.attributes.some((attr) =>
+          isSelectorAttribute(attributeName(attr), attrs),
+        );
+        if (hasSelector || !isInteractiveElement(elementName, node.attributes)) {
+          return;
+        }
+        context.report({ node: node.name, messageId: "missing" });
+      },
+    };
+  },
+);
+
+function isInteractiveElement(elementName, attributes) {
+  if (INTERACTIVE_ELEMENTS.has(elementName)) {
+    return true;
+  }
+  if (elementName === "a" && attributes.some((attr) => attributeName(attr) === "href")) {
+    return true;
+  }
+  return attributes.some((attr) => {
+    if (attributeName(attr) === "onClick") {
+      return true;
+    }
+    if (attributeName(attr) !== "role") {
+      return false;
+    }
+    return [
+      "button",
+      "checkbox",
+      "link",
+      "menuitem",
+      "option",
+      "radio",
+      "switch",
+      "tab",
+      "textbox",
+    ].includes(selectorLiteral(attr));
+  });
+}

package/src/rules/playwright-unique.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const { rule, selectorLiteral } = require("../helpers");
+const { selectorAttributeVisitors } = require("../selector-visitor");
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description: "require unique literal test IDs within a file",
+      recommended: true,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: { selectorAttributes: { type: "array", items: { type: "string" } } },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      duplicate: "Test ID '{{value}}' is already used in this file.",
+    },
+  },
+  (context) => {
+    const seen = new Map();
+    return selectorAttributeVisitors(context, (node) => {
+      const value = selectorLiteral(node);
+      if (value === null) {
+        return;
+      }
+      if (seen.has(value)) {
+        context.report({ node, messageId: "duplicate", data: { value } });
+      } else {
+        seen.set(value, node);
+      }
+    });
+  },
+);

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

@@ -0,0 +1,193 @@
+"use strict";
+
+const { rule } = require("../helpers");
+const { createReactNodeFacts, keyName, typeAnnotation, typeName } = require("../react-node-types");
+
+function isObjectPattern(node) {
+  return node && node.type === "ObjectPattern";
+}
+
+function isIdentifier(node) {
+  return node && node.type === "Identifier";
+}
+
+function definePattern(pattern, props, defineBinding, defineReactNode) {
+  if (!isObjectPattern(pattern)) return;
+  for (const property of pattern.properties || []) {
+    if (property.type !== "Property") continue;
+    const name = keyName(property.key);
+    if (isIdentifier(property.value)) {
+      defineBinding(property.value.name);
+      if (name && props && props.has(name)) defineReactNode(property.value.name);
+    } else if (property.value.type === "AssignmentPattern" && isIdentifier(property.value.left)) {
+      defineBinding(property.value.left.name);
+      if (name && props && props.has(name)) defineReactNode(property.value.left.name);
+    }
+  }
+}
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description: "disallow nullish coalescing on ReactNode-like values",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      nullish:
+        "Do not use ?? with ReactNode values. React renders null, false, and empty values differently; use an explicit undefined check for fallbacks.",
+    },
+  },
+  (context) => {
+    const scopes = [];
+    let facts = { aliases: new Map(), objectProps: new Map(), reactNodeNames: new Set() };
+
+    function currentScope() {
+      return scopes[scopes.length - 1];
+    }
+
+    function pushScope(kind) {
+      scopes.push({ bindings: new Set(), kind, objectTypes: new Map(), reactNodes: new Set() });
+    }
+
+    function popScope() {
+      scopes.pop();
+    }
+
+    function isReactNodeType(type) {
+      const name = typeName(type);
+      return Boolean(name && (facts.reactNodeNames.has(name) || facts.aliases.get(name) === true));
+    }
+
+    function propsForType(type) {
+      if (type && type.type === "TSTypeLiteral") {
+        const props = new Set();
+        for (const member of type.members || []) {
+          if (member.type !== "TSPropertySignature" || !isReactNodeType(typeAnnotation(member))) {
+            continue;
+          }
+          const name = keyName(member.key);
+          if (name) props.add(name);
+        }
+        return props;
+      }
+      const name = typeName(type);
+      return name ? facts.objectProps.get(name) : null;
+    }
+
+    function defineReactNode(name, scope = currentScope()) {
+      scope.bindings.add(name);
+      scope.reactNodes.add(name);
+    }
+
+    function defineBinding(name, scope = currentScope()) {
+      scope.bindings.add(name);
+    }
+
+    function defineObjectType(name, type, scope = currentScope()) {
+      scope.bindings.add(name);
+      const props = propsForType(type);
+      if (props && props.size > 0) {
+        scope.objectTypes.set(name, props);
+      }
+    }
+
+    function variableScope(node) {
+      if (!node.parent || node.parent.kind !== "var") return currentScope();
+      return (
+        scopes.findLast((scope) => scope.kind === "function" || scope.kind === "program") ||
+        currentScope()
+      );
+    }
+
+    function variableIsReactNode(name) {
+      for (let index = scopes.length - 1; index >= 0; index -= 1) {
+        if (scopes[index].bindings.has(name)) {
+          return scopes[index].reactNodes.has(name);
+        }
+      }
+      return false;
+    }
+
+    function objectProps(name) {
+      for (let index = scopes.length - 1; index >= 0; index -= 1) {
+        if (scopes[index].bindings.has(name) && !scopes[index].objectTypes.has(name)) return null;
+        const props = scopes[index].objectTypes.get(name);
+        if (props) return props;
+      }
+      return null;
+    }
+
+    function defineParam(param) {
+      const target = param.type === "AssignmentPattern" ? param.left : param;
+      const type = typeAnnotation(param) || typeAnnotation(target);
+      if (isIdentifier(target)) {
+        currentScope().bindings.add(target.name);
+        if (isReactNodeType(type)) defineReactNode(target.name);
+        defineObjectType(target.name, type);
+      } else if (isObjectPattern(target)) {
+        definePattern(target, propsForType(type), defineBinding, defineReactNode);
+      }
+    }
+
+    function defineVariable(node) {
+      const scope = variableScope(node);
+      const type = typeAnnotation(node.id);
+      if (isIdentifier(node.id)) {
+        scope.bindings.add(node.id.name);
+        if (isReactNodeType(type)) defineReactNode(node.id.name, scope);
+        defineObjectType(node.id.name, type, scope);
+      } else if (isObjectPattern(node.id)) {
+        const initType = isIdentifier(node.init) ? objectProps(node.init.name) : null;
+        definePattern(
+          node.id,
+          propsForType(type) || initType,
+          (name) => defineBinding(name, scope),
+          (name) => defineReactNode(name, scope),
+        );
+      }
+    }
+
+    function expressionIsReactNode(node) {
+      if (node && node.type === "ChainExpression") return expressionIsReactNode(node.expression);
+      if (isIdentifier(node)) return variableIsReactNode(node.name);
+      if (node && node.type === "MemberExpression" && !node.computed && isIdentifier(node.object)) {
+        const props = objectProps(node.object.name);
+        return Boolean(props && props.has(keyName(node.property)));
+      }
+      return false;
+    }
+
+    function enterFunction(node) {
+      pushScope("function");
+      for (const param of node.params || []) {
+        defineParam(param);
+      }
+    }
+
+    return {
+      Program(node) {
+        facts = createReactNodeFacts(node);
+        pushScope("program");
+      },
+      "Program:exit": popScope,
+      FunctionDeclaration: enterFunction,
+      "FunctionDeclaration:exit": popScope,
+      FunctionExpression: enterFunction,
+      "FunctionExpression:exit": popScope,
+      ArrowFunctionExpression: enterFunction,
+      "ArrowFunctionExpression:exit": popScope,
+      BlockStatement() {
+        pushScope("block");
+      },
+      "BlockStatement:exit": popScope,
+      VariableDeclarator: defineVariable,
+      LogicalExpression(node) {
+        if (node.operator === "??" && expressionIsReactNode(node.left)) {
+          context.report({ node, messageId: "nullish" });
+        }
+      },
+    };
+  },
+);

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

@@ -0,0 +1,42 @@
+"use strict";
+
+const { rule } = require("../helpers");
+
+function exportName(node) {
+  if (!node) return null;
+  if (node.type === "Identifier") return node.name;
+  return node.type === "Literal" ? String(node.value) : null;
+}
+
+function isTypeExport(node, specifier) {
+  return node.exportKind === "type" || specifier.exportKind === "type";
+}
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      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.",
+    },
+  },
+  (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" });
+        }
+      }
+    },
+  }),
+);