@blumintinc/eslint-plugin-blumint 1.20.92 → 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.92',
+        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/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "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",