@blumintinc/eslint-plugin-blumint 1.20.85 → 1.20.87

package/lib/index.js

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

package/lib/rules/enforce-assert-safe-object-key.js

@@ -10,6 +10,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
+const importInsertion_1 = require("../utils/importInsertion");
 const DEFAULT_IMPORT_PATH = 'functions/src/util/assertSafe';
 const ASSERT_SAFE_NAME = 'assertSafe';
 /**
@@ -327,18 +328,15 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                     isAssertSafeModule(declaration.source.value));
             });
         /**
-         * Helper function to add assertSafe import if needed
+         * Emits the `import { assertSafe }` statement the wrapped call needs. The
+         * position comes from the shared anchor so the file's prologue keeps its
+         * meaning: a `'use client'` directive stops being a directive the moment a
+         * statement precedes it, and a `#!` shebang stops parsing once it leaves
+         * character 0.
          */
         const addAssertSafeImport = (fixer) => {
-            const program = context.sourceCode.ast;
-            const firstImport = program.body.find((node) => node.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
             const importStatement = `import { assertSafe } from '${computeImportSpecifier()}';\n`;
-            if (firstImport) {
-                return fixer.insertTextBefore(firstImport, importStatement);
-            }
-            else {
-                return fixer.insertTextBefore(program.body[0], importStatement);
-            }
+            return (0, importInsertion_1.insertAtImportAnchor)(context.sourceCode, fixer, (0, importInsertion_1.importInsertionAnchor)(context.sourceCode), importStatement);
         };
         /**
          * Helper function to create fixes for a node

package/lib/rules/enforce-memoize-async.js

@@ -5,6 +5,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
+const importInsertion_1 = require("../utils/importInsertion");
 const MEMOIZE_MODULE = '@blumintinc/typescript-memoize';
 const ALLOWED_MEMOIZE_MODULES = new Set([MEMOIZE_MODULE, 'typescript-memoize']);
 const MEMOIZE_NAME = 'Memoize';
@@ -342,22 +343,13 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                         if (!hasMemoizeImport &&
                             memoizeNamespaces.size === 0 &&
                             !scheduledImportFix) {
-                            const programBody = sourceCode.ast.body;
-                            const firstImport = programBody.find((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-                            const anchorNode = (firstImport ?? programBody[0]);
-                            if (anchorNode) {
-                                const text = sourceCode.text;
-                                const anchorStart = anchorNode.range[0];
-                                const lineStart = text.lastIndexOf('\n', anchorStart - 1) + 1;
-                                const leadingWhitespace = text.slice(lineStart, anchorStart).match(/^[ \t]*/)?.[0] ??
-                                    '';
-                                const importLine = `${leadingWhitespace}${importStatement}\n`;
-                                fixes.push(fixer.insertTextBeforeRange([lineStart, lineStart], importLine));
-                            }
-                            else {
-                                // Fallback: empty file
-                                fixes.push(fixer.insertTextBeforeRange([0, 0], `import { Memoize } from '${MEMOIZE_MODULE}';\n`));
-                            }
+                            // The shared anchor keeps the import below whatever governs the
+                            // top of the file — a `'use client'` directive that must stay the
+                            // first statement, a `#!` shebang that must stay at character 0,
+                            // a header comment — while still placing it above the first
+                            // existing import.
+                            const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
+                            fixes.push((0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importAnchorLineStart)(sourceCode, anchor), `${(0, importInsertion_1.importAnchorIndent)(sourceCode, anchor)}${importStatement}\n`));
                             scheduledImportFix = true;
                         }
                         // Add decorator for this method

package/lib/rules/enforce-memoize-getters.js

@@ -6,6 +6,7 @@ const visitor_keys_1 = require("@typescript-eslint/visitor-keys");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
+const importInsertion_1 = require("../utils/importInsertion");
 const MEMOIZE_PREFERRED_MODULE = '@blumintinc/typescript-memoize';
 const MEMOIZE_MODULES = new Set([
     MEMOIZE_PREFERRED_MODULE,
@@ -473,23 +474,18 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                                 return null;
                             }
                         }
