@blumintinc/eslint-plugin-blumint 1.20.91 → 1.20.93

package/lib/index.js

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

package/lib/rules/enforce-date-ttime.d.ts

@@ -1 +1,2 @@
-export declare const enforceDateTTime: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"enforceDateTTime", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const enforceDateTTime: TSESLint.RuleModule<"enforceDateTTime", [], TSESLint.RuleListener>;

package/lib/rules/enforce-date-ttime.js

@@ -27,6 +27,7 @@ exports.enforceDateTTime = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const ts = __importStar(require("typescript"));
 const createRule_1 = require("../utils/createRule");
+const importRemoval_1 = require("../utils/importRemoval");
 exports.enforceDateTTime = (0, createRule_1.createRule)({
     name: 'enforce-date-ttime',
     meta: {
@@ -43,7 +44,8 @@ exports.enforceDateTTime = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
-        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const sourceCode = context
+            .sourceCode ?? context.getSourceCode();
         const parserServices = sourceCode?.parserServices ?? context.parserServices;
         const checker = parserServices?.program?.getTypeChecker();
         if (!parserServices || !checker) {
@@ -139,14 +141,46 @@ exports.enforceDateTTime = (0, createRule_1.createRule)({
                     });
                 }
                 else if (!isExactDate(tTimeArg)) {
-                    // TTime is provided but is not exactly Date
+                    // TTime is provided but is not exactly Date. Overwriting the argument
+                    // deletes every name it mentions, so the rewrite and the unbinding of
+                    // whatever it was the last reference to are one fix: applying either
+                    // half alone leaves the file worse than applying neither, and since
+                    // this rule's own report is resolved by the fix, nothing re-reports
+                    // the debt an orphaned declaration becomes.
+                    //
+                    // Orphanhood is judged against this one argument's own range and the
+                    // file as it stands, never against what the rest of the `--fix` run
+                    // might also overwrite. A sibling argument naming the same alias may
+                    // be `eslint-disable`d — which a rule cannot see, since suppression is
+                    // applied to reports after they are emitted — so an edit assuming its
+                    // sibling will also go unbinds an import the survivor still
+                    // references, trading an unused import for a dangling type. Judging
+                    // one edit at a time is suppression-safe by construction.
+                    const importRanges = (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [
+                        tTimeArg.range,
+                    ]);
                     context.report({
                         node: tTimeArg,
                         messageId: 'enforceDateTTime',
                         data: { typeName },
-                        fix(fixer) {
-                            return fixer.replaceText(tTimeArg, 'Date');
-                        },
+                        // No plan means the argument holds the last reference to something
+                        // the helper cannot rewrite — a locally declared alias, or the
+                        // enclosing declaration's own type parameter — so the argument
+                        // stays as written: the report without a fixer is the lesser
+                        // damage. Deleting a declaration is a materially riskier edit than
+                        // dropping an import specifier, and a type parameter left unread by
+                        // its own body fails `no-unused-vars` and `noUnusedParameters`
+                        // exactly as an orphaned alias does, on top of turning a
+                        // pass-through generic into one whose argument no longer means
+                        // anything.
+                        ...(importRanges
+                            ? {
+                                fix: (fixer) => [
+                                    fixer.replaceText(tTimeArg, 'Date'),
+                                    ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
+                                ],
+                            }
+                            : {}),
                     });
                 }
             },

package/lib/rules/no-redundant-annotation-assertion.js

@@ -29,6 +29,7 @@ const visitor_keys_1 = require("@typescript-eslint/visitor-keys");
 const ts = __importStar(require("typescript"));
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
+const importRemoval_1 = require("../utils/importRemoval");
 /**
  * Type string formatting flags chosen to keep comparisons stable and predictable.
  * - NoTruncation avoids `...` elisions that can hide important differences.
@@ -143,10 +144,15 @@ function findTypeAnnotationStart(typeAnnotation, sourceCode) {
     }
     return removalStart;
 }
-function removeTypeAnnotation(fixer, typeAnnotation, sourceCode) {
-    const end = typeAnnotation.range[1];
-    const removalStart = findTypeAnnotationStart(typeAnnotation, sourceCode);
-    return fixer.removeRange([removalStart, end]);
+/**
+ * The slice a fix deletes to drop `typeAnnotation`: the `:` and the whitespace
+ * separating it from the declared name go with the type.
+ */
+function annotationRemovalRange(typeAnnotation, sourceCode) {
+    return [
+        findTypeAnnotationStart(typeAnnotation, sourceCode),
+        typeAnnotation.range[1],
+    ];
 }
 function typeText(type, checker) {
     return checker.typeToString(type, undefined, typeFormatFlags());
@@ -338,15 +344,49 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
             return {};
         }
         const checker = parserServices.program.getTypeChecker();
+        /**
+         * Reports the redundant annotation, taking with it any import it was the
+         * only consumer of. The two are one fix: applying either half alone leaves
+         * the file worse than applying neither — a stripped annotation with its
+         * import left behind fails `no-unused-vars`, and since this rule's own
+         * report is resolved by the fix, nothing re-reports the debt.
+         *
+         * Orphanhood is judged against this one annotation's own removal and the
+         * file as it stands, never against what the rest of the `--fix` run might
+         * also delete. A sibling annotation naming the same type may be
+         * `eslint-disable`d — which a rule cannot see, since suppression is applied
+         * to reports after they are emitted — so an edit that assumes its sibling
+         * will also go deletes an import the surviving annotation still references,
+         * trading an unused import for a dangling type. Judging one edit at a time
+         * is suppression-safe by construction: a suppressed report's fix never
+         * applies, so it can never have been depended on.
+         *
+         * A type the annotation names but the helper cannot rewrite — a local alias,
+         * an interface, a type parameter — declines the fix outright. Deleting a
+         * declaration is a materially riskier edit than dropping an import
+         * specifier, and the author is better placed to decide whether the type
+         * should go or be used elsewhere.
+         */
         function reportIfRedundant(annotation, assertion, reportNode, fixerTarget) {
             const matchingType = haveMatchingTypes(annotation.typeAnnotation, assertion, checker, parserServices);
             if (!matchingType)
                 return;
+            const removal = annotationRemovalRange(fixerTarget, sourceCode);
+            const importRanges = (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [removal]);
             context.report({
                 node: reportNode,
                 messageId: 'redundantAnnotationAndAssertion',
                 data: { type: matchingType },
-                fix: (fixer) => removeTypeAnnotation(fixer, fixerTarget, sourceCode),
+                // No plan means no binding can be unbound safely, so the annotation
+                // stays too: the report without a fixer is the lesser damage.
+                ...(importRanges
+                    ? {
+                        fix: (fixer) => [
+                            fixer.removeRange([removal[0], removal[1]]),
+                            ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
+                        ],
+                    }
+                    : {}),
             });
         }
         return {

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

@@ -6,6 +6,7 @@ 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
@@ -200,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;
@@ -312,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))
@@ -370,66 +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;
-                        }
-                        // The callee is the text this fix deletes, so it is 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.
-                        //
-                        // Orphanhood is judged against this one callee's removal and the
-                        // file as it stands. A second `useMemo` call site keeps the
-                        // specifier, even one this rule also reports: that sibling may be
-                        // `eslint-disable`d (suppression is applied after a rule emits its
-                        // reports, so its fix never runs) or lose its fix to a conflict, and
-                        // either way the surviving call would spell a name nothing binds. A
-                        // later pass, reading a source where the sibling is already
-                        // converted, finds the specifier orphaned and removes it then.
-                        const importRemoval = (0, importRemoval_1.planOrphanedImportRemoval)(context.sourceCode, [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;
-                        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));
-                        fixes.push(...importRemoval.map((range) => fixer.removeRange([range[0], range[1]])));
-                        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.91",
+  "version": "1.20.93",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,48 @@
 [
+  {
+    "version": "1.20.93",
+    "date": "2026-08-03T22:34:05.616Z",
+    "rules": [
+      {
+        "name": "enforce-date-ttime",
+        "changeType": "fix",
+        "issues": [
+          1667
+        ],
+        "summary": "keep the alias it rewrites away (closes #1667)"
+      },
+      {
+        "name": "no-redundant-annotation-assertion",
+        "changeType": "fix",
+        "issues": [
+          1666
+        ],
+        "summary": "keep the type its annotation named (closes #1666)"
+      }
+    ]
+  },
+  {
+    "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",