@blumintinc/eslint-plugin-blumint 1.20.56 → 1.20.58

package/lib/index.js

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

package/lib/rules/enforce-memoize-async.js

@@ -42,6 +42,39 @@ function bindsMemoize(variable) {
                 ALLOWED_MEMOIZE_MODULES.has(String(declaration.source.value)));
         }));
 }
+/**
+ * Whether a declared return type annotation promises no value: `void` or
+ * `Promise<void>`.
+ *
+ * Memoizing such a method caches nothing — there is no result to hand back —
+ * while changing runtime behaviour: the side effects run once per instance and
+ * every later call silently no-ops. Because the decision comes from the
+ * annotation node, spacing and line breaks inside the type are irrelevant.
+ *
+ * The check stays keyed to a plain `void`: a union (`Promise<void | undefined>`)
+ * or a type parameter (`Promise<T>`) can resolve to a value, so those still
+ * warrant caching. Absent annotations are likewise not exempt — this rule is
+ * syntactic (no `parserOptions.project`), so an unannotated body carries no
+ * declaration of intent to honour, and exempting inferred void would silently
+ * drop methods the author never marked value-less.
+ */
+function declaresVoidResult(returnType) {
+    const annotation = returnType?.typeAnnotation;
+    if (!annotation) {
+        return false;
+    }
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSVoidKeyword) {
+        return true;
+    }
+    if (annotation.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
+        annotation.typeName.type !== utils_1.AST_NODE_TYPES.Identifier ||
+        annotation.typeName.name !== 'Promise') {
+        return false;
+    }
+    const typeArguments = annotation.typeParameters?.params;
+    return (typeArguments?.length === 1 &&
+        typeArguments[0].type === utils_1.AST_NODE_TYPES.TSVoidKeyword);
+}
 /**
  * Matches a memoize decorator in supported syntaxes:
  * - @Alias()
@@ -148,6 +181,13 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (node.value.params.length > 1) {
                     return;
                 }
+                // A method declared to produce no value has no result to cache, so the
+                // decorator's benefit is unobtainable while its cost is real: the
+                // fixer would convert a repeatable side effect into a
+                // once-per-instance one, unattended, under `--fix`.
+                if (declaresVoidResult(node.value.returnType)) {
+                    return;
+                }
                 const { aliases: memoizeAliases, namespaces: memoizeNamespaces } = memoizeImports();
                 const hasMemoizeImport = memoizeAliases.size > 0 || memoizeNamespaces.size > 0;
                 // Check if method already has @Memoize or @Memoize() decorator

package/lib/rules/no-entire-object-hook-deps.js

@@ -20,6 +20,58 @@ function isEffectHookCall(node) {
     return (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
         EFFECT_HOOK_NAMES.has(callee.name));
 }
+/**
+ * The rule whose suppression marks a dependency array as hand-maintained.
+ */
+const EXHAUSTIVE_DEPS_RULE = 'react-hooks/exhaustive-deps';
+/**
+ * Matches the keyword of an `eslint-disable`, `eslint-disable-next-line` or
+ * `eslint-disable-line` directive, leaving the rule list as the remainder. The
+ * lookahead keeps `eslint-disabled-something` (and prose that merely opens with
+ * the same letters) from parsing as a directive.
+ */
+const DISABLE_DIRECTIVE = /^\s*eslint-disable(-next-line|-line)?(?![\w-])/u;
+/**
+ * ESLint splits a directive's rule list from its ` -- justification` suffix on
+ * this separator, so the rule list must be read the same way.
+ */
+const JUSTIFICATION_SEPARATOR = /\s-{2,}\s/u;
+/**
+ * The line an exhaustive-deps disable comment covers, `'file'` for the
+ * whole-file form, or null when the comment is not such a directive.
+ *
+ * why: `eslint-disable-next-line` covers the line after the comment ends, while
+ * `eslint-disable-line` covers the comment's own line. Only the block form of
+ * the bare `eslint-disable` is a file-level directive to ESLint, so a line
+ * comment starting with it is not treated as one here either. The file form
+ * counts for the whole file rather than from its own position onward: erring
+ * toward exempting a hook keeps a hand-managed array intact, which is the safe
+ * direction for a deleting fixer.
+ */
+function readExhaustiveDepsDisable(comment) {
+    const [directive] = comment.value.split(JUSTIFICATION_SEPARATOR);
+    const match = DISABLE_DIRECTIVE.exec(directive);
+    if (!match) {
+        return null;
+    }
+    // why: a bare directive with no rule list says nothing about dependency
+    // management, so only an explicit mention of exhaustive-deps counts.
+    const namesExhaustiveDeps = directive
+        .slice(match[0].length)
+        .split(',')
+        .some((ruleId) => ruleId.trim() === EXHAUSTIVE_DEPS_RULE);
+    if (!namesExhaustiveDeps) {
+        return null;
+    }
+    const scope = match[1];
+    if (scope === '-next-line') {
+        return comment.loc.end.line + 1;
+    }
+    if (scope === '-line') {
+        return comment.loc.start.line;
+    }
+    return comment.type === utils_1.AST_TOKEN_TYPES.Block ? 'file' : null;
+}
 /** `channelGroupActive` -> `setChannelGroupActive`, `a` -> `setA`. */
 function toSetterName(dependencyName) {
     return `set${dependencyName.charAt(0).toUpperCase()}${dependencyName.slice(1)}`;
@@ -609,6 +661,53 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
             // In a real environment, we would want to enforce this
             // throw new Error('You have to enable the `project` setting in parser options to use this rule');
         }
