@blumintinc/eslint-plugin-blumint 1.20.92 → 1.20.94

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.94',
     },
     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,8 @@ exports.enforceDateTTime = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const ts = __importStar(require("typescript"));
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
+const importRemoval_1 = require("../utils/importRemoval");
 exports.enforceDateTTime = (0, createRule_1.createRule)({
     name: 'enforce-date-ttime',
     meta: {
@@ -43,7 +45,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) {
@@ -90,7 +93,102 @@ exports.enforceDateTTime = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * Reporting is deferred to `Program:exit` because an import is unbound only
+         * once no reference to it survives the fix, and a file where two arguments
+         * name the same imported alias overwrites both in a single pass. Judging
+         * each rewrite alone sees the sibling argument still standing, concludes the
+         * binding is alive, and leaves the import stranded with no later pass to
+         * notice — this rule's own reports are resolved by the fix, so nothing
+         * re-reports the debt.
+         */
+        const sites = [];
+        /**
+         * Suppression is applied to reports after a rule emits them, so a suppressed
+         * site keeps its argument while losing its fix. Counting its range toward
+         * orphanhood would unbind an import the surviving text still spells, trading
+         * an unused import for a dangling type.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
+        /**
+         * Supplies a TTime that was left out entirely. Declines whenever the
+         * argument cannot be appended positionally — a gap before TTime would need
+         * every intervening parameter spelled out, and this rule does not invent
+         * them.
+         */
+        function fixOmittedArgument(site, fixer) {
+            const { reference, tTimeIndex } = site;
+            if (reference.typeParameters) {
+                const { params } = reference.typeParameters;
+                if (tTimeIndex === params.length) {
+                    return fixer.insertTextAfter(params[params.length - 1], ', Date');
+                }
+                return null;
+            }
+            if (tTimeIndex === 0) {
+                return fixer.insertTextAfter(reference.typeName, '<Date>');
+            }
+            return null;
+        }
+        /**
+         * The rewrites that actually ship. A site is excluded when its report will
+         * be suppressed, or when its own range holds the last reference to something
+         * the helper cannot rewrite — a locally declared alias, or the enclosing
+         * declaration's own type parameter. 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.
+         *
+         * Screening individually before batching keeps one unfixable site from
+         * vetoing the rest: orphanhood grows monotonically with the overwritten set,
+         * so a site that cannot be planned alone can only ever poison the batch.
+         */
+        function selectRewritableSites() {
+            return sites.filter((site) => site.kind === 'nonDate' &&
+                !isReportSuppressed(site.reportNode) &&
+                (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [site.reportNode.range]) !==
+                    null);
+        }
         return {
+            'Program:exit'() {
+                if (sites.length === 0)
+                    return;
+                const rewrites = selectRewritableSites();
+                const ranges = rewrites.map((site) => site.reportNode.range);
+                // One plan over every surviving rewrite: an import referenced solely by
+                // arguments that all go in this pass is orphaned by their union, even
+                // though no single one of them orphans it.
+                const importRanges = ranges.length > 0
+                    ? (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, ranges)
+                    : null;
+                // The whole batch ships as one fix, so no rewrite can land without the
+                // others that the import's orphanhood was judged against. The rest
+                // report without a fixer; the carrier's pass already resolves them.
+                const carrier = importRanges ? rewrites[0] : undefined;
+                for (const site of sites) {
+                    if (site.kind === 'omitted') {
+                        context.report({
+                            node: site.reportNode,
+                            messageId: 'enforceDateTTime',
+                            data: { typeName: site.typeName },
+                            fix: (fixer) => fixOmittedArgument(site, fixer),
+                        });
+                        continue;
+                    }
+                    context.report({
+                        node: site.reportNode,
+                        messageId: 'enforceDateTTime',
+                        data: { typeName: site.typeName },
+                        fix: site === carrier && importRanges
+                            ? (fixer) => [
+                                ...rewrites.map((rewrite) => fixer.replaceText(rewrite.reportNode, 'Date')),
+                                ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
+                            ]
+                            : null,
+                    });
+                }
+            },
             TSTypeReference(node) {
                 const typeNameNode = node.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName
                     ? node.typeName.right
@@ -114,39 +212,21 @@ exports.enforceDateTTime = (0, createRule_1.createRule)({
                 const tTimeArg = typeArgs[tTimeIndex];
                 const typeName = sourceCode.getText(node.typeName);
                 if (!tTimeArg) {
-                    // TTime is omitted
-                    context.report({
-                        node,
-                        messageId: 'enforceDateTTime',
-                        data: { typeName },
-                        fix(fixer) {
-                            if (node.typeParameters) {
-                                // Already has type parameters, but not enough to cover TTime
-                                const lastParam = node.typeParameters.params[node.typeParameters.params.length - 1];
-                                // Check if we can just append ", Date"
-                                // We can only do this safely if all parameters between existing ones and TTime have defaults.
-                                // For simplicity and safety, we only fix if tTimeIndex is the next one or if it's already provided.
-                                if (tTimeIndex === node.typeParameters.params.length) {
-                                    return fixer.insertTextAfter(lastParam, ', Date');
-                                }
-                            }
-                            else if (tTimeIndex === 0) {
-                                // No type parameters and TTime is the first one
-                                return fixer.insertTextAfter(node.typeName, '<Date>');
-                            }
-                            return null;
-                        },
+                    sites.push({
+                        kind: 'omitted',
+                        reportNode: node,
+                        reference: node,
+                        typeName,
+                        tTimeIndex,
                     });
                 }
                 else if (!isExactDate(tTimeArg)) {
-                    // TTime is provided but is not exactly Date
-                    context.report({
-                        node: tTimeArg,
-                        messageId: 'enforceDateTTime',
-                        data: { typeName },
-                        fix(fixer) {
-                            return fixer.replaceText(tTimeArg, 'Date');
-                        },
+                    sites.push({
+                        kind: 'nonDate',
+                        reportNode: tTimeArg,
+                        reference: node,
+                        typeName,
+                        tTimeIndex,
                     });
                 }
             },

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

@@ -29,6 +29,8 @@ 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 disableDirectives_1 = require("../utils/disableDirectives");
+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 +145,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,18 +345,79 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
             return {};
         }
         const checker = parserServices.program.getTypeChecker();
-        function reportIfRedundant(annotation, assertion, reportNode, fixerTarget) {
+        /**
+         * Reporting is deferred to `Program:exit` because an import is unbound only
+         * once no reference to it survives the fix, and a file where two annotations
+         * name the same imported type strips both in a single pass. Judging each
+         * removal alone sees the sibling annotation still standing, concludes the
+         * binding is alive, and leaves the import stranded with no later pass to
+         * notice — this rule's own reports are resolved by the fix, so nothing
+         * re-reports the debt.
+         */
+        const sites = [];
+        /**
+         * Suppression is applied to reports after a rule emits them, so a suppressed
+         * site keeps its annotation while losing its fix. Counting its removal
+         * toward orphanhood would unbind an import the surviving text still spells,
+         * trading an unused import for a dangling type.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
+        function collectIfRedundant(annotation, assertion, reportNode, fixerTarget) {
             const matchingType = haveMatchingTypes(annotation.typeAnnotation, assertion, checker, parserServices);
             if (!matchingType)
                 return;
-            context.report({
-                node: reportNode,
-                messageId: 'redundantAnnotationAndAssertion',
-                data: { type: matchingType },
-                fix: (fixer) => removeTypeAnnotation(fixer, fixerTarget, sourceCode),
+            sites.push({
+                reportNode,
+                removal: annotationRemovalRange(fixerTarget, sourceCode),
+                matchingType,
             });
         }
+        /**
+         * The sites whose fixes actually ship. A site is excluded when its report
+         * will be suppressed, or when its own removal orphans something the helper
+         * cannot rewrite — a local alias, an interface, a type parameter. 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.
+         *
+         * Screening individually before batching keeps one unfixable site from
+         * vetoing the rest: orphanhood grows monotonically with the removed set, so
+         * a site that cannot be planned alone can only ever poison the batch.
+         */
+        function selectFixableSites() {
+            return sites.filter((site) => !isReportSuppressed(site.reportNode) &&
+                (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [site.removal]) !== null);
+        }
         return {
+            'Program:exit'() {
+                if (sites.length === 0)
+                    return;
+                const fixable = selectFixableSites();
+                const removals = fixable.map((site) => site.removal);
+                // One plan over every surviving removal: an import referenced solely by
+                // annotations that all go in this pass is orphaned by their union, even
+                // though no single one of them orphans it.
+                const importRanges = removals.length > 0
+                    ? (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, removals)
+                    : null;
+                // The whole batch ships as one fix, so no removal can land without the
+                // others that the import's orphanhood was judged against. The rest
+                // report without a fixer; the carrier's pass already resolves them.
+                const carrier = importRanges ? fixable[0] : undefined;
+                for (const site of sites) {
+                    context.report({
+                        node: site.reportNode,
+                        messageId: 'redundantAnnotationAndAssertion',
+                        data: { type: site.matchingType },
+                        fix: site === carrier && importRanges
+                            ? (fixer) => [
+                                ...removals.map((range) => fixer.removeRange([range[0], range[1]])),
+                                ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
+                            ]
+                            : null,
+                    });
+                }
+            },
             VariableDeclarator(node) {
                 if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
                     !node.id.typeAnnotation ||
@@ -360,7 +428,7 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
                 const assertionType = extractAssertionTypeNode(node.init);
                 if (!assertionType)
                     return;
-                reportIfRedundant(node.id.typeAnnotation, assertionType, node.id, node.id.typeAnnotation);
+                collectIfRedundant(node.id.typeAnnotation, assertionType, node.id, node.id.typeAnnotation);
             },
             PropertyDefinition(node) {
                 if (!node.typeAnnotation ||
@@ -371,7 +439,7 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
                 const assertionType = extractAssertionTypeNode(node.value);
                 if (!assertionType)
                     return;
-                reportIfRedundant(node.typeAnnotation, assertionType, node.key, node.typeAnnotation);
+                collectIfRedundant(node.typeAnnotation, assertionType, node.key, node.typeAnnotation);
             },
             FunctionDeclaration(node) {
                 if (!node.returnType)
@@ -379,7 +447,7 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
                 const assertionType = getReturnAssertion(node);
                 if (!assertionType)
                     return;
-                reportIfRedundant(node.returnType, assertionType, node.id ?? node, node.returnType);
+                collectIfRedundant(node.returnType, assertionType, node.id ?? node, node.returnType);
             },
             FunctionExpression(node) {
                 if (node.parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
@@ -390,7 +458,7 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
                 const assertionType = getReturnAssertion(node);
                 if (!assertionType)
                     return;
-                reportIfRedundant(node.returnType, assertionType, node, node.returnType);
+                collectIfRedundant(node.returnType, assertionType, node, node.returnType);
             },
             ArrowFunctionExpression(node) {
                 if (!node.returnType)
@@ -398,7 +466,7 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
                 const assertionType = getReturnAssertion(node);
                 if (!assertionType)
                     return;
-                reportIfRedundant(node.returnType, assertionType, node, node.returnType);
+                collectIfRedundant(node.returnType, assertionType, node, node.returnType);
             },
             MethodDefinition(node) {
                 if (!node.value.returnType)
@@ -406,7 +474,7 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
                 const assertionType = getReturnAssertion(node);
                 if (!assertionType)
                     return;
-                reportIfRedundant(node.value.returnType, assertionType, node.key, node.value.returnType);
+                collectIfRedundant(node.value.returnType, assertionType, node.key, node.value.returnType);
             },
         };
     },

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,48 @@
 [
+  {
+    "version": "1.20.94",
+    "date": "2026-08-03T22:57:52.839Z",
+    "rules": [
+      {
+        "name": "enforce-date-ttime",
+        "changeType": "fix",
+        "issues": [
+          1669
+        ],
+        "summary": "unbind the import two arguments share (closes #1669)"
+      },
+      {
+        "name": "no-redundant-annotation-assertion",
+        "changeType": "fix",
+        "issues": [
+          1668
+        ],
+        "summary": "unbind the import two annotations share (closes #1668)"
+      }
+    ]
+  },
+  {
+    "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",