@blumintinc/eslint-plugin-blumint 1.20.68 → 1.20.70

package/lib/index.js

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

package/lib/rules/class-methods-read-top-to-bottom.js

@@ -80,25 +80,42 @@ exports.classMethodsReadTopToBottom = (0, createRule_1.createRule)({
                     if (actualMember !== expectedMember) {
                         const classNameReport = className || 'this class';
                         const sourceCode = context.getSourceCode();
-                        const newClassBody = sortedOrder
-                            .map((n) => {
-                            // Fetch the actual AST node corresponding to the name
-                            const memberNode = node.body.find((member) => getMemberName(member) === n);
-                            if (!memberNode) {
-                                return '';
-                            }
-                            const comments = sourceCode.getCommentsBefore(memberNode) || [];
-                            const nodeRange = memberNode.range;
-                            const newRange = comments.length > 0
-                                ? [
-                                    Math.min(nodeRange[0], Math.min(...comments.map((comment) => comment.range[0]))),
-                                    Math.max(nodeRange[1], Math.max(...comments.map((comment) => comment.range[1]))),
-                                ]
-                                : nodeRange;
-                            return sourceCode.getText({ ...memberNode, range: newRange });
-                        })
-                            .filter(Boolean)
-                            .join('\n');
+                        const sourceText = sourceCode.getText();
+                        // A member's block spans its leading comments through its own end,
+                        // so documentation travels with the member it describes. Because
+                        // every comment in the body is thereby absorbed into some block,
+                        // the text between two adjacent blocks is pure whitespace.
+                        const memberBlocks = node.body.map((member) => {
+                            const comments = sourceCode.getCommentsBefore(member) || [];
+                            const start = Math.min(member.range[0], ...comments.map((comment) => comment.range[0]));
+                            return {
+                                name: getMemberName(member),
+                                text: sourceText.slice(start, member.range[1]),
+                                start,
+                                end: member.range[1],
+                            };
+                        });
+                        // Reuse those whitespace runs positionally instead of joining with
+                        // a bare '\n'. The blank lines between members are the part that
+                        // matters: prettier preserves existing blank lines but never
+                        // inserts new ones, so collapsing them is irreversible (#1592).
+                        // Carrying the runs verbatim also reproduces the newline and
+                        // indentation after `{` and the newline before `}` for free, since
+                        // every member sits at the same depth.
+                        const separators = memberBlocks
+                            .slice(1)
+                            .map((block, index) => sourceText.slice(memberBlocks[index].end, block.start));
+                        const prefix = sourceText.slice(node.range[0] + 1, memberBlocks[0].start);
+                        const suffix = sourceText.slice(memberBlocks[memberBlocks.length - 1].end, node.range[1] - 1);
+                        const newClassBody = prefix +
+                            sortedOrder
+                                .map((n) => {
+                                const block = memberBlocks.find(({ name }) => name === n);
+                                return block ? block.text : '';
+                            })
+                                .map((text, index) => index === 0 ? text : separators[index - 1] + text)
+                                .join('') +
+                            suffix;
                         return context.report({
                             node,
                             messageId: 'classMethodsReadTopToBottom',

package/lib/rules/enforce-early-destructuring.js

@@ -3,6 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceEarlyDestructuring = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+/**
+ * Source forms that already bind tighter than `??`, so wrapping them in the
+ * hoisted `(obj) ?? {}` initializer adds parentheses a formatter then strips.
+ *
+ * The set is deliberately limited to what this rule can actually emit: only an
+ * identifier-rooted source is ever hoisted, so a call, conditional or logical
+ * source never reaches here. Anything absent keeps its parentheses, which is the
+ * safe direction — a stray pair is cosmetic, a missing pair changes what the
+ * initializer evaluates. `as` and `satisfies` are excluded on purpose: TypeScript
+ * rejects them beside `??` unparenthesized.
+ */
+const TIGHTER_THAN_NULLISH = new Set([
+    utils_1.AST_NODE_TYPES.Identifier,
+    utils_1.AST_NODE_TYPES.ThisExpression,
+    utils_1.AST_NODE_TYPES.MemberExpression,
+    utils_1.AST_NODE_TYPES.ChainExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+]);
+const nullishSourceText = (objectText, init) => init && TIGHTER_THAN_NULLISH.has(init.type) ? objectText : `(${objectText})`;
 const HOOK_NAMES = new Set([
     'useEffect',
     'useMemo',
@@ -875,7 +894,7 @@ function generateHoistingFixes(groups, callback, depsArray, depTexts, insertionS
     for (const group of groups.values()) {
         const sortedProps = Array.from(group.properties.values()).sort((a, b) => a.order - b.order);
         const pattern = `{ ${sortedProps.map((p) => p.text).join(', ')} }`;
-        hoistedLines.push(`${indent}const ${pattern} = (${group.objectText}) ?? {};`);
+        hoistedLines.push(`${indent}const ${pattern} = ${nullishSourceText(group.objectText, group.inits[0])} ?? {};`);
     }
     reservedNamesByScope.set(scope, updatedReservedNames);
     const newDepSet = new Set(newDepTexts);

package/lib/rules/enforce-render-hits-memoization.d.ts

@@ -1,3 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'requireMemoizedTransformBefore' | 'requireMemoizedRender' | 'requireMemoizedRenderHits' | 'noDirectComponentInRender';
-export declare const enforceRenderHitsMemoization: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const enforceRenderHitsMemoization: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
 export {};

package/lib/rules/enforce-render-hits-memoization.js

@@ -3,6 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceRenderHitsMemoization = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const LATEST_CALLBACK_MODULE = 'use-latest-callback';
+const LATEST_CALLBACK_HOOK = 'useLatestCallback';
+/**
+ * Declaration forms whose binding is created once for the program's lifetime.
+ *
+ * `let` and `var` are deliberately excluded: a reassignable binding can hand
+ * `useRenderHits` a different function on a later render, which is precisely
+ * the instability this rule exists to catch.
+ */
+function isStableDeclaration(def) {
+    switch (def.type) {
+        case utils_1.TSESLint.Scope.DefinitionType.FunctionName:
+            return true;
+        case utils_1.TSESLint.Scope.DefinitionType.ImportBinding:
+            // A type-only import binds no value, so its local name names nothing
+            // callable — the same reason the memoization-callee set rejects one.
+            return (def.parent.importKind !== 'type' &&
+                (def.node.type !== utils_1.AST_NODE_TYPES.ImportSpecifier ||
+                    def.node.importKind !== 'type'));
+        case utils_1.TSESLint.Scope.DefinitionType.Variable:
+            return def.parent.kind === 'const';
+        default:
+            return false;
+    }
+}
 exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
     name: 'enforce-render-hits-memoization',
     meta: {
@@ -13,14 +38,36 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            requireMemoizedTransformBefore: 'transformBefore prop must be memoized using useCallback',
-            requireMemoizedRender: 'render prop must be memoized using useCallback',
-            requireMemoizedRenderHits: 'renderHits must be used inside useMemo or useCallback',
+            requireMemoizedTransformBefore: 'transformBefore is recreated on every render, so useRenderHits sees a new transform identity each pass and re-derives (and re-renders) the whole hit list even when the hits did not change. Memoize it with useCallback, useMemo, or useLatestCallback so the reference stays stable across renders.',
+            requireMemoizedRender: 'render is recreated on every render, so useRenderHits sees a new render identity each pass and re-renders every hit even when the hits did not change. Memoize it with useCallback, useMemo, or useLatestCallback so the reference stays stable across renders.',
+            requireMemoizedRenderHits: 'renderHits builds a fresh element for every hit, so calling it outside a memoization boundary re-creates the entire list on each render. Wrap the call in useCallback, useMemo, or useLatestCallback so the elements are rebuilt only when the hits they came from change.',
             noDirectComponentInRender: 'Do not pass React components directly to render prop, use a memoized arrow function instead',
         },
     },
     defaultOptions: [],
     create(context) {
+        // Every callee this rule accepts as a memoization boundary. `useCallback`
+        // and `useMemo` are seeded bare because the rule never resolves React's
+        // import either; local names bound from `use-latest-callback` are added as
+        // its imports are visited.
+        //
+        // `useLatestCallback` belongs in the same set rather than a separate one:
+        // nothing here inspects a dependency array, so the hook taking none (it
+        // keeps the latest callback behind a ref that is stable for the component's
+        // whole life) costs the rule no precision. It has to be here because
+        // `use-latest-callback` — 'error' in the same recommended config, and
+        // fixable — rewrites every `useCallback` into it, and ESLint re-lints until
+        // the output settles, so one `eslint --fix` run does both steps. Without
+        // this entry correctly memoized code goes in and a demand to memoize it
+        // comes out, and the demand names the very hook the sibling fixer just
+        // removed, so following it loops forever (issue #1585).
+        const memoizationCallees = new Set([
+            'useCallback',
+            'useMemo',
+            LATEST_CALLBACK_HOOK,
+        ]);
+        const isMemoizationCallee = (node) => node.type === utils_1.AST_NODE_TYPES.Identifier &&
+            memoizationCallees.has(node.name);
         const isReactComponent = (node) => {
             if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return false;
@@ -29,17 +76,30 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
         const isMemoizedCall = (node) => {
             if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
                 return false;
-            if (!node.callee || node.callee.type !== utils_1.AST_NODE_TYPES.Identifier)
+            if (!node.callee)
                 return false;
-            return (node.callee.name === 'useCallback' || node.callee.name === 'useMemo');
+            return isMemoizationCallee(node.callee);
+        };
+        const isWithinMemoizationCall = (node) => {
+            let current = node;
+            while (current?.parent) {
+                if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    isMemoizationCallee(current.parent.callee)) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
         };
         const isMemoizedVariable = (node) => {
             if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return false;
-            // Get the variable declaration for this identifier
-            const variable = context
-                .getScope()
-                .variables.find((v) => v.name === node.name);
+            // The whole scope chain has to be searched rather than the current
+            // scope's own variable list: a useRenderHits call sitting inside a nested
+            // block or a nested component reaches its memoized declaration through an
+            // enclosing scope, and reading one scope's `variables` would miss it and
+            // demand a useCallback around a value that already has one.
+            const variable = utils_1.ASTUtils.findVariable(context.getScope(), node);
             if (!variable)
                 return false;
             // Check if the variable is initialized with a memoized call
@@ -55,6 +115,45 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
             }
             return false;
         };
+        /**
+         * A prop pointing at a declaration that lives outside every component body.
+         *
+         * Module scope creates the binding once for the program's lifetime, so its
+         * identity is strictly more stable than anything a hook can hand back:
+         * demanding a `useCallback` wrapper around it asks for work that can only
+         * make the reference less stable, never more.
+         *
+         * Both `module` and `global` count. Under `sourceType: 'script'` — the
+         * parser default, and what a consumer's config may well leave in place — a
+         * top-level declaration binds to the *global* scope and no module scope
+         * exists at all (issue #1578), so keying on `module` alone would silently
+         * drop the carve-out for exactly the consumers who never opted into module
+         * parsing.
+         *
+         * The shape is not hypothetical:
+         * `no-empty-dependency-use-callbacks` — 'error' in the same recommended
+         * config, and fixable — hoists a dependency-free callback to module scope
+         * and drops the hook, so one `eslint --fix` run rewrites memoized code into
+         * exactly this form. Without the carve-out the config demands the very hook
+         * its own fixer just removed (issue #1586).
+         */
+        const isStableOuterScopeBinding = (node) => {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            // The scope chain has to be walked rather than a single scope's variable
+            // list read: the useRenderHits call sits inside the component, so a
+            // module-scope declaration is never among the current scope's own
+            // variables.
+            const variable = utils_1.ASTUtils.findVariable(context.getScope(), node);
+            if (!variable)
+                return false;
+            const scopeType = variable.scope.type;
+            if (scopeType !== utils_1.TSESLint.Scope.ScopeType.module &&
+                scopeType !== utils_1.TSESLint.Scope.ScopeType.global) {
+                return false;
+            }
+            return variable.defs.some(isStableDeclaration);
+        };
         const isInsideMemoizedCall = (node) => {
             // Handle the case when node is already a memoized call
             if (isMemoizedCall(node))
@@ -62,18 +161,13 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
             // Check if the node is a reference to a memoized variable
             if (isMemoizedVariable(node))
                 return true;
+            // A declaration outside every component body needs no memoization: it is
+            // already as stable as a reference can be.
+            if (isStableOuterScopeBinding(node))
+                return true;
             // Check if the node is inside a memoization hook call
-            let current = node;
-            while (current?.parent) {
-                if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                    const callee = current.parent.callee;
-                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        (callee.name === 'useCallback' || callee.name === 'useMemo')) {
-                        return true;
-                    }
-                }
-                current = current.parent;
-            }
+            if (isWithinMemoizationCall(node))
+                return true;
             // Check if the node is a reference to a memoized value
             const scope = context.getScope();
             // Make sure node is an Identifier before accessing name property
@@ -88,44 +182,22 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
             for (const def of variable.defs) {
                 const parent = def.node.parent;
                 if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                    parent.init?.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                    const callee = parent.init.callee;
-                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        (callee.name === 'useCallback' || callee.name === 'useMemo')) {
-                        return true;
-                    }
+                    parent.init?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    isMemoizationCallee(parent.init.callee)) {
+                    return true;
                 }
             }
             // Check if any reference is inside a memoized call
             for (const ref of variable.references) {
-                let current = ref.identifier;
-                while (current?.parent) {
-                    if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                        const callee = current.parent.callee;
-                        if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            (callee.name === 'useCallback' || callee.name === 'useMemo')) {
-                            return true;
-                        }
-                    }
-                    current = current.parent;
-                }
+                if (isWithinMemoizationCall(ref.identifier))
+                    return true;
             }
             // Check if the node is a property of an object that is memoized
             const parent = node.parent;
             if (parent?.type === utils_1.AST_NODE_TYPES.Property &&
                 parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                const objectExpression = parent.parent;
-                let current = objectExpression;
-                while (current?.parent) {
-                    if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                        const callee = current.parent.callee;
-                        if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            (callee.name === 'useCallback' || callee.name === 'useMemo')) {
-                            return true;
-                        }
-                    }
-                    current = current.parent;
-                }
+                if (isWithinMemoizationCall(parent.parent))
+                    return true;
             }
             return false;
         };
