@blumintinc/eslint-plugin-blumint 1.20.23 → 1.20.25

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.25',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/no-entire-object-hook-deps.js

@@ -55,6 +55,21 @@ function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
         return false;
     }
 }
+function renderPathSegments(baseName, segments) {
+    let path = baseName;
+    for (const segment of segments) {
+        if (segment.computed) {
+            // why: an optional computed access must render as `?.[` — a bare `?`
+            // before `[` parses as a conditional expression, so `state?[0]` is a
+            // syntax error while `state?.[0]` is the valid optional element access.
+            path += segment.optional ? `?.${segment.text}` : segment.text;
+        }
+        else {
+            path += segment.optional ? `?.${segment.text}` : `.${segment.text}`;
+        }
+    }
+    return path;
+}
 function unwrapExpression(expr) {
     let current = expr;
     while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
@@ -67,6 +82,10 @@ function unwrapExpression(expr) {
 }
 function getObjectUsagesInHook(hookBody, objectName) {
     const usages = new Map(); // Track usage and its position
+    // why: derived dependency paths (first-optional intermediate, array base)
+    // must be re-rendered from structured links — string surgery on the
+    // rendered path cannot place `?.` markers correctly.
+    const pathSegments = new Map();
     const visited = new Set();
     let needsEntireObject = false;
     let isUsed = false;
@@ -123,23 +142,33 @@ function getObjectUsagesInHook(hookBody, objectName) {
         'includes',
     ]);
     function buildAccessPath(node) {
-        const parts = [];
+        // why: optionality belongs to individual links, not the whole chain.
+        // Rendering from per-link segments keeps `?.` markers at their real
+        // position (a.b?.[0] stays a.b?.[0], not a?.b[0]) and forms the mandatory
+        // `?.[` for optional computed access (state?.[0], never state?[0]).
+        const segments = [];
         let current = node;
-        let hasOptionalChaining = false;
-        // Collect all parts from leaf to root
+        // Collect all links from leaf to root
         while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
             const memberExpr = current;
             // Handle computed properties (like array indices)
             if (memberExpr.computed) {
-                // why: only a *literal* computed key (obj[0], obj['special-key'])
-                // narrows to a single, stable field. EVERY other computed key —
-                // Identifier (obj[i]), CallExpression (obj[assertSafe(i)]),
-                // BinaryExpression (obj[i+1]), MemberExpression (obj[keys[j]]),
-                // TSAsExpression (obj[k as K]), TemplateLiteral (obj[`row-${i}`]), etc.
-                // — is a dynamic access that can read arbitrary elements across an
-                // iteration. There is no single narrowable field, so the whole object
-                // is a legitimate dependency: resolve the base and mark it accordingly.
-                if (memberExpr.property.type !== utils_1.AST_NODE_TYPES.Literal) {
+                // why: only a *literal* string/number computed key (obj[0],
+                // obj['special-key']) narrows to a single, stable field. EVERY other
+                // computed key — Identifier (obj[i]), CallExpression
+                // (obj[assertSafe(i)]), BinaryExpression (obj[i+1]), MemberExpression
+                // (obj[keys[j]]), TSAsExpression (obj[k as K]), TemplateLiteral
+                // (obj[`row-${i}`]), etc. — is a dynamic access that can read
+                // arbitrary elements across an iteration. Remaining literal kinds
+                // (boolean/null/regex/bigint keys) have no rendering the fixer can
+                // guarantee round-trips, so they decline narrowing too rather than
+                // emit unreliable text. In every declined case the whole object is a
+                // legitimate dependency: resolve the base and mark it accordingly.
+                const literalValue = memberExpr.property.type === utils_1.AST_NODE_TYPES.Literal
+                    ? memberExpr.property.value
+                    : undefined;
+                if (typeof literalValue !== 'number' &&
+                    typeof literalValue !== 'string') {
                     // Check if this is accessing our target object
                     let currentBase = unwrapExpression(memberExpr.object);
                     while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
@@ -147,24 +176,18 @@ function getObjectUsagesInHook(hookBody, objectName) {
                     }
                     if (currentBase.type === utils_1.AST_NODE_TYPES.Identifier &&
                         currentBase.name === objectName) {
-                        // This is a dynamic computed property access on our target object,
-                        // so we need the entire object (no narrowable field exists).
+                        // No narrowable field exists, so the entire object is required.
                         needsEntireObject = true;
                     }
                     return null;
                 }
-                // For computed properties with literals
-                const literalProp = memberExpr.property;
-                if (typeof literalProp.value === 'number') {
-                    parts.unshift(`[${literalProp.value}]`);
-                }
-                else if (typeof literalProp.value === 'string') {
-                    parts.unshift(`[${JSON.stringify(literalProp.value)}]`);
-                }
-                else {
-                    // For other literal computed properties (e.g. boolean/null), wildcard
-                    parts.unshift('[*]');
-                }
+                segments.unshift({
+                    text: typeof literalValue === 'number'
+                        ? `[${literalValue}]`
+                        : `[${JSON.stringify(literalValue)}]`,
+                    computed: true,
+                    optional: memberExpr.optional,
+                });
             }
             else {
                 // Regular property access
@@ -175,57 +198,37 @@ function getObjectUsagesInHook(hookBody, objectName) {
                 if (memberExpr.property.name &&
                     (ARRAY_METHODS.has(memberExpr.property.name) ||
                         STRING_METHODS.has(memberExpr.property.name))) {
-                    // Check if this is accessing our target object or a property of it
-                    let currentBase = unwrapExpression(memberExpr.object);
-                    const pathParts = [];
-                    let hasOptionalChainingInMethod = false;
-                    // Build the path to the array/string being accessed
-                    while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                        const currentMember = currentBase;
-                        if (currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            pathParts.unshift(currentMember.property.name);
-                        }
-                        if (currentMember.optional) {
-                            hasOptionalChainingInMethod = true;
-                        }
-                        currentBase = unwrapExpression(currentMember.object);
-                    }
-                    if (currentBase.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        currentBase.name === objectName) {
-                        if (pathParts.length === 0) {
-                            // Direct method call on the object (e.g., userData.map(...))
-                            needsEntireObject = true;
-                        }
-                        else {
-                            // Method call on a property (e.g., userData.items.map(...) or userData?.items?.map(...))
-                            let path = objectName + (hasOptionalChainingInMethod ? '?' : '');
-                            path += '.' + pathParts.join('.');
+                    const methodTarget = unwrapExpression(memberExpr.object);
+                    if (methodTarget.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        // Method call on a property (e.g., userData.items.map(...) or
+                        // userData?.items?.map(...)): depend on that property's own path,
+                        // rendered with the same per-link optional markers as any other
+                        // access.
+                        const path = buildAccessPath(methodTarget);
+                        if (path) {
                             usages.set(path, memberExpr.range?.[0] || 0);
                         }
                     }
+                    else if (methodTarget.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        methodTarget.name === objectName) {
+                        // Direct method call on the object (e.g., userData.map(...))
+                        needsEntireObject = true;
+                    }
                     return null;
                 }
-                parts.unshift(memberExpr.property.name);
-            }
-            if (memberExpr.optional) {
-                hasOptionalChaining = true;
+                segments.unshift({
+                    text: memberExpr.property.name,
+                    computed: false,
+                    optional: memberExpr.optional,
+                });
             }
             current = unwrapExpression(memberExpr.object);
         }
         // Check if we reached the target identifier
         const base = unwrapExpression(current);
         if (base.type === utils_1.AST_NODE_TYPES.Identifier && base.name === objectName) {
-            // Build the path with optional chaining
-            let path = objectName + (hasOptionalChaining ? '?' : '');
-            // Add each part with proper formatting (dot notation or bracket notation)
-            for (const part of parts) {
-                if (part.startsWith('[')) {
-                    path += part; // Already formatted as bracket notation
-                }
-                else {
-                    path += '.' + part; // Dot notation
-                }
-            }
+            const path = renderPathSegments(objectName, segments);
+            pathSegments.set(path, segments);
             return path;
         }
         return null;
@@ -446,29 +449,24 @@ function getObjectUsagesInHook(hookBody, objectName) {
     paths.forEach((path) => {
         // Always include the main path
         finalPaths.add(path);
-        // For optional chaining, include the FIRST optional chaining point as intermediate
-        if (path.includes('?.')) {
-            // Find the first optional chaining point
-            // For userData?.profile.settings.theme.primary, we want to include userData?.profile
-            const firstOptionalIndex = path.indexOf('?.');
-            if (firstOptionalIndex !== -1) {
-                // Find the end of the first property after the optional chaining
-                const afterOptional = path.substring(firstOptionalIndex + 2);
-                const nextDotIndex = afterOptional.indexOf('.');
-                if (nextDotIndex !== -1) {
-                    // There are more properties after the first optional property
-                    const firstOptionalPath = path.substring(0, firstOptionalIndex + 2 + nextDotIndex);
-                    finalPaths.add(firstOptionalPath);
-                }
-            }
+        const segments = pathSegments.get(path);
+        if (!segments) {
+            return;
         }
-        // For array access, include the array property itself
-        if (path.includes('[') && path.includes(']')) {
-            const bracketIndex = path.indexOf('[');
-            if (bracketIndex > 0) {
-                const arrayPath = path.substring(0, bracketIndex);
-                finalPaths.add(arrayPath);
-            }
+        // Include the FIRST optional link as an intermediate dependency when more
+        // links follow it: for userData?.profile.settings.theme.primary we also
+        // want userData?.profile.
+        const firstOptionalIndex = segments.findIndex((segment) => segment.optional);
+        if (firstOptionalIndex !== -1 && firstOptionalIndex < segments.length - 1) {
+            finalPaths.add(renderPathSegments(objectName, segments.slice(0, firstOptionalIndex + 1)));
+        }
+        // For array access, include the array property itself: for
+        // userData.items[0] we also want userData.items. A bracket directly on
+        // the base (state[0], state?.[0]) adds nothing — its "array" is the
+        // entire object dependency this rule exists to narrow away.
+        const firstComputedIndex = segments.findIndex((segment) => segment.computed);
+        if (firstComputedIndex > 0) {
+            finalPaths.add(renderPathSegments(objectName, segments.slice(0, firstComputedIndex)));
         }
     });
     // Convert to array for sorting
@@ -477,9 +475,11 @@ function getObjectUsagesInHook(hookBody, objectName) {
     // Exception: keep array paths with optional chaining as they represent different dependencies
     const filteredPaths = pathsArray.filter((path) => {
         // Skip array paths if we're accessing specific indices, unless it's optional chaining
+        // why: an optional bracket renders as `?.[`, so the specific-index probe
+        // must accept both `base[0]` and `base?.[0]` shapes.
         const isArrayWithSpecificIndices = pathsArray.some((otherPath) => otherPath !== path &&
             (otherPath.startsWith(path + '[') ||
-                otherPath.match(new RegExp(`^${path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\[\\d+\\]`))));
+                otherPath.startsWith(path + '?.[')));
         // Keep array paths with optional chaining even if specific indices are accessed
         if (isArrayWithSpecificIndices && path.includes('?.')) {
             return true;

package/lib/rules/prefer-map-over-conditional-dispatch.js

@@ -50,6 +50,18 @@ const FUNCTION_TYPES = new Set([
     utils_1.AST_NODE_TYPES.FunctionExpression,
     utils_1.AST_NODE_TYPES.FunctionDeclaration,
 ]);
+/**
+ * Function/constructor/conditional type notation must be parenthesized to
+ * appear as a `|` union member, or the emitted annotation does not parse
+ * ("Function type notation must be parenthesized when used in a union type").
+ * Over-wrapping is harmless — a parenthesized type is valid in any type
+ * position — so this tests the printed text conservatively instead of
+ * re-deriving the printer's precedence rules.
+ */
+function parenthesizeForUnion(text) {
+    const needsParens = text.includes('=>') || /^new\b/.test(text) || /\bextends\b/.test(text);
+    return needsParens ? `(${text})` : text;
+}
 exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
     name: 'prefer-map-over-conditional-dispatch',
     meta: {
@@ -194,7 +206,13 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                     parts.push(text);
                 }
             }
-            return parts.length > 0 ? parts.join(' | ') : null;
+            if (parts.length === 0) {
+                return null;
+            }
+            if (parts.length === 1) {
+                return parts[0];
+            }
+            return parts.map(parenthesizeForUnion).join(' | ');
         }
         function discriminantTypeText(type, discriminant) {
             try {
@@ -209,6 +227,94 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 return null;
             }
         }
+        /**
+         * `checker.typeToString()` prints a symbol's bare name with no regard for
+         * whether that name resolves at the fix site (an unimported helper type
+         * prints the same as an imported one), and exotic printer output can be
+         * invalid in an annotation position. Shipping such an annotation breaks
+         * the build, so the fix is gated on the synthesized text (a) parsing
+         * standalone and (b) referencing only names in scope where the Record is
+         * inserted. Failing the gate downgrades to the report-only path — the
+         * plugin prefers a skipped fix over one that does not compile.
+         */
+        function validateAnnotation(annotationText, fixSite) {
+            const sourceFile = ts.createSourceFile('__annotation__.ts', `type __T = ${annotationText};`, ts.ScriptTarget.Latest, true);
+            // parseDiagnostics is absent from the public SourceFile type but always
+            // populated at runtime; a diagnostic here means the annotation cannot
+            // ship (e.g. printer truncation, or an unparenthesized member shape the
+            // union-wrapping heuristic does not recognize).
+            const parseDiagnostics = sourceFile.parseDiagnostics;
+            if (!parseDiagnostics || parseDiagnostics.length > 0) {
+                return 'unparseable';
+            }
+            const typeReferenceRoots = new Set();
+            const typeQueryRoots = new Set();
+            let hasImportType = false;
+            const rootNameOf = (name) => {
+                let current = name;
+                while (ts.isQualifiedName(current)) {
+                    current = current.left;
+                }
+                return current.text;
+            };
+            const collect = (node) => {
+                if (ts.isTypeReferenceNode(node)) {
+                    typeReferenceRoots.add(rootNameOf(node.typeName));
+                }
+                else if (ts.isTypeQueryNode(node)) {
+                    typeQueryRoots.add(rootNameOf(node.exprName));
+                }
+                else if (ts.isImportTypeNode(node)) {
+                    // `import("...").T` paths printed by the checker are absolute or
+                    // resolver-relative — never portable source text.
+                    hasImportType = true;
+                }
+                ts.forEachChild(node, collect);
+            };
+            collect(sourceFile);
+            if (hasImportType) {
+                return 'unresolvable';
+            }
+            // `Record` is the wrapper this rule itself emits — a TS lib global that
+            // is present in any real project. The isolated single-file program a
+            // RuleTester builds loads no lib files at all, so requiring it in scope
+            // would falsely downgrade every fix under test.
+            typeReferenceRoots.delete('Record');
+            if (typeReferenceRoots.size === 0 && typeQueryRoots.size === 0) {
+                return 'ok';
+            }
+            const tsFixSite = esTreeNodeToTSNodeMap.get(fixSite);
+            if (!tsFixSite) {
+                return 'unresolvable';
+            }
+            try {
+                const namesInScope = (meaning) => new Set(checker
+                    .getSymbolsInScope(tsFixSite, meaning)
+                    .map((symbol) => symbol.name));
+                if (typeReferenceRoots.size > 0) {
+                    const typeNames = namesInScope(ts.SymbolFlags.Type |
+                        ts.SymbolFlags.Namespace |
+                        ts.SymbolFlags.Alias);
+                    for (const root of typeReferenceRoots) {
+                        if (!typeNames.has(root)) {
+                            return 'unresolvable';
+                        }
+                    }
+                }
+                if (typeQueryRoots.size > 0) {
+                    const valueNames = namesInScope(ts.SymbolFlags.Value | ts.SymbolFlags.Alias);
+                    for (const root of typeQueryRoots) {
+                        if (!valueNames.has(root)) {
+                            return 'unresolvable';
+                        }
+                    }
+                }
+            }
+            catch {
+                return 'unresolvable';
+            }
+            return 'ok';
+        }
         // ---- AST helpers --------------------------------------------------------
         /** Whether a discriminant expression is an identifier or a call-free,
          * non-optional member chain (safe to collapse repeated evaluations). */
@@ -500,6 +606,19 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 });
                 return;
             }
+            const verdict = validateAnnotation(`Record<${dText}, ${vText}>`, discriminantOf(node));
+            if (verdict !== 'ok') {
+                context.report({
+                    node,
+                    messageId: 'preferMapManual',
+                    data: {
+                        reason: verdict === 'unparseable'
+                            ? 'the branch value type does not print as a parseable annotation — write the Record with an explicit type manually'
+                            : 'the annotation would name types that are not in scope at the fix site — import them or write the Record manually',
+                    },
+                });
+                return;
+            }
             context.report({
                 node,
                 messageId: 'preferMap',

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.20.25",
+    "date": "2026-07-30T02:59:17.229Z",
+    "rules": [
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          1401
+        ],
+        "summary": "render optional links per segment (closes #1401)"
+      },
+      {
+        "name": "prefer-map-over-conditional-dispatch",
+        "changeType": "fix",
+        "issues": [
+          1402
+        ],
+        "summary": "validate the synthesized Record annotation (closes #1402)"
+      }
+    ]
+  },
+  {
+    "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",