eslint-plugin-no-mistakes 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jonathan Ong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,10 @@
+# eslint-plugin-no-mistakes
+
+ESLint and Oxlint rules that keep TS/JS, React, Next.js, and Playwright code
+static enough for `no-mistakes` analyzers and AI agents.
+
+```sh
+npm install --save-dev eslint-plugin-no-mistakes
+```
+
+See [docs/eslint-plugin.md](../../docs/eslint-plugin.md).

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "eslint-plugin-no-mistakes",
+  "version": "0.6.0",
+  "description": "ESLint and Oxlint rules for deterministic no-mistakes code analysis",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jonathanong/no-mistakes.git",
+    "directory": "packages/eslint-plugin-no-mistakes"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "src/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "@typescript-eslint/parser": "^8.48.0",
+    "@vitest/coverage-v8": "^4.1.6",
+    "eslint": "^10.3.0",
+    "oxlint": "^1.64.0",
+    "vitest": "^4.1.6"
+  },
+  "peerDependencies": {
+    "eslint": ">=9"
+  },
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || >=24"
+  }
+}

package/src/defaulted-props.js

@@ -0,0 +1,209 @@
+"use strict";
+
+const { isStringLiteralNode, literalString, staticTemplate } = require("./helpers");
+const EMPTY_FUNCTION = { params: [], body: null };
+
+function isLiteralLike(node, opts, context) {
+  const value = literalString(node);
+  if (value !== null) {
+    return true;
+  }
+  if (opts.allowStaticTemplates && staticTemplate(node)) {
+    return true;
+  }
+  if (opts.allowDefaultedProps && isDefaultedPropReference(node, context)) {
+    return true;
+  }
+  return false;
+}
+
+function collectDefaultedProps(params) {
+  const props = new Set();
+  for (const param of params) {
+    collectPatternDefaults(param, props);
+  }
+  return props;
+}
+
+function collectPatternDefaults(pattern, props) {
+  if (pattern.type === "AssignmentPattern") {
+    collectDefaultName(pattern.left, props, isStringLiteralNode(pattern.right));
+    return;
+  }
+  if (pattern.type === "ObjectPattern") {
+    for (const prop of pattern.properties) {
+      collectObjectPropertyDefault(prop, props);
+    }
+    return;
+  }
+  if (pattern.type === "ArrayPattern") {
+    for (const element of pattern.elements) {
+      if (element) {
+        collectPatternDefaults(element, props);
+      }
+    }
+  }
+}
+
+function collectObjectPropertyDefault(prop, props) {
+  if (prop.type === "RestElement") {
+    return;
+  }
+  if (prop.value.type === "AssignmentPattern") {
+    collectDefaultName(prop.value.left, props, isStringLiteralNode(prop.value.right));
+    return;
+  }
+  collectPatternDefaults(prop.value, props);
+}
+
+function collectDefaultName(node, props, hasLiteralDefault) {
+  if (hasLiteralDefault && node.type === "Identifier") {
+    props.add(node.name);
+  }
+  if (node.type === "ObjectPattern") {
+    collectPatternDefaults(node, props);
+  }
+}
+
+function collectConstPatternDefaults(node, props) {
+  if (!node) {
+    return;
+  }
+  if (node.type === "VariableDeclaration") {
+    if (node.kind === "const") {
+      for (const declaration of node.declarations) {
+        if (declaration.id.type === "ObjectPattern" || declaration.id.type === "ArrayPattern") {
+          collectPatternDefaults(declaration.id, props);
+        }
+      }
+    }
+    return;
+  }
+  if (node.type !== "BlockStatement" && isFunctionNode(node)) {
+    return;
+  }
+  for (const child of constDefaultTraversalChildren(node)) {
+    collectConstPatternDefaults(child, props);
+  }
+}
+
+function patternHasLiteralDefault(pattern, name) {
+  if (pattern.type === "AssignmentPattern") {
+    return pattern.left.type === "Identifier"
+      ? pattern.left.name === name && isStringLiteralNode(pattern.right)
+      : patternHasLiteralDefault(pattern.left, name);
+  }
+  if (pattern.type !== "ObjectPattern") {
+    return (
+      pattern.type === "ArrayPattern" &&
+      pattern.elements.some((element) => element && patternHasLiteralDefault(element, name))
+    );
+  }
+  return pattern.properties.some((prop) => {
+    if (prop.type === "RestElement") {
+      return false;
+    }
+    return patternHasLiteralDefault(prop.value, name);
+  });
+}
+
+function constDefaultTraversalChildren(node) {
+  if (node.type === "BlockStatement") {
+    return node.body;
+  }
+  if (node.type === "IfStatement") {
+    return [node.consequent, node.alternate].filter(Boolean);
+  }
+  return [];
+}
+
+function isFunctionNode(node) {
+  return (
+    node.type === "FunctionDeclaration" ||
+    node.type === "FunctionExpression" ||
+    node.type === "ArrowFunctionExpression"
+  );
+}
+
+function nearestFunction(node) {
+  let current = node.parent;
+  while (current) {
+    if (isFunctionNode(current)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
+function defaultedPropsForNode(node) {
+  const fn = nearestFunction(node) || EMPTY_FUNCTION;
+  const props = collectDefaultedProps(fn.params);
+  collectConstPatternDefaults(fn.body, props);
+  return props;
+}
+
+function isDefaultedPropReference(node, context) {
+  if (node?.type !== "Identifier" || !defaultedPropsForNode(node).has(node.name)) {
+    return false;
+  }
+  const variable = findVariable(context.sourceCode.getScope(node), node.name);
+  return Boolean(
+    variable?.defs.some((def) => {
+      if (def.type === "Parameter") {
+        return hasLiteralParameterDefault(node, node.name);
+      }
+      return hasLiteralConstPatternDefault(def, node, context);
+    }),
+  );
+}
+
+function hasLiteralParameterDefault(node, name) {
+  return Boolean(
+    nearestFunction(node)?.params.some((param) => patternHasLiteralDefault(param, name)),
+  );
+}
+
+function hasLiteralConstPatternDefault(def, node, context) {
+  return (
+    def.type === "Variable" &&
+    def.parent?.kind === "const" &&
+    (def.node?.id?.type === "ObjectPattern" || def.node?.id?.type === "ArrayPattern") &&
+    patternHasLiteralDefault(def.node.id, node.name) &&
+    isAfterDeclaration(node, def.node) &&
+    isFunctionParameterSource(def.node.init, context)
+  );
+}
+
+function isAfterDeclaration(node, declaration) {
+  return node.range?.[0] >= declaration.range?.[1];
+}
+
+function isFunctionParameterSource(node, context) {
+  if (node?.type === "MemberExpression") {
+    return isFunctionParameterSource(node.object, context);
+  }
+  if (node?.type !== "Identifier" || !/props$/i.test(node.name)) {
+    return false;
+  }
+  const variable = findVariable(context.sourceCode.getScope(node), node.name);
+  return Boolean(variable?.defs.some((def) => def.type === "Parameter"));
+}
+
+function findVariable(scope, name) {
+  let variable = null;
+  for (let current = scope; current && variable === null; current = current.upper) {
+    variable = current.variables.find((item) => item.name === name) || null;
+  }
+  return variable;
+}
+
+module.exports = {
+  __test: {
+    findVariable,
+    patternHasLiteralDefault,
+  },
+  defaultedPropsForNode,
+  isDefaultedPropReference,
+  isLiteralLike,
+};

package/src/helpers.js

@@ -0,0 +1,180 @@
+"use strict";
+
+const DEFAULT_SELECTOR_ATTRIBUTES = ["data-testid", "data-pw"];
+const DEFAULT_NAMING_PATTERN = "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$";
+const INTERACTIVE_ELEMENTS = new Set(["button", "input", "select", "textarea"]);
+const SELECTOR_METHODS = new Set([
+  "$",
+  "$$",
+  "$eval",
+  "$$eval",
+  "check",
+  "click",
+  "dblclick",
+  "dragAndDrop",
+  "fill",
+  "focus",
+  "frameLocator",
+  "getByTestId",
+  "hover",
+  "locator",
+  "press",
+  "selectOption",
+  "setInputFiles",
+  "tap",
+  "textContent",
+  "type",
+  "uncheck",
+  "waitForSelector",
+]);
+
+function options(context) {
+  return context.options[0] || {};
+}
+
+function selectorAttributes(option) {
+  return option.selectorAttributes || DEFAULT_SELECTOR_ATTRIBUTES;
+}
+
+function canonicalAttribute(option) {
+  return option.canonicalAttribute || "data-pw";
+}
+
+function isSelectorAttribute(name, attrs) {
+  return attrs.includes(name);
+}
+
+function attributeName(attribute) {
+  if (!attribute || attribute.type !== "JSXAttribute") {
+    return null;
+  }
+  if (attribute.name.type !== "JSXIdentifier") {
+    return null;
+  }
+  return attribute.name.name;
+}
+
+function literalString(node) {
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+    return node.quasis.map((quasi) => quasi.value.raw).join("");
+  }
+  return null;
+}
+
+function staticTemplate(node) {
+  if (node && node.type === "TemplateLiteral" && node.expressions.length > 0) {
+    return node.quasis.some((quasi) => quasi.value.raw.length > 0);
+  }
+  return false;
+}
+
+function jsxAttributeExpression(attribute) {
+  if (!attribute.value) {
+    return null;
+  }
+  if (attribute.value.type === "JSXExpressionContainer") {
+    return attribute.value.expression;
+  }
+  return attribute.value;
+}
+
+function selectorLiteral(attribute) {
+  const expression = jsxAttributeExpression(attribute);
+  if (!expression) {
+    return null;
+  }
+  return literalString(expression);
+}
+
+function callMethodName(node) {
+  if (node.callee.type === "MemberExpression" && !node.callee.computed) {
+    return node.callee.property.name;
+  }
+  if (node.callee.type === "Identifier") {
+    return node.callee.name;
+  }
+  return null;
+}
+
+function isSelectorCall(node) {
+  const name = callMethodName(node);
+  return Boolean(name && SELECTOR_METHODS.has(name));
+}
+
+function cssSelectorValues(source, attrs) {
+  const values = [];
+  for (const attr of attrs) {
+    const escaped = attr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(
+      `\\[\\s*${escaped}\\s*([*^$]?=)\\s*(?:"([^"]*)"|'([^']*)'|([^\\s\\]]+))\\s*(?:[is])?\\s*\\]`,
+      "g",
+    );
+    let match = regex.exec(source);
+    while (match) {
+      values.push({ attribute: attr, operator: match[1], value: match[2] ?? match[3] ?? match[4] });
+      match = regex.exec(source);
+    }
+  }
+  return values;
+}
+
+function isStringLiteralNode(node) {
+  return literalString(node) !== null;
+}
+
+function isStaticString(node) {
+  return Boolean(node && isStringLiteralNode(node));
+}
+
+function selectorValueNode(attribute) {
+  const expression = jsxAttributeExpression(attribute);
+  return expression && expression.type !== "JSXEmptyExpression" ? expression : null;
+}
+
+const LOCAL_BINDING_TYPES = new Set(["Variable", "Parameter", "CatchClause", "FunctionName"]);
+
+function isFetchShadowed(scope) {
+  while (scope) {
+    const variable = scope.variables.find((v) => v.name === "fetch");
+    if (variable) {
+      return variable.defs.some((def) => LOCAL_BINDING_TYPES.has(def.type));
+    }
+    scope = scope.upper;
+  }
+  return false;
+}
+
+function isFetchCall(node, context) {
+  if (node.callee.type !== "Identifier" || node.callee.name !== "fetch") {
+    return false;
+  }
+  return !isFetchShadowed(context.sourceCode.getScope(node));
+}
+
+function rule(meta, create) {
+  return { meta, create };
+}
+
+module.exports = {
+  DEFAULT_NAMING_PATTERN,
+  attributeName,
+  callMethodName,
+  canonicalAttribute,
+  cssSelectorValues,
+  INTERACTIVE_ELEMENTS,
+  isFetchCall,
+  isSelectorAttribute,
+  isSelectorCall,
+  isStringLiteralNode,
+  isStaticString,
+  literalString,
+  options,
+  rule,
+  selectorAttributes,
+  selectorLiteral,
+  selectorValueNode,
+  staticTemplate,
+};

package/src/index.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const rules = {
+  "nextjs-static-fetch-method": require("./rules/nextjs-static-fetch-method"),
+  "nextjs-static-fetch-url": require("./rules/nextjs-static-fetch-url"),
+  "playwright-consistent-attribute": require("./rules/playwright-consistent-attribute"),
+  "playwright-defaults": require("./rules/playwright-defaults"),
+  "playwright-literals": require("./rules/playwright-literals"),
+  "playwright-naming-convention": require("./rules/playwright-naming-convention"),
+  "playwright-no-empty": require("./rules/playwright-no-empty"),
+  "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-unique": require("./rules/playwright-unique"),
+  "react-no-nullish-react-node": require("./rules/react-no-nullish-react-node"),
+  "ts-no-export-renaming": require("./rules/ts-no-export-renaming"),
+  "ts-no-function-aliases": require("./rules/ts-no-function-aliases"),
+};
+
+const plugin = {
+  meta: {
+    name: "eslint-plugin-no-mistakes",
+    version: require("../package.json").version,
+  },
+  rules,
+  configs: {},
+};
+
+plugin.configs.recommended = {
+  plugins: {
+    "no-mistakes": plugin,
+  },
+  rules: {
+    "no-mistakes/nextjs-static-fetch-method": "error",
+    "no-mistakes/nextjs-static-fetch-url": "error",
+    "no-mistakes/playwright-defaults": "error",
+    "no-mistakes/playwright-literals": "error",
+    "no-mistakes/playwright-no-empty": "error",
+    "no-mistakes/playwright-unique": "error",
+    "no-mistakes/react-no-nullish-react-node": "error",
+    "no-mistakes/ts-no-export-renaming": "error",
+    "no-mistakes/ts-no-function-aliases": "error",
+  },
+};
+
+plugin.configs.strict = {
+  plugins: {
+    "no-mistakes": plugin,
+  },
+  rules: {
+    ...plugin.configs.recommended.rules,
+    "no-mistakes/playwright-consistent-attribute": ["error", { canonicalAttribute: "data-pw" }],
+    "no-mistakes/playwright-naming-convention": "error",
+    "no-mistakes/playwright-prefer-get-by-test-id": "warn",
+    "no-mistakes/playwright-require-interactive-test-id": "warn",
+  },
+};
+
+module.exports = plugin;

package/src/react-node-types.js

@@ -0,0 +1,146 @@
+"use strict";
+
+function keyName(node) {
+  if (!node) return null;
+  if (node.type === "Identifier") return node.name;
+  return node.type === "Literal" ? String(node.value) : null;
+}
+
+function unwrapType(node) {
+  return node &&
+    (node.type === "TSParenthesizedType" ||
+      node.type === "TSOptionalType" ||
+      node.type === "TSRestType")
+    ? unwrapType(node.typeAnnotation)
+    : node;
+}
+
+function typeName(node) {
+  const current = unwrapType(node);
+  if (!current) return null;
+  if (current.type !== "TSTypeReference") return null;
+  const name = current.typeName;
+  if (name.type === "Identifier") return name.name;
+  return name.type === "TSQualifiedName" &&
+    name.left.type === "Identifier" &&
+    name.right.type === "Identifier"
+    ? `${name.left.name}.${name.right.name}`
+    : null;
+}
+
+function typeAnnotation(node) {
+  return node && node.typeAnnotation ? unwrapType(node.typeAnnotation.typeAnnotation) : null;
+}
+
+function createReactNodeFacts(program) {
+  const reactNodeNames = new Set(["React.ReactNode"]);
+  const aliases = new Map();
+  const objectProps = new Map();
+
+  function topLevelDeclaration(statement) {
+    return (statement.type === "ExportNamedDeclaration" ||
+      statement.type === "ExportDefaultDeclaration") &&
+      statement.declaration
+      ? statement.declaration
+      : statement;
+  }
+
+  function setChanged(previous, next) {
+    if (!previous || previous.size !== next.size) return true;
+    for (const value of next) {
+      if (!previous.has(value)) return true;
+    }
+    return false;
+  }
+
+  function heritageName(heritage) {
+    const expression = heritage && heritage.expression;
+    return expression && expression.type === "Identifier" ? expression.name : null;
+  }
+
+  function isReactNodeType(type) {
+    const name = typeName(type);
+    return Boolean(name && (reactNodeNames.has(name) || aliases.get(name) === true));
+  }
+
+  function collectMembers(members) {
+    const props = new Set();
+    for (const member of members || []) {
+      if (member.type !== "TSPropertySignature" || !isReactNodeType(typeAnnotation(member))) {
+        continue;
+      }
+      const name = keyName(member.key);
+      if (name) props.add(name);
+    }
+    return props;
+  }
+
+  for (const statement of program.body || []) {
+    if (statement.type !== "ImportDeclaration" || statement.source.value !== "react") continue;
+    for (const specifier of statement.specifiers || []) {
+      if (specifier.type === "ImportSpecifier" && keyName(specifier.imported) === "ReactNode") {
+        reactNodeNames.add(specifier.local.name);
+      }
+      if (
+        specifier.type === "ImportNamespaceSpecifier" ||
+        specifier.type === "ImportDefaultSpecifier"
+      ) {
+        reactNodeNames.add(`${specifier.local.name}.ReactNode`);
+      }
+    }
+  }
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const statement of program.body || []) {
+      const declaration = topLevelDeclaration(statement);
+      if (declaration.type !== "TSTypeAliasDeclaration") continue;
+      const name = declaration.id.name;
+      if (!aliases.has(name) && isReactNodeType(declaration.typeAnnotation)) {
+        aliases.set(name, true);
+        changed = true;
+      }
+    }
+  }
+
+  let objectsChanged = true;
+  while (objectsChanged) {
+    objectsChanged = false;
+    for (const statement of program.body || []) {
+      const declaration = topLevelDeclaration(statement);
+      if (declaration.type === "TSInterfaceDeclaration") {
+        const props = collectMembers(declaration.body && declaration.body.body);
+        for (const heritage of declaration.extends || []) {
+          const inherited = objectProps.get(heritageName(heritage));
+          if (inherited) {
+            for (const prop of inherited) props.add(prop);
+          }
+        }
+        if (setChanged(objectProps.get(declaration.id.name), props)) {
+          objectProps.set(declaration.id.name, props);
+          objectsChanged = true;
+        }
+      }
+      if (
+        declaration.type === "TSTypeAliasDeclaration" &&
+        declaration.typeAnnotation.type === "TSTypeLiteral"
+      ) {
+        const props = collectMembers(declaration.typeAnnotation.members);
+        if (setChanged(objectProps.get(declaration.id.name), props)) {
+          objectProps.set(declaration.id.name, props);
+          objectsChanged = true;
+        }
+      }
+    }
+  }
+
+  return { aliases, objectProps, reactNodeNames };
+}
+
+module.exports = {
+  createReactNodeFacts,
+  keyName,
+  typeAnnotation,
+  typeName,
+};

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

@@ -0,0 +1,38 @@
+"use strict";
+
+const { isFetchCall, isStaticString, literalString, rule } = require("../helpers");
+
+function isMethodKey(property) {
+  if (property.computed) return literalString(property.key) === "method";
+  return (
+    (property.key.type === "Identifier" && property.key.name === "method") ||
+    (property.key.type === "Literal" && property.key.value === "method")
+  );
+}
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description: "require static fetch() method option",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      dynamic:
+        "fetch() method option 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 opts = node.arguments[1];
+      if (!opts || opts.type !== "ObjectExpression") return;
+      const methodProp = opts.properties.findLast((p) => p.type === "Property" && isMethodKey(p));
+      if (!methodProp) return;
+      if (!isStaticString(methodProp.value)) {
+        context.report({ node: methodProp.value, messageId: "dynamic" });
+      }
+    },
+  }),
+);