@@ -133,6 +205,23 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
         let renderHitsName = 'renderHits';
         return {
             ImportDeclaration(node) {
+                // The module's sole export is the hook, so its DEFAULT specifier binds
+                // it under whatever local name the file chose — a shape a set of bare
+                // hook names cannot see. `use-latest-callback`'s own fixer picks that
+                // name, falling back to `useLatestCallback2` when `useLatestCallback`
+                // is already taken in the file, so the alias is not hypothetical.
+                if (node.source.value === LATEST_CALLBACK_MODULE &&
+                    (!node.importKind || node.importKind === 'value')) {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                            (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                                specifier.importKind !== 'type' &&
+                                specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                specifier.imported.name === LATEST_CALLBACK_HOOK)) {
+                            memoizationCallees.add(specifier.local.name);
+                        }
+                    }
+                }
                 if (node.source.value.endsWith('useRenderHits')) {
                     for (const specifier of node.specifiers) {
                         if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
@@ -160,43 +249,19 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
                     const options = node.arguments[0];
                     if (options.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
                         return;
-                    // Variable to track if we need to check properties (check both by default)
-                    const checkProps = {
-                        transformBefore: true,
-                        render: true,
-                    };
-                    // First pass: Check if transformBefore or render properties exist as shorthand
-                    for (const prop of options.properties) {
-                        if (prop.type !== utils_1.AST_NODE_TYPES.Property)
-                            continue;
-                        if (prop.key.type !== utils_1.AST_NODE_TYPES.Identifier)
-                            continue;
-                        // If it's shorthand property syntax like { transformBefore } and already a memoized variable
-                        if (prop.key.name === 'transformBefore' &&
-                            prop.shorthand &&
-                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            checkProps.transformBefore = !isMemoizedVariable(prop.key);
-                        }
-                        else if (prop.key.name === 'render' &&
-                            prop.shorthand &&
-                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            checkProps.render = !isMemoizedVariable(prop.key);
-                        }
-                    }
-                    // Second pass: Check non-shorthand properties
+                    // Shorthand props are checked exactly like written-out ones. `{ render }`
+                    // and `render: render` describe the same value, and the config's own
+                    // fixable `object-shorthand: ['error', 'always']` rewrites the second
+                    // into the first, so exempting the shorthand form would let a single
+                    // `eslint --fix` erase every report this rule makes about a prop whose
+                    // variable happens to share the API's name — the shape idiomatic code
+                    // reaches for first (issue #1588).
                     for (const prop of options.properties) {
                         if (prop.type !== utils_1.AST_NODE_TYPES.Property)
                             continue;
                         if (prop.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                             continue;
-                        // Skip shorthand properties that we already checked
-                        if (prop.shorthand)
-                            continue;
-                        if (prop.key.name === 'transformBefore' &&
-                            checkProps.transformBefore) {
-                            // Skip if the value is already a memoized call
-                            if (isMemoizedCall(prop.value))
-                                continue;
+                        if (prop.key.name === 'transformBefore') {
                             if (!isInsideMemoizedCall(prop.value)) {
                                 context.report({
                                     node: prop.value,
@@ -204,7 +269,7 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
                                 });
                             }
                         }
-                        else if (prop.key.name === 'render' && checkProps.render) {
+                        else if (prop.key.name === 'render') {
                             if (isReactComponent(prop.value)) {
                                 context.report({
                                     node: prop.value,
@@ -222,17 +287,8 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
                 }
                 if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                     node.callee.name === renderHitsName) {
-                    let current = node;
-                    while (current?.parent) {
-                        if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                            const callee = current.parent.callee;
-                            if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                (callee.name === 'useCallback' || callee.name === 'useMemo')) {
-                                return;
-                            }
-                        }
-                        current = current.parent;
-                    }
+                    if (isWithinMemoizationCall(node))
+                        return;
                     context.report({
                         node,
                         messageId: 'requireMemoizedRenderHits',

package/lib/rules/enforce-transform-memoization.js

@@ -4,6 +4,8 @@ exports.enforceTransformMemoization = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const LATEST_CALLBACK_MODULE = 'use-latest-callback';
+const LATEST_CALLBACK_HOOK = 'useLatestCallback';
 exports.enforceTransformMemoization = (0, createRule_1.createRule)({
     name: 'enforce-transform-memoization',
     meta: {
@@ -26,7 +28,14 @@ exports.enforceTransformMemoization = (0, createRule_1.createRule)({
         const scopeManager = sourceCode.scopeManager;
         const adaptValueNames = new Set(['adaptValue']);
         const memoizingHooks = new Set(['useMemo', 'useCallback']);
-        const stabilizingUtilities = new Set(['useEvent']);
+        // Hooks that hand back a reference stable for the component's whole life and
+        // take no dependency array, so there is none to audit. `useLatestCallback`
+        // belongs here because `use-latest-callback` — 'error' in the same
+        // recommended config, and fixable — rewrites every `useCallback` into it and
+        // drops the array. ESLint re-lints until the output settles, so one
+        // `eslint --fix` run does both steps: without this entry, correctly
+        // memoized code goes in and a demand to memoize it comes out (issue #1584).
+        const stabilizingUtilities = new Set(['useEvent', LATEST_CALLBACK_HOOK]);
         const getPropertyName = (key) => {
             if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
                 return key.name;
@@ -378,6 +387,23 @@ exports.enforceTransformMemoization = (0, createRule_1.createRule)({
         return {
             ImportDeclaration(node) {
                 const sourceValue = typeof node.source.value === 'string' ? node.source.value : '';
+                // The module's sole export is the hook, so its DEFAULT specifier binds
+                // it under whatever local name the file chose — a shape a set of bare
+                // hook names cannot see. `use-latest-callback`'s own fixer picks that
+                // name, and falls back to `useLatestCallback2` when `useLatestCallback`
+                // is already taken in the file, so the alias is not hypothetical.
+                if (sourceValue === LATEST_CALLBACK_MODULE &&
+                    (!node.importKind || node.importKind === 'value')) {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                            (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                                specifier.importKind !== 'type' &&
+                                specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                specifier.imported.name === LATEST_CALLBACK_HOOK)) {
+                            stabilizingUtilities.add(specifier.local.name);
+                        }
+                    }
+                }
                 for (const specifier of node.specifiers) {
                     if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                         specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&

package/lib/rules/no-useless-usememo-primitives.js

@@ -381,6 +381,22 @@ exports.noUselessUsememoPrimitives = (0, createRule_1.createRule)({
                         valueKind,
                     },
                     fix(fixer) {
+                        // Inlining replaces the entire useMemo(...) call with the returned
+                        // expression's text, so any comment inside the call but outside
+                        // that expression — an eslint-disable-next-line directive on the
+                        // return statement among them — has no representation in the
+                        // replacement and would be silently destroyed, changing which
+                        // rules report on the file (#1591). The inlined expression lands
+                        // mid-line (e.g. `const label = <expr>;`), where a -next-line
+                        // directive cannot be hosted, so the autofix declines and leaves
+                        // the report for a manual fix.
+                        const strandedComments = sourceCode
+                            .getCommentsInside(node)
+                            .filter((comment) => comment.range[0] < returnedExpression.range[0] ||
+                            comment.range[1] > returnedExpression.range[1]);
+                        if (strandedComments.length > 0) {
+                            return null;
+                        }
                         const replacement = `(${sourceCode.getText(returnedExpression)})`;
                         return fixer.replaceText(node, replacement);
                     },

package/lib/rules/optimize-object-boolean-conditions.js

@@ -101,6 +101,12 @@ function isPrimitiveTypeNode(node) {
  * operands: comparisons and arithmetic yield numbers/strings/booleans, and `!`,
  * `typeof` and friends yield booleans/strings/numbers.
  */
+/** `as const` — a type reference whose name is the `const` contextual keyword. */
+function isConstAssertion(typeNode) {
+    return (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+        typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        typeNode.typeName.name === 'const');
+}
 function isPrimitiveExpression(node) {
     if (!node) {
         return false;
@@ -120,7 +126,19 @@ function isPrimitiveExpression(node) {
         case utils_1.AST_NODE_TYPES.BinaryExpression:
             return true;
         case utils_1.AST_NODE_TYPES.TSAsExpression:
-            return isPrimitiveTypeNode(node.typeAnnotation);
+            // `as const` narrows rather than retypes, so the asserted expression
+            // decides. Recursing keeps `{ a: 1 } as const` an object while accepting
+            // `0 as const` — the form global-const-style and
+            // enforce-object-literal-as-const rewrite bare constants into, so without
+            // this the plugin's own fixers manufacture the report (#1581).
+            return isConstAssertion(node.typeAnnotation)
+                ? isPrimitiveExpression(node.expression)
+                : isPrimitiveTypeNode(node.typeAnnotation);
+        // `satisfies` never changes the value, only checks it.
+        case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+            return isPrimitiveExpression(node.expression);
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            return isPrimitiveExpression(node.expression);
         default:
             return false;
     }