-                        // Insert import if needed, at the top alongside other imports
+                        // Insert import if needed, at the top alongside other imports.
+                        // The shared anchor keeps the edit below the file's prologue: a
+                        // `'use client'` directive demoted to a plain expression statement
+                        // and a shebang displaced off character 0 both change what the file
+                        // means, and neither is recoverable from the emitted decorator.
                         if (!hasMemoizeImport && !scheduledImportFix) {
-                            const programBody = sourceCode.ast.body;
-                            const firstImport = programBody.find((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-                            const anchorNode = (firstImport ?? programBody[0]);
-                            if (anchorNode) {
-                                const text = sourceCode.text;
-                                const anchorStart = anchorNode.range[0];
-                                const lineStart = text.lastIndexOf('\n', anchorStart - 1) + 1;
-                                const leadingWhitespace = text.slice(lineStart, anchorStart).match(/^[ \t]*/)?.[0] ??
-                                    '';
-                                const importLine = `${leadingWhitespace}import { Memoize } from '${MEMOIZE_PREFERRED_MODULE}';\n`;
-                                fixes.push(fixer.insertTextBeforeRange([lineStart, lineStart], importLine));
-                            }
-                            else {
-                                fixes.push(fixer.insertTextBeforeRange([0, 0], `import { Memoize } from '${MEMOIZE_PREFERRED_MODULE}';\n`));
-                            }
+                            const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
+                            // Indent comes from the anchor's own line, so the import lines up
+                            // with the statement it displaces; widening to the line start
+                            // then leaves that statement's indentation intact.
+                            const indent = (0, importInsertion_1.importAnchorIndent)(sourceCode, anchor);
+                            fixes.push((0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, (0, importInsertion_1.importAnchorLineStart)(sourceCode, anchor), `${indent}import { Memoize } from '${MEMOIZE_PREFERRED_MODULE}';\n`));
                             scheduledImportFix = true;
                         }
                         // Insert decorator above the getter (or before the first decorator), preserving indentation

package/lib/rules/enforce-microdiff.js

@@ -4,6 +4,7 @@ exports.enforceMicrodiff = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const importInsertion_1 = require("../utils/importInsertion");
 const DIFF_NAME = 'diff';
 /**
  * The package the fix imports from. BluMint's fork is the dependency this
@@ -334,12 +335,24 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
          * the reported node, because the reported node is rarely at module scope: a
          * comparison inside a function body, or a function behind an `export`,
          * would otherwise take the import somewhere the grammar forbids it.
+         *
+         * The shared anchor decides where the prologue ends. Splicing at character
+         * 0 put the import above a `'use client'` directive, which demotes it to an
+         * ordinary expression statement, and above a `#!` shebang, which has to sit
+         * at character 0 for the file to parse at all.
          */
         function buildMicrodiffImportFix(fixer) {
             if (findMicrodiffImport(sourceCode.ast)) {
                 return null;
             }
-            return fixer.insertTextBeforeRange([0, 0], `${MICRODIFF_IMPORT}\n\n`);
+            const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
+            // A blank line separates the import from the code below it, but not from
+            // another import: an import block split in two reads as two groups.
+            const separator = anchor.kind === 'before' &&
+                anchor.target.type === utils_1.AST_NODE_TYPES.ImportDeclaration
+                ? '\n'
+                : '\n\n';
+            return (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, anchor, `${MICRODIFF_IMPORT}${separator}`);
         }
         // Add a specific set to track which import names are used
         const usedImportNames = new Set();

package/lib/rules/enforce-querykey-ts.js

@@ -8,6 +8,7 @@ const path_1 = __importDefault(require("path"));
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const disableDirectives_1 = require("../utils/disableDirectives");
+const importInsertion_1 = require("../utils/importInsertion");
 // The module's path below the project root doubles as the bare specifier,
 // which is precisely why the root tsconfig `paths` and the Jest mapper resolve
 // it.
@@ -245,14 +246,29 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                 return null;
             }
             const importText = `import { ${constants.join(', ')} } from '${source}';\n`;
-            const [firstImport] = importDeclarations;
-            if (firstImport) {
-                return fixer.insertTextBefore(firstImport, importText);
+            const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
+            if (importDeclarations.length) {
+                // The statement joins an import block, and the anchor is that block's
+                // first declaration (or a suppression comment bound to it), so it lands
+                // among its siblings with nothing above them displaced.
+                return (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, anchor, importText);
             }
-            // Keep the import visually separated from the code it precedes unless the
-            // file already opens with a blank line.
-            const separator = /^\r?\n/.test(sourceCode.text) ? '' : '\n';
-            return fixer.insertTextBeforeRange([0, 0], `${importText}${separator}`);
+            // A file's first import opens the file, so it may cross the blank lines
+            // the source starts with. The anchor is the floor of that climb: a
+            // `'use client'` directive stops being a directive, a `#!` shebang stops
+            // parsing, and a header comment stops covering its subject the moment a
+            // statement precedes them, so only whitespace may be crossed.
+            const anchorIndex = anchor.kind === 'before' ? anchor.target.range[0] : anchor.index;
+            const opensFile = sourceCode.text.slice(0, anchorIndex).trim() === '';
+            const insertion = opensFile
+                ? { kind: 'index', index: 0 }
+                : anchor;
+            // Keep the import visually separated from the code it precedes unless a
+            // blank line already sits at the insertion point.
+            const separator = /^\r?\n/.test(sourceCode.text.slice(opensFile ? 0 : anchorIndex))
+                ? ''
+                : '\n';
+            return (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, insertion, `${importText}${separator}`);
         }
         function flushReports() {
             const resolutions = new Map();

package/lib/rules/enforce-safe-stringify.js

@@ -4,6 +4,7 @@ exports.enforceStableStringify = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const importInsertion_1 = require("../utils/importInsertion");
 const STRINGIFY_MODULE = 'safe-stable-stringify';
 const STRINGIFY_NAME = 'stringify';
 /**
@@ -102,9 +103,12 @@ exports.enforceStableStringify = (0, createRule_1.createRule)({
                                     // application self-contained (the re-lint suppresses a
                                     // duplicate for later call sites).
                                     if (!importsStringify(program)) {
-                                        const firstImport = program.body.find((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-                                        const importStatement = "import stringify from 'safe-stable-stringify';\n";
-                                        fixes.push(fixer.insertTextBefore(firstImport ?? program.body[0], importStatement));
+                                        // Anchor through the shared helper so the import lands
+                                        // below the file's prologue: splicing it above a
+                                        // `'use client'` directive demotes the directive to a plain
+                                        // expression, and above a `#!` shebang leaves the file
+                                        // unparseable.
+                                        fixes.push((0, importInsertion_1.insertAtImportAnchor)(context.sourceCode, fixer, (0, importInsertion_1.importInsertionAnchor)(context.sourceCode), "import stringify from 'safe-stable-stringify';\n"));
                                     }
                                     fixes.push(fixer.replaceText(node, STRINGIFY_NAME));
                                     return fixes;

package/lib/rules/enforce-snapshot-state-narrowing.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceSnapshotStateNarrowing = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const importInsertion_1 = require("../utils/importInsertion");
 const DEFAULT_SNAPSHOT_HOOKS = [
     'useDocSnapshot',
     'useCollectionSnapshot',
@@ -216,6 +217,7 @@ exports.enforceSnapshotStateNarrowing = (0, createRule_1.createRule)({
          * otherwise add the canonical import statement.
          */
         function buildImportFix(fixer) {
+            const sourceCode = context.getSourceCode();
             const declarations = importDeclarationsOf();
             const guardDeclarations = declarations.filter((declaration) => isGuardModule(String(declaration.source.value)));
             const reusable = guardDeclarations.find((declaration) => declaration.importKind !== 'type' &&
@@ -231,14 +233,29 @@ exports.enforceSnapshotStateNarrowing = (0, createRule_1.createRule)({
                 ? String(guardDeclarations[0].source.value)
                 : guardImportSource;
             const importText = `import { ${guardName} } from '${source}';\n`;
-            const [firstImport] = declarations;
-            if (firstImport) {
-                return fixer.insertTextBefore(firstImport, importText);
+            const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
+            if (declarations.length) {
+                // The statement joins an import block, and the anchor is that block's
+                // first declaration (or a suppression comment bound to it), so it lands
+                // among its siblings with nothing above them displaced.
+                return (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, anchor, importText);
             }
-            // Keep the import visually separated from the code it precedes unless the
-            // file already opens with a blank line.
-            const separator = /^\r?\n/.test(context.getSourceCode().text) ? '' : '\n';
-            return fixer.insertTextBeforeRange([0, 0], `${importText}${separator}`);
+            // A file's first import opens the file, so it may cross the blank lines
+            // the source starts with. The anchor is the floor of that climb: a
+            // `'use client'` directive stops being a directive, a `#!` shebang stops
+            // parsing, and a header comment stops covering its subject the moment a
+            // statement precedes them, so only whitespace may be crossed.
+            const anchorIndex = anchor.kind === 'before' ? anchor.target.range[0] : anchor.index;
+            const opensFile = sourceCode.text.slice(0, anchorIndex).trim() === '';
+            const insertion = opensFile
+                ? { kind: 'index', index: 0 }
+                : anchor;
+            // Keep the import visually separated from the code it precedes unless a
+            // blank line already sits at the insertion point.
+            const separator = /^\r?\n/.test(sourceCode.text.slice(opensFile ? 0 : anchorIndex))
+                ? ''
+                : '\n';
+            return (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, insertion, `${importText}${separator}`);
         }
         /**
          * Builds the single suggestion shared by every report: swap the flagged

package/lib/rules/enforce-stable-hash-spread-props.js

@@ -5,6 +5,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
 const disableDirectives_1 = require("../utils/disableDirectives");
+const importInsertion_1 = require("../utils/importInsertion");
 const DEFAULT_HASH_IMPORT = {
     source: 'functions/src/util/hash/stableHash',
     importName: 'stableHash',
@@ -366,13 +367,23 @@ exports.enforceStableHashSpreadProps = (0, createRule_1.createRule)({
                         if (!isStableHashImported(sourceCode, hashImport) &&
                             !importPlanned) {
                             const importText = `import { ${hashImport.importName} } from '${hashImport.source}';\n`;
-                            const program = sourceCode.ast;
-                            const firstImport = program.body.find((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+                            const firstImport = sourceCode.ast.body.find((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
                             if (firstImport) {
                                 fixes.push(fixer.insertTextBefore(firstImport, importText));
                             }
                             else {
-                                fixes.push(fixer.insertTextBeforeRange([0, 0], importText));
+                                // A file's first import may cross only the whitespace the
+                                // source opens with. The shared anchor is the floor of that
+                                // climb: text spliced above a `#!` shebang leaves the file
+                                // unparseable, and text above a `'use client'` directive or a
+                                // header comment strips the prologue of the meaning it
+                                // carries only while it leads.
+                                const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
+                                const anchorIndex = anchor.kind === 'before'
+                                    ? anchor.target.range[0]
+                                    : anchor.index;
+                                const opensFile = sourceCode.text.slice(0, anchorIndex).trim() === '';
+                                fixes.push((0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, opensFile ? { kind: 'index', index: 0 } : anchor, importText));
                             }
                             importPlanned = true;
                         }

package/lib/rules/logical-top-to-bottom-grouping.js

@@ -1430,6 +1430,63 @@ function applyMove(body, fromIndex, toIndex) {
     next.splice(toIndex < fromIndex ? toIndex : toIndex - 1, 0, moved);
     return next;
 }
+/**
+ * A statement whose own value comes straight from an `await`, matching how
+ * `parallelize-async-operations` recognizes the members of a sequential-await run:
+ * an expression statement that *is* an await, or a declaration whose initializer *is*
+ * an await. An await buried deeper (`const x = (await f()).y`) is deliberately not
+ * counted — that rule does not group it either, so protecting it would cost autofixes
+ * for no gain.
+ */
+function isAwaitBearingStatement(statement) {
+    if (statement.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+        return statement.expression.type === utils_1.AST_NODE_TYPES.AwaitExpression;
+    }
+    if (statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+        return statement.declarations.some((declaration) => declaration.init?.type === utils_1.AST_NODE_TYPES.AwaitExpression);
+    }
+    return false;
+}
+/**
+ * Maximal stretches of two or more adjacent await-bearing statements.
+ *
+ * Adjacency is the entire input to `parallelize-async-operations`: a single unrelated
+ * statement dropped between two sequential awaits ends the run and silences that rule
+ * outright. A run of one is not protected because no such rule exists for it.
+ */
+function collectAwaitRuns(body) {
+    const runs = [];
+    let run = [];
+    for (const statement of body) {
+        if (isAwaitBearingStatement(statement)) {
+            run.push(statement);
+            continue;
+        }
+        if (run.length >= 2) {
+            runs.push(run);
+        }
+        run = [];
+    }
+    if (run.length >= 2) {
+        runs.push(run);
+    }
+    return runs;
+}
+/**
+ * Whether a candidate ordering leaves every await run contiguous and internally
+ * ordered as it was.
+ *
+ * Relative order matters as much as contiguity: `parallelize-async-operations` anchors
+ * its report and its `Promise.all` rewrite on the run's first await, so permuting the
+ * run relocates the transform even when the awaits stay adjacent.
+ */
+function preservesAwaitRuns(order, runs) {
+    return runs.every((run) => {
+        const start = order.indexOf(run[0]);
+        return (start !== -1 &&
+            run.every((statement, offset) => order[start + offset] === statement));
+    });
+}
 /**
  * Upper bound on candidate moves expanded per search node. Each candidate costs one
  * full detection pass, so a node offering more violations than this has its tail
@@ -1486,11 +1543,18 @@ function orderKey(order, indices) {
  * can still be the only route to a clean order, so the frontier is bounded by move
  * count and detection budget rather than by any notion of progress. Only the
  * zero-violation goal test decides whether a fix is emitted at all.
+ *
+ * The one hard constraint on the search is the block's await runs. Splitting a run of
+ * sequential awaits destroys `parallelize-async-operations`' `Promise.all` rewrite,
+ * and that rewrite carries a latency win this reordering does not — so orders that
+ * break a run are not candidates at all, however clean they score. A block whose only
+ * clean orders break a run is reported without a fix (#1651).
  */
 function findResolvingMoves(sourceCode, body, violations, maxMoves) {
     if (maxMoves === 0) {
         return null;
     }
+    const awaitRuns = collectAwaitRuns(body);
     const indices = new Map(body.map((statement, index) => [statement, index]));
     const seen = new Set([orderKey(body, indices)]);
     const queue = [{ order: body, violations, moves: [] }];
@@ -1507,6 +1571,12 @@ function findResolvingMoves(sourceCode, body, violations, maxMoves) {
             }
             const { fromIndex, toIndex } = node.violations[candidate];
             const order = applyMove(node.order, fromIndex, toIndex);
+            // Checked before the budget is charged: the test is a couple of array lookups,
+            // and dropping the order here prunes the frontier as well as the goal, so no
+            // route to a clean order passes through a broken run.
+            if (!preservesAwaitRuns(order, awaitRuns)) {
+                continue;
+            }
             const key = orderKey(order, indices);
             if (seen.has(key)) {
                 continue;

package/lib/rules/no-array-length-in-deps.js

@@ -5,6 +5,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
+const importInsertion_1 = require("../utils/importInsertion");
 // React hooks to check
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
 const REACT_MODULE = 'react';
@@ -561,7 +562,18 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                                     fixes.push(fixer.insertTextBefore(firstImport, importText));
                                 }
                                 else {
-                                    fixes.push(fixer.insertTextBeforeRange([0, 0], importText));
+                                    // A file's first import may cross only the whitespace the
+                                    // source opens with. The shared anchor is the floor of that
+                                    // climb: text spliced above a `#!` shebang leaves the file
+                                    // unparseable, and text above a `'use client'` directive or
+                                    // a header comment strips the prologue of the meaning it
+                                    // carries only while it leads.
+                                    const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
+                                    const anchorIndex = anchor.kind === 'before'
+                                        ? anchor.target.range[0]
+                                        : anchor.index;
+                                    const opensFile = sourceCode.text.slice(0, anchorIndex).trim() === '';
+                                    fixes.push((0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, opensFile ? { kind: 'index', index: 0 } : anchor, importText));
                                 }
                             }
                             importsPlanned = true;

package/lib/rules/no-empty-dependency-use-callbacks.js

@@ -5,6 +5,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const minimatch_1 = require("minimatch");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
+const importRemoval_1 = require("../utils/importRemoval");
 const DEFAULT_TEST_PATTERNS = ['**/__tests__/**', '**/*.test.*', '**/*.spec.*'];
 const PREFER_UTILITY_FUNCTION_MESSAGE = [
     'What\'s wrong: "{{name}}" uses useCallback([]) but never reads component/hook state',
@@ -463,6 +464,34 @@ function dedentedCallbackText(sourceCode, callback, hoistTarget) {
     })
         .join('\n');
 }
+/**
+ * The imports the hoist leaves bound to nothing, or `null` when none can be
+ * unbound safely.
+ *
+ * The hoist is not a deletion: the declared identifier and the callback text
+ * are re-emitted at module scope, so every reference inside them outlives the
+ * fix. Only the wrapper disappears — the `const` keyword, the ` = hook(`
+ * between the identifier and the callback, and the trailing `, []);`. Orphan-
+ * hood is judged against those three slices alone, which keeps a hook call
+ * nested in the callback body counted as a live reference (unwrapping the
+ * outer call carries the inner one along verbatim).
+ *
+ * A member callee (`React.useCallback`) is left alone. Its object is usually
+ * the JSX pragma, and under the classic runtime JSX consumes that binding
+ * through a transform no scope analysis records — a use this cannot see, so it
+ * must not delete it.
+ */
+function planHoistImportRemoval(sourceCode, callExpression, declarator, callback, idRangeEnd, removal) {
+    if (callExpression.callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return null;
+    }
+    const deleted = [
+        [removal[0], declarator.id.range[0]],
+        [idRangeEnd, callback.range[0]],
+        [callback.range[1], removal[1]],
+    ];
+    return (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, deleted);
+}
 function buildHoistFixes(context, callExpression, callback, hoistedIdentifierCache) {
     if (!callExpression.parent ||
         callExpression.parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
@@ -536,9 +565,16 @@ function buildHoistFixes(context, callExpression, callback, hoistedIdentifierCac
     if (hasOnlyIndentBefore && hasOnlyWhitespaceAfter && lineEnd !== -1) {
         removeEnd = lineEnd + 1;
     }
+    // The hook import the call was the last consumer of goes with the hoist, in
+    // the same fix: applying the hoist alone trades this rule's report for an
+    // unused-import one, and nothing re-reports that debt once the hoist has
+    // resolved the original violation. An unremovable binding costs only the
+    // unused import — the hoist is the fix's value and is kept regardless.
+    const importRanges = planHoistImportRemoval(sourceCode, callExpression, declarator, callback, idRangeEnd, [removeStart, removeEnd]) ?? [];
     return (fixer) => [
         fixer.insertTextBefore(hoistTarget, hoisted),
         fixer.removeRange([removeStart, removeEnd]),
+        ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
     ];
 }
 exports.noEmptyDependencyUseCallbacks = (0, createRule_1.createRule)({