+        const sourceCode = context.getSourceCode();
+        // why: scanning every comment once per file rather than once per hook call
+        // keeps the check off the hot path of files with many hooks.
+        let manuallyManagedLines = null;
+        let disabledForWholeFile = false;
+        function collectDisableDirectives() {
+            if (manuallyManagedLines) {
+                return manuallyManagedLines;
+            }
+            const lines = new Set();
+            for (const comment of sourceCode.getAllComments()) {
+                const scope = readExhaustiveDepsDisable(comment);
+                if (scope === 'file') {
+                    disabledForWholeFile = true;
+                }
+                else if (scope !== null) {
+                    lines.add(scope);
+                }
+            }
+            manuallyManagedLines = lines;
+            return lines;
+        }
+        /**
+         * Whether the author has taken manual control of this hook's dependency
+         * array by suppressing `react-hooks/exhaustive-deps` for it.
+         *
+         * why: exhaustive-deps is the rule that would otherwise force every read
+         * value into the array, so disabling it declares the array hand-maintained.
+         * Entries in such an array are load-bearing by construction — an unread one
+         * is a deliberate recompute trigger (a hydration flag, a change-detecting
+         * hash) whose deletion silently returns a stale value. The comment can sit
+         * above the hook call, above the dependency array, or above the closing
+         * `}, [...])` line, so any directive landing anywhere within the call
+         * counts.
+         */
+        function hasManuallyManagedDeps(node) {
+            const lines = collectDisableDirectives();
+            if (disabledForWholeFile) {
+                return true;
+            }
+            for (let line = node.loc.start.line; line <= node.loc.end.line; line += 1) {
+                if (lines.has(line)) {
+                    return true;
+                }
+            }
+            return false;
+        }
         return {
             CallExpression(node) {
                 if (!isHookCall(node)) {
@@ -628,6 +727,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                 }
                 const callbackBody = callbackArg.body;
                 const isEffect = isEffectHookCall(node);
+                const manuallyManagedDeps = hasManuallyManagedDeps(node);
                 // Check each dependency in the array
                 depsArg.elements.forEach((element) => {
                     const unwrappedElement = element ? unwrapExpression(element) : null;
@@ -648,6 +748,16 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                         const result = getObjectUsagesInHook(callbackBody, objectName);
                         // If the object is not used at all, suggest removing it
                         if (result.notUsed) {
+                            // why: deleting an entry from an array the author maintains by
+                            // hand is presumptuous — the suppression is the declaration that
+                            // the entries were chosen deliberately, and an unread one is a
+                            // recompute trigger whose removal yields a stale value. Narrowing
+                            // an entire object (avoidEntireObject) is a different transform
+                            // and stays enabled: it preserves the dependency, it does not
+                            // drop it.
+                            if (manuallyManagedDeps) {
+                                return;
+                            }
                             // why: an effect reruns for its side effects, so a dependency the
                             // body never reads is normally a deliberate re-run trigger
                             // (React's reset-on-scope-change idiom) — deleting it silently

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.58",
+    "date": "2026-08-01T04:26:49.434Z",
+    "rules": [
+      {
+        "name": "enforce-memoize-async",
+        "changeType": "fix",
+        "issues": [
+          1548
+        ],
+        "summary": "skip methods declared Promise<void> (closes #1548)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.57",
+    "date": "2026-08-01T03:42:42.343Z",
+    "rules": [
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          1547
+        ],
+        "summary": "never prune deps from a hand-maintained dependency array (closes #1547)"
+      }
+    ]
+  },
   {
     "version": "1.20.56",
     "date": "2026-08-01T03:08:15.343Z",