@skapxd/eslint-opinionated 0.5.0 → 0.6.0

package/README.md

@@ -764,6 +764,23 @@ function Card() {
 helper en minúscula **sí** pueden tener funciones dentro — ahí es donde se mueve
 la lógica.
 
+**Opciones** (desde v0.6.0) para permitir los dos patrones React idiomáticos
+que la versión estricta bloqueaba — forzarlos a salir del componente producía
+workarounds peores que el problema (`.bind(null, ...)`, adapters artificiales):
+
+```js
+"skapxd/no-functions-inside-components": ["error", {
+  allowJsxCallbacks: true,       // <button onClick={() => onSelect(id)} />
+  allowArrayMapCallbacks: true,  // {entries.map((entry) => <Entry key={entry.id} />)}
+}]
+```
+
+Ambas exenciones aplican **solo a funciones anónimas inline en esa posición
+exacta**: el valor directo de una prop JSX, o el primer argumento de `.map(...)`.
+Un handler con nombre en el cuerpo (`const onClick = () => ...`), un callback de
+`useEffect` o un `.forEach` siguen reportándose — la lógica con peso sigue
+viviendo fuera del componente.
+
 ### `skapxd/no-try-catch`
 
 Prohíbe `try/catch`. La intención es que los errores se modelen como `Result` en

package/dist/{chunk-QNSHGNVQ.mjs → chunk-5BA4KA37.mjs}

@@ -1337,6 +1337,37 @@ var noDeepRelativeImports = {
   }
 };
 
+// src/utils/get-no-functions-inside-components-options.ts
+function getNoFunctionsInsideComponentsOptions(options = {}) {
+  return {
+    allowArrayMapCallbacks: options.allowArrayMapCallbacks ?? false,
+    allowJsxCallbacks: options.allowJsxCallbacks ?? false
+  };
+}
+
+// src/utils/is-anonymous-inline-function.ts
+function isAnonymousInlineFunction(node) {
+  if (node.type === "ArrowFunctionExpression") {
+    return true;
+  }
+  return node.type === "FunctionExpression" && !node.id;
+}
+
+// src/utils/is-array-map-callback.ts
+function isArrayMapCallback(node) {
+  const parent = node.parent;
+  if (parent?.type !== "CallExpression" || parent.arguments[0] !== node) {
+    return false;
+  }
+  const callee = parent.callee;
+  return callee?.type === "MemberExpression" && !callee.computed && callee.property?.type === "Identifier" && callee.property.name === "map";
+}
+
+// src/utils/is-jsx-attribute-callback.ts
+function isJsxAttributeCallback(node) {
+  return node.parent?.type === "JSXExpressionContainer" && node.parent.parent?.type === "JSXAttribute";
+}
+
 // src/rules/no-functions-inside-components.ts
 var noFunctionsInsideComponents = {
   meta: {
@@ -1347,17 +1378,39 @@ var noFunctionsInsideComponents = {
     messages: {
       functionInsideComponent: "No definas funciones dentro del componente `{{component}}`: se recrean en cada render. Muevela a un hook (`useX`) o a un helper fuera del componente."
     },
-    schema: []
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowArrayMapCallbacks: { type: "boolean" },
+          allowJsxCallbacks: { type: "boolean" }
+        },
+        type: "object"
+      }
+    ]
   },
   create(context) {
+    const options = getNoFunctionsInsideComponentsOptions(context.options[0]);
     function isComponentFunction(node) {
       return isFunctionNode(node) && isPascalCaseName(getFunctionName(node));
     }
+    function isAllowedInlineCallback(node) {
+      if (!isAnonymousInlineFunction(node)) {
+        return false;
+      }
+      if (options.allowJsxCallbacks && isJsxAttributeCallback(node)) {
+        return true;
+      }
+      return options.allowArrayMapCallbacks && isArrayMapCallback(node);
+    }
     function reportIfInsideComponent(node) {
       const enclosingFunction = getContainingFunction(node);
       if (!enclosingFunction || !isComponentFunction(enclosingFunction)) {
         return;
       }
+      if (isAllowedInlineCallback(node)) {
+        return;
+      }
       context.report({
         data: {
           component: getFunctionName(enclosingFunction)
@@ -1556,4 +1609,4 @@ var rules = {
 export {
   rules
 };
-//# sourceMappingURL=chunk-QNSHGNVQ.mjs.map
+//# sourceMappingURL=chunk-5BA4KA37.mjs.map