@blumintinc/eslint-plugin-blumint 1.20.23 → 1.20.24

package/lib/index.js

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

package/lib/rules/use-latest-callback.js

@@ -197,10 +197,21 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                     return;
                 }
                 const specifiers = useCallbackSpecifiersOf(statement);
+                // A conversion nested inside another conversion cannot join the atomic
+                // batch: the outer replacement re-emits the inner call's original text,
+                // so fixing both at once would produce overlapping edits. The inner
+                // call is reported without a fix; because its callee then counts as a
+                // surviving reference, the react import is preserved and a later pass
+                // converts it against the rewritten text.
+                const isNestedConversion = (candidate) => conversions.some((other) => other.node !== candidate.node &&
+                    other.node.range[0] <= candidate.node.range[0] &&
+                    candidate.node.range[1] <= other.node.range[1]);
+                const batchedConversions = conversions.filter((conversion) => !isNestedConversion(conversion));
+                const deferredConversions = conversions.filter(isNestedConversion);
                 // A reference the fix does not rewrite (a JSX-returning call, an
                 // argument-less call, or `useCallback` used as a value) keeps needing
                 // react's binding, so the import must be preserved verbatim.
-                const convertedCallees = new Set(conversions
+                const convertedCallees = new Set(batchedConversions
                     .map((conversion) => conversion.callee)
                     .filter((callee) => !!callee));
                 const hasSurvivingReference = context
@@ -231,7 +242,84 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                         : useCallbackLocalName === 'useCallback'
                             ? 'useLatestCallback'
                             : useCallbackLocalName;
-                for (const conversion of conversions) {
+                const importText = `import ${recommendedHook} from 'use-latest-callback';`;
+                // The react import statement participates in the change set only when
+                // it binds useCallback or anchors a React.useCallback member call.
+                const touchesImport = specifiers.length > 0 || hasReactMemberUseCallback;
+                const importFixes = (fixer) => {
+                    if (!touchesImport) {
+                        return [];
+                    }
+                    // A surviving reference (or a member-only file) leaves the react
+                    // import untouched; only the new import is added when missing.
+                    if (hasSurvivingReference || specifiers.length === 0) {
+                        if (hasUseLatestCallbackImport) {
+                            return [];
+                        }
+                        return [fixer.insertTextBefore(statement, `${importText}\n`)];
+                    }
+                    const defaultOrNamespace = statement.specifiers.find((s) => s.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                        s.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
+                    const remainingNamed = statement.specifiers.filter((s) => s.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        s.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        s.imported.name !== 'useCallback');
+                    const prefix = statement.importKind && statement.importKind !== 'value'
+                        ? 'import type'
+                        : 'import';
+                    if (remainingNamed.length === 0 && !defaultOrNamespace) {
+                        if (!hasUseLatestCallbackImport) {
+                            return [fixer.replaceText(statement, importText)];
+                        }
+                        return [fixer.remove(statement)];
+                    }
+                    const parts = [];
+                    if (defaultOrNamespace) {
+                        parts.push(sourceCode.getText(defaultOrNamespace));
+                    }
+                    if (remainingNamed.length > 0) {
+                        parts.push(`{ ${remainingNamed
+                            .map((s) => sourceCode.getText(s))
+                            .join(', ')} }`);
+                    }
+                    const replacement = `${prefix} ${parts.join(', ')} from 'react';`;
+                    const fixes = [];
+                    if (!hasUseLatestCallbackImport) {
+                        fixes.push(fixer.insertTextBefore(statement, `${importText}\n`));
+                    }
+                    fixes.push(fixer.replaceText(statement, replacement));
+                    return fixes;
+                };
+                const conversionFix = (fixer, conversion) => {
+                    const callbackText = sourceCode.getText(conversion.node.arguments[0]);
+                    const typeParams = conversion.node.typeParameters
+                        ? sourceCode.getText(conversion.node.typeParameters)
+                        : '';
+                    // Replace useCallback with useLatestCallback and remove the dependency array
+                    return fixer.replaceText(conversion.node, `${recommendedHook}${typeParams}(${callbackText})`);
+                };
+                // Every call-site conversion and the import rewrite ride on ONE fix
+                // from ONE report. ESLint discards a multi-part fix wholesale when any
+                // part conflicts with another rule's fix and retries it on the next
+                // pass against the updated text, whereas fixes split across reports
+                // land piecemeal: the disjoint import rewrite would apply even when
+                // the call-site conversion is deferred, permanently stranding a
+                // `useCallback(...)` call with no import (issue #1400).
+                const [fixOwner, ...followers] = batchedConversions;
+                context.report({
+                    node: fixOwner.node,
+                    messageId: 'useLatestCallback',
+                    data: {
+                        currentHook: fixOwner.currentHook,
+                        recommendedHook,
+                    },
+                    fix(fixer) {
+                        return [
+                            ...batchedConversions.map((conversion) => conversionFix(fixer, conversion)),
+                            ...importFixes(fixer),
+                        ];
+                    },
+                });
+                for (const conversion of [...followers, ...deferredConversions]) {
                     context.report({
                         node: conversion.node,
                         messageId: 'useLatestCallback',
@@ -239,34 +327,13 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                             currentHook: conversion.currentHook,
                             recommendedHook,
                         },
-                        fix(fixer) {
-                            const callbackText = sourceCode.getText(conversion.node.arguments[0]);
-                            const typeParams = conversion.node.typeParameters
-                                ? sourceCode.getText(conversion.node.typeParameters)
-                                : '';
-                            // Replace useCallback with useLatestCallback and remove the dependency array
-                            return fixer.replaceText(conversion.node, `${recommendedHook}${typeParams}(${callbackText})`);
-                        },
                     });
                 }
-                if (specifiers.length === 0 && !hasReactMemberUseCallback) {
+                if (!touchesImport) {
                     return;
                 }
-                const importText = `import ${recommendedHook} from 'use-latest-callback';`;
-                if (hasSurvivingReference) {
-                    if (hasUseLatestCallbackImport) {
-                        return; // The react import stays as is and the new import exists
-                    }
-                    context.report({
-                        node: statement,
-                        messageId: 'useLatestCallback',
-                        data: {
-                            currentHook: useCallbackLocalName,
-                            recommendedHook,
-                        },
-                        fix: (fixer) => fixer.insertTextBefore(statement, `${importText}\n`),
-                    });
-                    return;
+                if (hasSurvivingReference && hasUseLatestCallbackImport) {
+                    return; // The react import stays as is and the new import exists
                 }
                 context.report({
                     node: statement,
@@ -275,43 +342,6 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                         currentHook: useCallbackLocalName,
                         recommendedHook,
                     },
-                    fix(fixer) {
-                        if (specifiers.length === 0) {
-                            if (hasUseLatestCallbackImport)
-                                return null;
-                            return fixer.insertTextBefore(statement, `${importText}\n`);
-                        }
-                        const defaultOrNamespace = statement.specifiers.find((s) => s.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
-                            s.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
-                        const remainingNamed = statement.specifiers.filter((s) => s.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                            s.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            s.imported.name !== 'useCallback');
-                        const prefix = statement.importKind && statement.importKind !== 'value'
-                            ? 'import type'
-                            : 'import';
-                        if (remainingNamed.length === 0 && !defaultOrNamespace) {
-                            if (!hasUseLatestCallbackImport) {
-                                return fixer.replaceText(statement, importText);
-                            }
-                            return fixer.remove(statement);
-                        }
-                        const parts = [];
-                        if (defaultOrNamespace) {
-                            parts.push(sourceCode.getText(defaultOrNamespace));
-                        }
-                        if (remainingNamed.length > 0) {
-                            parts.push(`{ ${remainingNamed
-                                .map((s) => sourceCode.getText(s))
-                                .join(', ')} }`);
-                        }
-                        const replacement = `${prefix} ${parts.join(', ')} from 'react';`;
-                        const fixes = [];
-                        if (!hasUseLatestCallbackImport) {
-                            fixes.push(fixer.insertTextBefore(statement, `${importText}\n`));
-                        }
-                        fixes.push(fixer.replaceText(statement, replacement));
-                        return fixes;
-                    },
                 });
             },
         };

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.24",
+    "date": "2026-07-30T02:00:54.523Z",
+    "rules": [
+      {
+        "name": "use-latest-callback",
+        "changeType": "fix",
+        "issues": [
+          1400
+        ],
+        "summary": "apply the import rewrite and call conversions atomically (closes #1400)"
+      }
+    ]
+  },
   {
     "version": "1.20.23",
     "date": "2026-07-30T01:37:58.854Z",