@blumintinc/eslint-plugin-blumint 1.20.88 → 1.20.89

package/lib/index.js

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

package/lib/rules/memo-compare-deeply-complex-props.js

@@ -577,7 +577,60 @@ function checkUnionType(ts, unionType, checker, visited) {
 function isIntersectionType(ts, flags) {
     return (flags & ts.TypeFlags.Intersection) !== 0;
 }
+/**
+ * Returns true when `type` holds a JavaScript primitive at runtime — a string,
+ * number, boolean, bigint, symbol, enum member, or any literal/template/mapping
+ * flavour of those. A union qualifies when every constituent does.
+ *
+ * Deliberately narrower than `isPrimitiveType`, which also accepts
+ * `null`/`undefined`/`void`/`never`: those carry no runtime *value* to reason
+ * about, and inside an intersection they collapse the whole type to `never`
+ * anyway, so admitting them would prove nothing about the surviving members.
+ */
+function isRuntimePrimitiveType(ts, type) {
+    const flags = type.flags ?? 0;
+    if ((flags &
+        (ts.TypeFlags.StringLike |
+            ts.TypeFlags.NumberLike |
+            ts.TypeFlags.BooleanLike |
+            ts.TypeFlags.BigIntLike |
+            ts.TypeFlags.ESSymbolLike |
+            ts.TypeFlags.EnumLike)) !==
+        0) {
+        return true;
+    }
+    // `('a' | 'b') & {}` can surface the literal union as a single member.
+    if ((flags & ts.TypeFlags.Union) !== 0) {
+        const members = type.types;
+        return (members.length > 0 &&
+            members.every((member) => isRuntimePrimitiveType(ts, member)));
+    }
+    return false;
+}
+/**
+ * Detects the open-ended literal union idiom — a primitive intersected with an
+ * object type, e.g. `'alert' | 'button' | (string & {})`, of which React's own
+ * `AriaRole` is the most widespread instance. The `& {}` exists purely to defeat
+ * TypeScript's literal-union widening so editors keep offering autocomplete on
+ * the named members; it contributes no runtime object identity.
+ *
+ * A value of `string & X` is still assignable to `string`, so it is a primitive
+ * at runtime no matter what `X` is. That makes `compareDeeply('role')` provably
+ * inert: the consuming comparator only reaches deep equality behind a
+ * `typeof value === 'object'` guard, and `isEqual` on two primitives is `===`
+ * regardless. So the reduction keys on "the intersection has a primitive
+ * member", not on the object member being empty — branded primitives
+ * (`string & { brand: 'x' }`) reduce identically, and the widener is spelled
+ * several ways in the wild (`{}`, `Record<never, never>`, `Record<string, never>`)
+ * that no structural emptiness test or name allowlist covers uniformly.
+ */
+function isPrimitiveBackedIntersection(ts, intersectionType) {
+    return intersectionType.types.some((member) => isRuntimePrimitiveType(ts, member));
+}
 function checkIntersectionType(ts, intersectionType, checker, visited) {
+    if (isPrimitiveBackedIntersection(ts, intersectionType)) {
+        return false;
+    }
     return intersectionType.types.some((t) => isComplexTypeInternal(ts, t, checker, visited));
 }
 function isPrimitiveType(ts, flags) {

package/lib/rules/no-explicit-return-type.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noExplicitReturnType = 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");
 const defaultOptions = {
     allowRecursiveFunctions: true,
@@ -640,6 +641,80 @@ function declaresVoidResult(returnType) {
     return (typeArguments?.length === 1 &&
         typeArguments[0].type === utils_1.AST_NODE_TYPES.TSVoidKeyword);
 }
+function containsRange(outer, inner) {
+    return inner[0] >= outer[0] && inner[1] <= outer[1];
+}
+/**
+ * Partitions annotations into the sets whose removals have to travel together.
+ *
+ * An import read from two annotations is unbound only once both are gone, so
+ * neither annotation may unbind it alone — and a fix may only count on the other
+ * removal happening if it performs that removal itself. Annotations that jointly
+ * keep an import alive are therefore merged into one batch, and every other
+ * annotation is a batch of one, judged against the file as it stands.
+ *
+ * `candidates` must already exclude suppressed reports: a suppressed report's
+ * fix never runs, so its annotation — and the reference it holds — outlives the
+ * pass.
+ */
+function batchAnnotations(source, candidates) {
+    const parents = candidates.map((_, index) => index);
+    const rootOf = (index) => {
+        let root = index;
+        while (parents[root] !== root) {
+            root = parents[root];
+        }
+        return root;
+    };
+    const ownerOf = (reference) => candidates.findIndex((candidate) => containsRange(candidate.returnType.range, reference));
+    for (const binding of (0, importRemoval_1.importBindingReferences)(source)) {
+        // A single reference cannot be shared, so the one-annotation judgement
+        // already covers it.
+        if (binding.references.length < 2)
+            continue;
+        const owners = new Set();
+        const escapes = binding.references.some((reference) => {
+            const owner = ownerOf(reference);
+            if (owner === -1)
+                return true;
+            owners.add(owner);
+            return false;
+        });
+        // A reference outside every strippable annotation survives whatever this
+        // pass deletes, so no batch can unbind the import.
+        if (escapes || owners.size < 2)
+            continue;
+        const [target, ...rest] = [...owners].map(rootOf);
+        for (const root of rest) {
+            if (root !== target) {
+                parents[root] = target;
+            }
+        }
+    }
+    const batches = new Map();
+    candidates.forEach((candidate, index) => {
+        const root = rootOf(index);
+        const batch = batches.get(root);
+        if (batch) {
+            batch.push(candidate);
+        }
+        else {
+            batches.set(root, [candidate]);
+        }
+    });
+    return [...batches.values()];
+}
+/**
+ * The ranges a single fix deletes for `batch`: the annotations themselves plus
+ * any import they were the last consumers of. `null` when a binding the removal
+ * orphans cannot be unbound safely — the caller then drops the fix rather than
+ * emitting the half of it that leaves a binding behind.
+ */
+function planRemoval(source, batch) {
+    const annotations = batch.map((entry) => entry.returnType.range);
+    const imports = (0, importRemoval_1.planOrphanedImportRemoval)(source, annotations);
+    return imports ? [...annotations, ...imports] : null;
+}
 exports.noExplicitReturnType = (0, createRule_1.createRule)({
     name: 'no-explicit-return-type',
     meta: {
@@ -677,6 +752,14 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
         const filename = context.getFilename();
         const sourceCode = context.getSourceCode();
         const visitorKeys = sourceCode.visitorKeys;
+        const pending = [];
+        /**
+         * Whether ESLint will discard a report, resolved the way ESLint resolves
+         * it. A fix that deletes several annotations at once is counting on all of
+         * them being reportable; a suppressed one keeps its type reference, so it
+         * must be left out of every batch.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         // Built at most once per file, and only when a direct self-reference has
         // already been ruled out.
         let returnReferenceGraph;
@@ -727,46 +810,75 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 declaresVoidResult(returnType));
         }
         /**
-         * Reports an 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.
+         * Holds an annotation for `flushReports`, which decides once the file has
+         * been walked which removals may travel together.
+         */
+        function reportAnnotation(node, returnType, strippable) {
+            pending.push({ node, returnType, strippable });
+        }
+        /**
+         * Emits every held report, each carrying the import cleanup its own
+         * removal makes necessary. An annotation and the import it unbinds are one
+         * fix: applying either half alone leaves the file worse than applying
+         * neither.
          *
-         * Orphanhood is judged against this 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.
+         * Orphanhood is judged against a single fix's own deletions, never against
+         * what the rest of the `--fix` run might also delete. That is what makes
+         * the cleanup suppression-safe, and it is why a type several annotations
+         * share cannot be unbound by any one of them: a sibling annotation may be
+         * `eslint-disable`d, and deleting "its" import strands a reference that
+         * outlives the pass — a compile error in place of an unused import.
          *
-         * 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.
+         * Waiting for the last such annotation does not work either. Once every
+         * annotation is stripped the rule has nothing left to report, so no later
+         * fix exists to carry the cleanup and the binding stays orphaned for good
+         * (issue #1654). The annotations that jointly hold an import alive are
+         * therefore removed by one fix, which owes two things: it deletes all of
+         * them itself rather than assuming sibling reports land, and it counts
+         * only annotations whose reports ESLint will not discard.
          */
-        function reportAnnotation(node, returnType, strippable) {
-            const importRanges = strippable
-                ? (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [returnType.range])
-                : null;
-            context.report({
-                node: returnType,
-                messageId: strippable
-                    ? 'noExplicitReturnTypeInferable'
-                    : 'noExplicitReturnTypeNonInferable',
-                data: { functionKind: describeFunctionKind(node) },
-                ...(importRanges
-                    ? {
-                        fix: (fixer) => [
-                            fixer.remove(returnType),
-                            ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
-                        ],
-                    }
-                    : {}),
-            });
+        function flushReports() {
+            const strippable = pending.filter((entry) => entry.strippable);
+            // Every annotation starts with the judgement it would get alone, so a
+            // batch can only ever add a cleanup, never withdraw one.
+            const plans = new Map();
+            for (const entry of strippable) {
+                const plan = planRemoval(sourceCode, [entry]);
+                if (plan) {
+                    plans.set(entry, plan);
+                }
+            }
+            const batches = batchAnnotations(sourceCode, strippable.filter((entry) => !isReportSuppressed(entry.returnType)));
+            for (const batch of batches) {
+                if (batch.length < 2)
+                    continue;
+                const plan = planRemoval(sourceCode, batch);
+                if (!plan)
+                    continue;
+                for (const entry of batch) {
+                    plans.set(entry, plan);
+                }
+            }
+            for (const entry of pending) {
+                const plan = plans.get(entry);
+                context.report({
+                    node: entry.returnType,
+                    messageId: entry.strippable
+                        ? 'noExplicitReturnTypeInferable'
+                        : 'noExplicitReturnTypeNonInferable',
+                    data: { functionKind: describeFunctionKind(entry.node) },
+                    ...(plan
+                        ? {
+                            fix: (fixer) => plan.map((range) => fixer.removeRange([range[0], range[1]])),
+                        }
+                        : {}),
+                });
+            }
         }
         return {
+            'Program:exit'() {
+                flushReports();
+            },
             FunctionDeclaration(node) {
                 const returnType = node.returnType;
                 if (!returnType)

package/lib/rules/no-redundant-param-types.js

@@ -3,33 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noRedundantParamTypes = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
-function isIdentifierWithTypeAnnotation(node) {
-    return (node.type === utils_1.AST_NODE_TYPES.Identifier && node.typeAnnotation !== undefined);
-}
-function isRestElementWithTypeAnnotation(node) {
-    return (node.type === utils_1.AST_NODE_TYPES.RestElement &&
-        node.typeAnnotation !== undefined);
-}
-function isObjectPatternWithTypeAnnotation(node) {
-    return (node.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
-        node.typeAnnotation !== undefined);
-}
-function isArrayPatternWithTypeAnnotation(node) {
-    return (node.type === utils_1.AST_NODE_TYPES.ArrayPattern &&
-        node.typeAnnotation !== undefined);
-}
-function isAssignmentPatternWithTypeAnnotation(node) {
-    return (node.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
-        node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
-        node.left.typeAnnotation !== undefined);
+const importRemoval_1 = require("../utils/importRemoval");
+/**
+ * The annotation a parameter carries, or `undefined` when it has none. A
+ * parameter with a default value holds its annotation on the pattern it assigns
+ * to, and only an identifier pattern is read there: a destructured parameter
+ * with a default keeps its annotation.
+ */
+function annotationOf(param) {
+    if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+        return param.left.type === utils_1.AST_NODE_TYPES.Identifier
+            ? param.left.typeAnnotation
+            : undefined;
+    }
+    return param.typeAnnotation;
 }
-function removeTypeAnnotation(fixer, typeAnnotation, sourceCode) {
-    const typeStart = typeAnnotation.range[0];
-    const typeEnd = typeAnnotation.range[1];
-    // Check if there's a question mark before the type annotation
+/**
+ * The slice a fix deletes to drop `typeAnnotation`. An optional marker goes with
+ * it: contextual typing supplies a parameter's optionality along with its type,
+ * so a `?` left behind keeps half of the duplication the rule exists to remove.
+ */
+function annotationRemovalRange(typeAnnotation, sourceCode) {
+    const [typeStart, typeEnd] = typeAnnotation.range;
     const hasQuestionMark = typeStart > 0 && sourceCode.getText().charAt(typeStart - 1) === '?';
-    const startPos = hasQuestionMark ? typeStart - 1 : typeStart;
-    return fixer.removeRange([startPos, typeEnd]);
+    return [hasQuestionMark ? typeStart - 1 : typeStart, typeEnd];
 }
 function hasRedundantTypeAnnotation(node) {
     const parent = node.parent;
@@ -69,67 +66,58 @@ exports.noRedundantParamTypes = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.getSourceCode();
+        /**
+         * Reports a parameter 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.
+         *
+         * 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.
+         */
+        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]])),
+                        ],
+                    }
+                    : {}),
+            });
+        }
         return {
             ArrowFunctionExpression(node) {
                 if (!hasRedundantTypeAnnotation(node))
                     return;
-                const params = node.params;
-                const sourceCode = context.getSourceCode();
-                params.forEach((param) => {
-                    const paramText = sourceCode
-                        .getText(param)
-                        .replace(/\s+/g, ' ')
-                        .trim();
-                    if (isIdentifierWithTypeAnnotation(param)) {
-                        context.report({
-                            node: param,
-                            messageId: 'redundantParamType',
-                            data: { paramText },
-                            fix(fixer) {
-                                return removeTypeAnnotation(fixer, param.typeAnnotation, sourceCode);
-                            },
-                        });
-                    }
-                    else if (isRestElementWithTypeAnnotation(param)) {
-                        context.report({
-                            node: param,
-                            messageId: 'redundantParamType',
-                            data: { paramText },
-                            fix(fixer) {
-                                return removeTypeAnnotation(fixer, param.typeAnnotation, sourceCode);
-                            },
-                        });
-                    }
-                    else if (isObjectPatternWithTypeAnnotation(param)) {
-                        context.report({
-                            node: param,
-                            messageId: 'redundantParamType',
-                            data: { paramText },
-                            fix(fixer) {
-                                return removeTypeAnnotation(fixer, param.typeAnnotation, sourceCode);
-                            },
-                        });
-                    }
-                    else if (isArrayPatternWithTypeAnnotation(param)) {
-                        context.report({
-                            node: param,
-                            messageId: 'redundantParamType',
-                            data: { paramText },
-                            fix(fixer) {
-                                return removeTypeAnnotation(fixer, param.typeAnnotation, sourceCode);
-                            },
-                        });
-                    }
-                    else if (isAssignmentPatternWithTypeAnnotation(param)) {
-                        const { left } = param;
-                        context.report({
-                            node: param,
-                            messageId: 'redundantParamType',
-                            data: { paramText },
-                            fix(fixer) {
-                                return removeTypeAnnotation(fixer, left.typeAnnotation, sourceCode);
-                            },
-                        });
+                node.params.forEach((param) => {
+                    const typeAnnotation = annotationOf(param);
+                    if (typeAnnotation) {
+                        reportParam(param, typeAnnotation);
                     }
                 });
             },

package/lib/rules/no-type-assertion-returns.js

@@ -136,14 +136,25 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
         function isInsideJSXAttributeOrObjectProperty(node) {
             let current = node;
             while (current?.parent) {
-                // Direct JSX attribute
-                if (current.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute) {
+                // Direct JSX attribute, in either spelling. A named attribute
+                // (`title={x as T}`) and a spread (`{...(x as T)}`) feed the receiving
+                // component's props identically, so they earn the same carve-out: what
+                // the enclosing function returns is a JSXElement, never the asserted
+                // value, and the object is re-checked against the component's prop
+                // types at the JSX call site. This is the argument already accepted for
+                // call and new arguments above.
+                if (current.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute ||
+                    current.parent.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute) {
                     return true;
                 }
                 // Object property (which could be JSX props)
                 if (current.parent.type === utils_1.AST_NODE_TYPES.Property) {
                     return true;
                 }
+                // A SpreadElement is deliberately absent: `return { ...(x as T) }`
+                // splices the asserted value's own members into the returned value, so
+                // the cast is exactly the unvalidated data reaching callers that this
+                // rule exists to catch. Unlike a JSX spread, nothing re-checks it.
                 current = current.parent;
             }
             return false;

package/lib/utils/importRemoval.d.ts

@@ -34,6 +34,22 @@ export declare function removeImportBindingFixes(source: ImportRemovalSource, fi
  * its own rather than a specifier and is left alone.
  */
 export declare function importBindingSpecifierOf(variable: TSESLint.Scope.Variable): ImportBindingSpecifier | undefined;
+/** An import binding together with the ranges that reference it. */
+export type ImportBindingUse = {
+    specifier: ImportBindingSpecifier;
+    references: TextRange[];
+};
+/**
+ * Every import binding the file declares, paired with the positions that read
+ * it.
+ *
+ * A caller deleting several regions at once needs this to decide *which* of its
+ * own deletions a binding depends on before asking
+ * {@link planOrphanedImportRemoval} to unbind it: a binding read from two
+ * regions is unbound only if both go, and only a caller that deletes both in one
+ * fix may claim that.
+ */
+export declare function importBindingReferences(source: ImportRemovalSource): ImportBindingUse[];
 /**
  * The extra ranges a fix must delete so that removing `removed` leaves nothing
  * bound to nothing, or `null` when some binding would be orphaned yet cannot be
@@ -45,13 +61,20 @@ export declare function importBindingSpecifierOf(variable: TSESLint.Scope.Variab
  * file that lints clean into one that fails `no-unused-vars`, and since the
  * original report is resolved by the fix, nothing re-reports the debt.
  *
- * `removed` is one fix's own deletion, judged against the file as it stands.
- * Widening it to "everything this `--fix` run will delete" looks like it would
- * catch a binding two edits share, but it is unsound: a rule cannot see
- * `eslint-disable` comments, because suppression is applied to reports after the
- * rule emits them. A suppressed sibling edit never happens, so the widened view
- * deletes an import that a surviving reference still needs — trading an unused
- * import for a dangling type reference, a lint warning for a compile error.
- * There is deliberately no way to ask this helper that question.
+ * `removed` is **one fix's own deletion**, judged against the file as it stands.
+ * Several ranges may be passed only when a single fix deletes all of them, since
+ * ESLint applies a fix whole or not at all. Passing ranges that belong to other
+ * reports is unsound in two ways: a sibling report may be suppressed (ESLint
+ * applies `eslint-disable` after the rule emits its reports, so the sibling's fix
+ * never runs), and a sibling fix that overlaps another rule's fix is dropped for
+ * the pass. Either way the surviving reference outlives the import this helper
+ * was told to unbind — trading an unused import for a dangling type reference, a
+ * lint warning for a compile error.
+ *
+ * A caller batching several of its own edits therefore owes two things: the
+ * edits must ship as one fix, and the reports they came from must be checked
+ * with `createSuppressionChecker` so that a suppressed one is never counted on.
+ * {@link importBindingReferences} exposes the reference sets such a caller needs
+ * to work out which edits belong in the same batch.
  */
 export declare function planOrphanedImportRemoval(source: ImportRemovalSource, removed: readonly TextRange[]): TextRange[] | null;

package/lib/utils/importRemoval.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.planOrphanedImportRemoval = exports.importBindingSpecifierOf = exports.removeImportBindingFixes = exports.planImportBindingRemoval = void 0;
+exports.planOrphanedImportRemoval = exports.importBindingReferences = exports.importBindingSpecifierOf = exports.removeImportBindingFixes = exports.planImportBindingRemoval = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const disableDirectives_1 = require("./disableDirectives");
 function contains(outer, inner) {
@@ -221,6 +221,32 @@ function allVariables(scopeManager) {
     }
     return variables;
 }
+/**
+ * Every import binding the file declares, paired with the positions that read
+ * it.
+ *
+ * A caller deleting several regions at once needs this to decide *which* of its
+ * own deletions a binding depends on before asking
+ * {@link planOrphanedImportRemoval} to unbind it: a binding read from two
+ * regions is unbound only if both go, and only a caller that deletes both in one
+ * fix may claim that.
+ */
+function importBindingReferences(source) {
+    const uses = [];
+    for (const variable of allVariables(source.scopeManager)) {
+        if (!isImportBindingVariable(variable))
+            continue;
+        const specifier = importBindingSpecifierOf(variable);
+        if (!specifier)
+            continue;
+        uses.push({
+            specifier,
+            references: variable.references.map((reference) => reference.identifier.range),
+        });
+    }
+    return uses;
+}
+exports.importBindingReferences = importBindingReferences;
 function isAstNode(value) {
     return (typeof value === 'object' &&
         value !== null &&
@@ -329,14 +355,21 @@ function exportedBindingKeys(ast) {
  * file that lints clean into one that fails `no-unused-vars`, and since the
  * original report is resolved by the fix, nothing re-reports the debt.
  *
- * `removed` is one fix's own deletion, judged against the file as it stands.
- * Widening it to "everything this `--fix` run will delete" looks like it would
- * catch a binding two edits share, but it is unsound: a rule cannot see
- * `eslint-disable` comments, because suppression is applied to reports after the
- * rule emits them. A suppressed sibling edit never happens, so the widened view
- * deletes an import that a surviving reference still needs — trading an unused
- * import for a dangling type reference, a lint warning for a compile error.
- * There is deliberately no way to ask this helper that question.
+ * `removed` is **one fix's own deletion**, judged against the file as it stands.
+ * Several ranges may be passed only when a single fix deletes all of them, since
+ * ESLint applies a fix whole or not at all. Passing ranges that belong to other
+ * reports is unsound in two ways: a sibling report may be suppressed (ESLint
+ * applies `eslint-disable` after the rule emits its reports, so the sibling's fix
+ * never runs), and a sibling fix that overlaps another rule's fix is dropped for
+ * the pass. Either way the surviving reference outlives the import this helper
+ * was told to unbind — trading an unused import for a dangling type reference, a
+ * lint warning for a compile error.
+ *
+ * A caller batching several of its own edits therefore owes two things: the
+ * edits must ship as one fix, and the reports they came from must be checked
+ * with `createSuppressionChecker` so that a suppressed one is never counted on.
+ * {@link importBindingReferences} exposes the reference sets such a caller needs
+ * to work out which edits belong in the same batch.
  */
 function planOrphanedImportRemoval(source, removed) {
     const orphaned = [];

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,42 @@
 [
+  {
+    "version": "1.20.89",
+    "date": "2026-08-03T12:31:01.823Z",
+    "rules": [
+      {
+        "name": "memo-compare-deeply-complex-props",
+        "changeType": "fix",
+        "issues": [
+          1656
+        ],
+        "summary": "treat a primitive-backed intersection as primitive, not complex (closes #1656)"
+      },
+      {
+        "name": "no-explicit-return-type",
+        "changeType": "fix",
+        "issues": [
+          1654
+        ],
+        "summary": "unbind an import when the annotations jointly keeping it alive are all stripped (closes #1654)"
+      },
+      {
+        "name": "no-redundant-param-types",
+        "changeType": "fix",
+        "issues": [
+          1653
+        ],
+        "summary": "remove the type imports a stripped parameter annotation was the sole consumer of (closes #1653)"
+      },
+      {
+        "name": "no-type-assertion-returns",
+        "changeType": "fix",
+        "issues": [
+          1655
+        ],
+        "summary": "exempt type assertions in JSX spread attributes (closes #1655)"
+      }
+    ]
+  },
   {
     "version": "1.20.88",
     "date": "2026-08-03T09:05:50.265Z",