@blumintinc/eslint-plugin-blumint 1.20.94 → 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.94',
+        version: '1.20.95',
     },
     parseOptions: {
         ecmaVersion: 2020,

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.94",
+  "version": "1.20.95",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

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