eslint-plugin-no-mistakes 0.6.0

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

@@ -0,0 +1,102 @@
+"use strict";
+
+const { rule } = require("../helpers");
+
+function unwrapExpression(expression) {
+  let current = expression;
+  while (
+    current &&
+    (current.type === "AwaitExpression" ||
+      current.type === "ChainExpression" ||
+      current.type === "TSNonNullExpression")
+  ) {
+    current = current.type === "AwaitExpression" ? current.argument : current.expression;
+  }
+  return current;
+}
+
+function expressionStatementCall(statement) {
+  if (statement.type !== "ExpressionStatement") return null;
+  return unwrapExpression(statement.expression);
+}
+
+function returnStatementCall(statement) {
+  if (statement.type !== "ReturnStatement") return null;
+  return unwrapExpression(statement.argument);
+}
+
+function onlyCallExpression(body) {
+  if (!body) return null;
+  if (body.type !== "BlockStatement") {
+    return unwrapExpression(body);
+  }
+  if (body.body.length !== 1) return null;
+  const statement = body.body[0];
+  return returnStatementCall(statement) || expressionStatementCall(statement);
+}
+
+function identifierName(node) {
+  return node && node.type === "Identifier" ? node.name : null;
+}
+
+function isSameArgumentList(params, args) {
+  if (params.length !== args.length) return false;
+  return params.every((param, index) => {
+    if (param.type === "RestElement") {
+      return (
+        args[index].type === "SpreadElement" &&
+        identifierName(param.argument) === identifierName(args[index].argument)
+      );
+    }
+    if (param.type === "AssignmentPattern") return false;
+    const name = identifierName(param);
+    return name && args[index].type === "Identifier" && args[index].name === name;
+  });
+}
+
+function isSelfCall(node, call) {
+  if (call.callee.type !== "Identifier") return false;
+  if (node.id && node.id.name === call.callee.name) return true;
+  const parent = node.parent;
+  return (
+    parent &&
+    parent.type === "VariableDeclarator" &&
+    parent.id.type === "Identifier" &&
+    parent.id.name === call.callee.name
+  );
+}
+
+function reportIfAlias(node, context) {
+  const call = onlyCallExpression(node.body);
+  if (!call || call.type !== "CallExpression") return;
+  if (isSelfCall(node, call)) return;
+  if (isSameArgumentList(node.params || [], call.arguments)) {
+    context.report({ node, messageId: "alias" });
+  }
+}
+
+module.exports = 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.",
+    },
+  },
+  (context) => ({
+    ArrowFunctionExpression(node) {
+      reportIfAlias(node, context);
+    },
+    FunctionDeclaration(node) {
+      reportIfAlias(node, context);
+    },
+    FunctionExpression(node) {
+      reportIfAlias(node, context);
+    },
+  }),
+);

package/src/selector-visitor.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const { attributeName, isSelectorAttribute, options, selectorAttributes } = require("./helpers");
+
+function selectorAttributeVisitors(context, callback) {
+  const attrs = selectorAttributes(options(context));
+  return {
+    JSXAttribute(node) {
+      const name = attributeName(node);
+      if (name && isSelectorAttribute(name, attrs)) {
+        callback(node, name);
+      }
+    },
+  };
+}
+
+module.exports = {
+  selectorAttributeVisitors,
+};