@blumintinc/eslint-plugin-blumint 1.19.15 → 1.19.17

package/lib/index.js

@@ -222,7 +222,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.19.15',
+        version: '1.19.17',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/prefer-getter-over-parameterless-method.js

@@ -661,6 +661,15 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                         ? (suggestedNameCounts.get(classBody)?.get(scopeKey) ?? 0) > 1
                         : false;
                     const isAsync = node.value.async;
+                    // Only `private` methods are safe to autofix. A public / protected /
+                    // unspecified-accessibility method is API surface whose call sites of
+                    // the form `instance.method()` may live in other files this
+                    // single-file rule never sees. Converting such a method to a getter
+                    // silently breaks every external caller (the call would invoke the
+                    // getter's return value), so the fix must be withheld for anything
+                    // not demonstrably private. The report (nudge) is still emitted.
+                    const isPrivate = node.accessibility === 'private' ||
+                        node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier;
                     context.report({
                         node: node.key,
                         messageId: sideEffectReason
@@ -671,7 +680,8 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                             suggestedName,
                             reason: sideEffectReason ?? 'it returns a value',
                         },
-                        fix: sideEffectReason ||
+                        fix: !isPrivate ||
+                            sideEffectReason ||
                             isAsync ||
                             !leftParen ||
                             !rightParen ||

package/lib/rules/react-memoize-literals.js

@@ -138,6 +138,37 @@ function isIterationMethodCallback(node) {
         callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
         ITERATION_METHODS.has(callee.property.name));
 }
+/**
+ * True when the NEAREST enclosing function of `node` is itself an Array
+ * iteration-method callback (`arr.map((x) => ({ … }))`, `.filter`, `.reduce`,
+ * `.forEach`, `.sort`, ...). This extends the `isIterationMethodCallback`
+ * exemption (issue #1290) from the callback function itself down to the
+ * object/array literals created directly inside its body (issue #1319): such a
+ * literal is a per-iteration value discarded along with the mapped result, so
+ * its identity is never observed. The rule's own remediation is unfollowable at
+ * the literal — `useMemo` cannot run per-iteration inside a `.map` loop, and a
+ * literal closing over the callback parameter cannot be hoisted to module
+ * scope. The memoizable unit is the whole `.map()` call:
+ * `const tabs = useMemo(() => arr.map((x) => ({ … })), [arr])`.
+ *
+ * The walk starts at `node` and stops at the FIRST function encountered
+ * (including `node` itself when `node` is a function). Keying on the nearest
+ * function — not any ancestor — is what preserves the #1290 scope guard: a
+ * nested, non-iteration callback inside the map body (e.g. an `onClick` handler
+ * that persists as a JSX prop) is the nearest function for any literal in its
+ * body, so those literals stay flagged, and the handler itself (its own nearest
+ * function is itself) stays flagged too.
+ */
+function isInsideIterationMethodCallback(node) {
+    let current = node;
+    while (current) {
+        if (isFunctionNode(current)) {
+            return isIterationMethodCallback(current);
+        }
+        current = current.parent;
+    }
+    return false;
+}
 /**
  * Type guard for parenthesized expressions to unwrap safely.
  * @param node Node to evaluate.
@@ -838,7 +869,15 @@ exports.reactMemoizeLiterals = (0, createRule_1.createRule)({
             // to module level, and useCallback can't run inside a .map loop. Inline
             // functions passed as JSX-attribute props *inside* the callback body are
             // separate nodes and remain flagged.
-            if (isIterationMethodCallback(node)) {
+            //
+            // The same rationale exempts object/array literals created directly
+            // inside such a callback (issue #1319): they are per-iteration values
+            // discarded with the mapped result, `useMemo` cannot run inside the loop,
+            // and the memoizable unit is the enclosing `.map()` call. The guard keys
+            // on the NEAREST enclosing function, so a literal inside a nested,
+            // non-iteration callback (e.g. an `onClick` handler) is NOT exempted.
+            if (isIterationMethodCallback(node) ||
+                isInsideIterationMethodCallback(node)) {
                 return;
             }
             // Inline literals that resolve to a style JSX attribute (sx, style),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.19.15",
+  "version": "1.19.17",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.19.17",
+    "date": "2026-07-18T07:27:36.853Z",
+    "rules": [
+      {
+        "name": "react-memoize-literals",
+        "changeType": "fix",
+        "issues": [
+          1319
+        ],
+        "summary": "exempt literals inside iteration-method callbacks (closes #1319)"
+      }
+    ]
+  },
+  {
+    "version": "1.19.16",
+    "date": "2026-07-18T06:29:03.568Z",
+    "rules": [
+      {
+        "name": "prefer-getter-over-parameterless-method",
+        "changeType": "fix",
+        "issues": [
+          1318
+        ],
+        "summary": "withhold autofix for non-private methods (closes #1318)"
+      }
+    ]
+  },
   {
     "version": "1.19.15",
     "date": "2026-07-17T23:29:51.136Z",