@blumintinc/eslint-plugin-blumint 1.20.90 → 1.20.92

package/lib/index.js

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

package/lib/rules/prefer-map-over-conditional-dispatch.js

@@ -203,6 +203,15 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
          * Resolve a case-test / equality-test node to a literal key. Handles inline
          * literals directly and constant references (e.g. `THIS_DEVICE_STATUS.active`)
          * via the checker.
+         *
+         * A test the checker had to resolve carries its source text along with the
+         * value: the value proves the key is a literal, but emitting the value as
+         * the key destroys the expression it came from. For a constant reference
+         * that orphans the constant (an imported one then trips `no-unused-vars`)
+         * and bakes its value into the call site, discarding the single source of
+         * truth the constant exists to provide; for `case -1:` the resolved value
+         * does not even print as a legal object key (`{ -1: v }` does not parse).
+         * The fixer emits a computed key from the source text instead.
          */
         function resolveLiteralKey(node) {
             if (node.type === utils_1.AST_NODE_TYPES.Literal) {
@@ -218,7 +227,11 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             if (!type) {
                 return null;
             }
-            return literalValueOf(type);
+            const literal = literalValueOf(type);
+            if (!literal) {
+                return null;
+            }
+            return { ...literal, sourceText: sourceCode.getText(node) };
         }
         function computeValueTypeText(exprs) {
             const seen = new Set();
@@ -589,6 +602,13 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
         }
         // ---- Fix construction ---------------------------------------------------
         function formatKey(key) {
+            if (key.sourceText !== undefined) {
+                // Computed key preserving the constant reference the case tested on.
+                // Type-safe by construction: the fix is reached only after the checker
+                // resolved this expression to a string/number *literal* type, so the
+                // computed key is a literal key and the Record stays exhaustive.
+                return `[${key.sourceText}]`;
+            }
             if (key.kind === 'number') {
                 return String(key.value);
             }

package/lib/rules/prefer-use-deep-compare-memo.js

@@ -5,6 +5,8 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const importInsertion_1 = require("../utils/importInsertion");
+const importRemoval_1 = require("../utils/importRemoval");
+const disableDirectives_1 = require("../utils/disableDirectives");
 const DEEP_COMPARE_MODULE = '@blumintinc/use-deep-compare';
 const DEEP_COMPARE_HOOK = 'useDeepCompareMemo';
 // Consider these as memoizing hooks producing stable references
@@ -199,6 +201,50 @@ function bindsHookImport(variable, hookImport) {
         variable.defs.length > 0 &&
         variable.defs.every((def) => def.node === hookImport));
 }
+/**
+ * Whether the name the rewrite spells resolves, at this call site, to nothing or
+ * to the very import this fix would insert. Any other binding makes the edit
+ * wrong twice over: the inserted import declares the name a second time
+ * (TS2440/TS2300), and a shadowing parameter or local silently routes the call
+ * to the wrong value with no diagnostic at all. Such a call site keeps its
+ * report and stays out of the batch, so the author migrates it deliberately —
+ * and, still spelling `useMemo`, it holds the specifier the batch would
+ * otherwise unbind.
+ */
+function emitsResolvableHook(call, hookImport) {
+    const existing = ASTHelpers_1.ASTHelpers.findVariableInScope(call.scope, DEEP_COMPARE_HOOK);
+    return !existing || bindsHookImport(existing, hookImport);
+}
+/**
+ * The single fix that converts every call in `calls`, imports the hook once, and
+ * unbinds whatever the conversions stop reading.
+ *
+ * Batching is what makes the unbinding reachable at all. Judged one call at a
+ * time, a file with two convertible calls never sees either as the specifier's
+ * sole remaining reference, and once both are rewritten the rule no longer
+ * reports — so nothing revisits the stranded import. The batch is sound only
+ * because it contains exactly the calls this one fix rewrites: siblings the
+ * caller has already dropped for being suppressed or unfixable are absent, so no
+ * unbinding is ever claimed on the strength of an edit that does not happen.
+ */
+function convertCallsFixes(context, fixer, calls) {
+    // The callees are the text this fix deletes, so they are also the text
+    // whatever carried the hook stops being read from: `useMemo` for a bare call,
+    // `React` for a member call. A binding left with no reference at all is
+    // unbound here, in this same fix — stripping its last use and keeping the
+    // declaration trades this rule's report for an unused-import one, and nothing
+    // re-reports that debt once the rewrite has resolved the original violation.
+    const importRemoval = (0, importRemoval_1.planOrphanedImportRemoval)(context.sourceCode, calls.map((call) => call.node.callee.range));
+    // No plan means a binding is orphaned yet cannot be unbound safely, so the
+    // rewrite stays too: the report without a fixer is the lesser damage.
+    if (!importRemoval)
+        return null;
+    return [
+        ...calls.map((call) => fixer.replaceText(call.node.callee, DEEP_COMPARE_HOOK)),
+        ...ensureDeepCompareImportFixes(context, fixer),
+        ...importRemoval.map((range) => fixer.removeRange([range[0], range[1]])),
+    ];
+}
 function ensureDeepCompareImportFixes(context, fixer) {
     const sourceCode = context.sourceCode;
     const program = sourceCode.ast;
@@ -218,49 +264,6 @@ function ensureDeepCompareImportFixes(context, fixer) {
         (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importAnchorLineStart)(sourceCode, anchor), importText),
     ];
 }
