@blumintinc/eslint-plugin-blumint 1.20.93 → 1.20.95

package/lib/index.js

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

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 disableDirectives_1 = require("../utils/disableDirectives");
 const importRemoval_1 = require("../utils/importRemoval");
 exports.enforceDateTTime = (0, createRule_1.createRule)({
     name: 'enforce-date-ttime',
@@ -92,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
@@ -116,71 +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. 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 },
-                        // 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]])),
-                                ],
-                            }
-                            : {}),
+                    sites.push({
+                        kind: 'nonDate',
+                        reportNode: tTimeArg,
+                        reference: node,
+                        typeName,
+                        tTimeIndex,
                     });
                 }
             },

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 disableDirectives_1 = require("../utils/disableDirectives");
 const importRemoval_1 = require("../utils/importRemoval");
 /**
  * Type string formatting flags chosen to keep comparisons stable and predictable.
@@ -345,51 +346,78 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
         }
         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.
+         * 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.
          */
-        function reportIfRedundant(annotation, assertion, reportNode, fixerTarget) {
+        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;
-            const removal = annotationRemovalRange(fixerTarget, sourceCode);
-            const importRanges = (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [removal]);
-            context.report({
-                node: reportNode,
-                messageId: 'redundantAnnotationAndAssertion',
-                data: { type: matchingType },
-                // 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]])),
-                        ],
-                    }
-                    : {}),
+            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 ||
@@ -400,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 ||
@@ -411,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)
@@ -419,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) {
@@ -430,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)
@@ -438,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)
@@ -446,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/lib/rules/no-redundant-param-types.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noRedundantParamTypes = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
 const importRemoval_1 = require("../utils/importRemoval");
 /**
  * The annotation a parameter carries, or `undefined` when it has none. A
@@ -68,57 +69,88 @@ exports.noRedundantParamTypes = (0, createRule_1.createRule)({
     create(context) {
         const sourceCode = context.getSourceCode();
         /**
-         * Reports a parameter annotation, taking with it any import it was the only
+         * An annotation is stripped together with 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.
+         * Reporting is therefore deferred to `Program:exit`: 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.
+         */
+        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);
+        /**
+         * The strips that 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.
          *
-         * The cost is that a type shared by several strippable annotations is not
-         * unbound in a single pass; each pass removes the annotations it can see,
-         * and only a pass that leaves the binding with no reference at all removes
-         * the import.
+         * 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 reportParam(param, typeAnnotation) {
-            const removal = annotationRemovalRange(typeAnnotation, sourceCode);
-            const importRanges = (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [removal]);
-            context.report({
-                node: param,
-                messageId: 'redundantParamType',
-                data: {
-                    paramText: sourceCode.getText(param).replace(/\s+/g, ' ').trim(),
-                },
-                // 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]])),
-                        ],
-                    }
-                    : {}),
-            });
+        function selectFixableSites() {
+            return sites.filter((site) => !isReportSuppressed(site.param) &&
+                (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 strip: 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 strip 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.
+                //
+                // No plan at all means no binding can be unbound safely, so every
+                // annotation stays: reports without a fixer are the lesser damage.
+                const carrier = importRanges ? fixable[0] : undefined;
+                for (const site of sites) {
+                    context.report({
+                        node: site.param,
+                        messageId: 'redundantParamType',
+                        data: { paramText: site.paramText },
+                        fix: site === carrier && importRanges
+                            ? (fixer) => [
+                                ...removals.map((range) => fixer.removeRange([range[0], range[1]])),
+                                ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
+                            ]
+                            : null,
+                    });
+                }
+            },
             ArrowFunctionExpression(node) {
                 if (!hasRedundantTypeAnnotation(node))
                     return;
                 node.params.forEach((param) => {
                     const typeAnnotation = annotationOf(param);
-                    if (typeAnnotation) {
-                        reportParam(param, typeAnnotation);
-                    }
+                    if (!typeAnnotation)
+                        return;
+                    sites.push({
+                        param,
+                        removal: annotationRemovalRange(typeAnnotation, sourceCode),
+                        paramText: sourceCode.getText(param).replace(/\s+/g, ' ').trim(),
+                    });
                 });
             },
         };

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.20.95",
+    "date": "2026-08-03T23:44:33.733Z",
+    "rules": [
+      {
+        "name": "no-redundant-param-types",
+        "changeType": "fix",
+        "issues": [
+          1670
+        ],
+        "summary": "unbind the import two annotations share (closes #1670)"
+      }
+    ]
+  },
+  {
+    "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",