-function findVariableInScope(scope, name) {
-    if (!scope)
-        return null;
-    const found = scope.variables?.find((v) => v.name === name);
-    if (found)
-        return found;
-    if (Array.isArray(scope.childScopes)) {
-        for (const child of scope.childScopes) {
-            const v = findVariableInScope(child, name);
-            if (v)
-                return v;
-        }
-    }
-    return null;
-}
-function isIdentifierReferenced(sourceCode, name) {
-    const scope = sourceCode.scopeManager?.globalScope;
-    if (!scope)
-        return true;
-    const variable = findVariableInScope(scope, name);
-    if (!variable)
-        return false;
-    return variable.references.some((ref) => ref.identifier && ref.identifier.name === name);
-}
-function removeImportSpecifierFixes(sourceCode, fixer, importDecl, specifier) {
-    const fixes = [];
-    if (importDecl.specifiers.length === 1) {
-        fixes.push(fixer.remove(importDecl));
-        return fixes;
-    }
-    const tokenAfter = sourceCode.getTokenAfter(specifier);
-    const tokenBefore = sourceCode.getTokenBefore(specifier);
-    if (tokenAfter && tokenAfter.value === ',') {
-        fixes.push(fixer.removeRange([specifier.range[0], tokenAfter.range[1]]));
-    }
-    else if (tokenBefore && tokenBefore.value === ',') {
-        fixes.push(fixer.removeRange([tokenBefore.range[0], specifier.range[1]]));
-    }
-    else {
-        fixes.push(fixer.remove(specifier));
-    }
-    return fixes;
-}
 function isImportedIdentifier(context, name) {
     const sourceCode = context.sourceCode;
     const program = sourceCode.ast;
@@ -354,6 +357,18 @@ exports.preferUseDeepCompareMemo = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         const memoizedIds = collectMemoizedIdentifiers(context);
+        // Reporting is deferred to Program:exit because the import rewrite depends
+        // on knowing every conversion in the file: the `useMemo` specifier may only
+        // be unbound once no reference to it survives the fix, and a file where two
+        // call sites convert in the same pass has no later pass to notice that.
+        const calls = [];
+        /**
+         * A suppressed report is discarded together with its fix, yet its
+         * `useMemo(...)` call stays in the file. Counting such a call as converted
+         * would unbind an import the surviving text still spells — trading an unused
+         * import for a dangling reference, a lint warning for a compile error.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         return {
             CallExpression(node) {
                 if (!isUseMemoCallee(node.callee))
@@ -412,63 +427,35 @@ exports.preferUseDeepCompareMemo = (0, createRule_1.createRule)({
                 }
                 if (!hasUnmemoizedNonPrimitive)
                     return;
-                // Captured during traversal because the fix runs afterwards, when an
-                // ESLint version lacking sourceCode.getScope can only report the
-                // global scope and would miss a narrower shadow.
-                const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
-                context.report({
-                    node,
-                    messageId: 'preferUseDeepCompareMemo',
-                    data: {
-                        hook: 'useMemo',
-                    },
-                    fix(fixer) {
-                        // Resolve the emitted name through the scope chain at the call
-                        // site. A binding that is not this fix's own import makes the edit
-                        // wrong twice over: the inserted import declares the name a second
-                        // time (TS2440/TS2300), and a shadowing parameter or local silently
-                        // routes the call to the wrong value with no diagnostic at all.
-                        // Declining leaves the report so the author migrates deliberately —
-                        // including the useMemo specifier removal below, which would
-                        // otherwise strip an import the untouched call site still needs.
-                        const existing = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, DEEP_COMPARE_HOOK);
-                        if (existing &&
-                            !bindsHookImport(existing, findDeepCompareMemoImport(context.sourceCode.ast))) {
-                            return null;
-                        }
-                        const fixes = [];
-                        // Replace callee
-                        if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            fixes.push(fixer.replaceText(node.callee, 'useDeepCompareMemo'));
-                        }
-                        else if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                            fixes.push(fixer.replaceText(node.callee, 'useDeepCompareMemo'));
-                        }
-                        // Ensure import exists
-                        fixes.push(...ensureDeepCompareImportFixes(context, fixer));
-                        // Clean up now-unused React/useMemo imports if safe
-                        const sourceCode = context.sourceCode;
-                        const program = sourceCode.ast;
-                        const reactImport = program.body.find((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
-                            n.source.value === 'react');
-                        if (reactImport) {
-                            // remove named useMemo if unused
-                            const useMemoSpec = reactImport.specifiers.find((s) => s.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                                s.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                s.imported.name === 'useMemo');
-                            if (useMemoSpec &&
-                                !isIdentifierReferenced(sourceCode, useMemoSpec.local.name)) {
-                                fixes.push(...removeImportSpecifierFixes(sourceCode, fixer, reactImport, useMemoSpec));
-                            }
-                            const defaultSpec = reactImport.specifiers.find((s) => s.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
-                            if (defaultSpec &&
-                                !isIdentifierReferenced(sourceCode, defaultSpec.local.name)) {
-                                fixes.push(...removeImportSpecifierFixes(sourceCode, fixer, reactImport, defaultSpec));
-                            }
-                        }
-                        return fixes;
-                    },
-                });
+                calls.push({ node, scope: ASTHelpers_1.ASTHelpers.getScope(context, node) });
+            },
+            'Program:exit'() {
+                if (calls.length === 0)
+                    return;
+                const hookImport = findDeepCompareMemoImport(context.sourceCode.ast);
+                // Exactly the calls the carrier's fix rewrites: a suppressed report
+                // loses its fix, and one whose scope binds the hook name to something
+                // else must not be rewritten at all.
+                const converted = calls.filter((call) => !isReportSuppressed(call.node) &&
+                    emitsResolvableHook(call, hookImport));
+                // The carrier is the first violation whose fix actually survives, so a
+                // suppressed or unfixable leading violation cannot take the batch down
+                // with it. Every other report emits without a fixer: the carrier's one
+                // pass already resolves them, and a second fixer would either duplicate
+                // its edits or contradict them.
+                const [carrier] = converted;
+                for (const call of calls) {
+                    context.report({
+                        node: call.node,
+                        messageId: 'preferUseDeepCompareMemo',
+                        data: {
+                            hook: 'useMemo',
+                        },
+                        fix: call === carrier
+                            ? (fixer) => convertCallsFixes(context, fixer, converted)
+                            : null,
+                    });
+                }
             },
         };
     },

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.20.92",
+    "date": "2026-08-03T19:30:56.799Z",
+    "rules": [
+      {
+        "name": "prefer-map-over-conditional-dispatch",
+        "changeType": "fix",
+        "issues": [
+          1663
+        ],
+        "summary": "emit computed keys for resolved case tests (closes #1663)"
+      },
+      {
+        "name": "prefer-use-deep-compare-memo",
+        "changeType": "fix",
+        "issues": [
+          1662
+        ],
+        "summary": "convert every call site in one edit (closes #1662)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.91",
+    "date": "2026-08-03T15:15:42.831Z",
+    "rules": [
+      {
+        "name": "prefer-use-deep-compare-memo",
+        "changeType": "fix",
+        "issues": [
+          1661
+        ],
+        "summary": "unbind the orphaned useMemo import (closes #1661)"
+      }
+    ]
+  },
   {
     "version": "1.20.90",
     "date": "2026-08-03T13:37:18.271Z",