@blumintinc/eslint-plugin-blumint 1.21.2 → 1.21.4

package/lib/rules/enforce-firestore-set-merge.js

@@ -33,6 +33,22 @@ const BATCH_MANAGER = 'batchManager';
  * the rule's scope entirely.
  */
 const REALTIME_BATCH_MANAGER = 'RealtimeBatchManager';
+/** Firestore's single-field addressing class, in every spelling it reaches. */
+const FIELD_PATH = 'FieldPath';
+/**
+ * Receivers whose `update(…)` puts the document reference in the first
+ * position. See {@link takesReferenceFirst}.
+ */
+const REFERENCE_FIRST_RECEIVERS = new Set([
+    'batch',
+    'writebatch',
+    'bulkwriter',
+    'transaction',
+    'trx',
+    'tx',
+    'txn',
+    'writer',
+]);
 /** The firestore module a dynamic `await import(…)` reads, if it is one. */
 function firestoreDynamicImportModule(node) {
     if (node?.type !== utils_1.AST_NODE_TYPES.AwaitExpression) {
@@ -269,6 +285,88 @@ function unwrapTransparent(node) {
         ? unwrapTransparent(stripped.expression)
         : stripped;
 }
+/**
+ * Whether an expression names Firestore's `FieldPath`, which addresses a single
+ * field rather than carrying a document's data.
+ *
+ * Every spelling reaches the same class — a bare `new FieldPath('a', 'b')`, the
+ * namespaced `new admin.firestore.FieldPath(…)`, and the static
+ * `admin.firestore.FieldPath.documentId()` — so the rightmost `FieldPath`
+ * segment anywhere in the callee or the member chain is what answers.
+ */
+function namesFieldPath(node) {
+    const expression = unwrapTransparent(node);
+    switch (expression.type) {
+        case utils_1.AST_NODE_TYPES.Identifier:
+            return expression.name === FIELD_PATH;
+        case utils_1.AST_NODE_TYPES.MemberExpression:
+            return ((!expression.computed &&
+                expression.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                expression.property.name === FIELD_PATH) ||
+                namesFieldPath(expression.object));
+        case utils_1.AST_NODE_TYPES.NewExpression:
+        case utils_1.AST_NODE_TYPES.CallExpression:
+            return namesFieldPath(expression.callee);
+        default:
+            return false;
+    }
+}
+/**
+ * Whether an argument is the document-data object the rewrite appends its
+ * options to, rather than the field name of `update(field, value, …)`.
+ *
+ * A primitive and a `FieldPath` are the two things the varargs overload puts in
+ * that position, and neither is data: handing one to `set` makes it the whole
+ * document (#2311).
+ */
+function isDocumentData(node) {
+    return !!node && !isPrimitiveLiteral(node) && !namesFieldPath(node);
+}
+/** The identifier that names a receiver, however the expression reaches it. */
+function receiverName(node) {
+    const receiver = unwrapTransparent(node);
+    switch (receiver.type) {
+        case utils_1.AST_NODE_TYPES.Identifier:
+            return receiver.name;
+        case utils_1.AST_NODE_TYPES.MemberExpression:
+            return !receiver.computed &&
+                receiver.property.type === utils_1.AST_NODE_TYPES.Identifier
+                ? receiver.property.name
+                : null;
+        case utils_1.AST_NODE_TYPES.CallExpression:
+            return receiverName(receiver.callee);
+        default:
+            return null;
+    }
+}
+/** A name's last camelCase (or snake_case) segment, lowercased. */
+function lastNameSegment(name) {
+    const segments = name.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+|[A-Z]/g) ?? [];
+    return (segments[segments.length - 1] ?? '').toLowerCase();
+}
+/**
+ * Whether a receiver's `update(…)` takes the document reference FIRST, which
+ * puts the data it merges in the second position.
+ *
+ * `WriteBatch`, `Transaction` and `BulkWriter` all spell the call
+ * `update(ref, data)`, while a `DocumentReference` spells it `update(data)`.
+ * The two readings of a two-argument call are not interchangeable — on a
+ * reference the second argument is a `Precondition`, which `set` has no
+ * parameter for — so the shape gate has to know which one it is looking at.
+ *
+ * The match is on the receiver's last camelCase SEGMENT rather than on a
+ * substring: a name that merely contains one of these words is usually a
+ * document, `transactionRef` being a document in a `transactions` collection.
+ * An unrecognised receiver therefore reads as a document, which is the safe
+ * default in both directions: its one-argument calls still rewrite, because
+ * `update(data)` is the only valid reading of a single argument on ANY of these
+ * receivers, and its two-argument calls decline rather than gamble the
+ * precondition rewrite on a name.
+ */
+function takesReferenceFirst(node) {
+    const name = receiverName(node);
+    return name !== null && REFERENCE_FIRST_RECEIVERS.has(lastNameSegment(name));
+}
 /**
  * Whether a declarator is initialized from a `<x>.firestore()` call.
  *
@@ -953,7 +1051,11 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
             // BatchManager takes a single descriptor object, so its arguments are
             // genuinely restructured rather than extended.
             if (objectText.includes('batchManager')) {
-                if (args.length < 2) {
+                // The descriptor is built from the reference and the data alone, so an
+                // argument past the second is copied nowhere: a call carrying one is
+                // some other overload, and rewriting it would DELETE that argument
+                // rather than merely mislay it (#2311).
+                if (args.length !== 2 || !isDocumentData(args[1])) {
                     return null;
                 }
                 // This branch is the one rewrite that cannot edit the call in place: it
@@ -985,6 +1087,47 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                         `${indent}})`),
                 ];
             }
+            // `set` has exactly two parameters, `set(data, options)`, so appending
+            // `{ merge: true }` is a valid rewrite of ONE call shape: the single
+            // data object. `update` has two more documented forms, and the append
+            // corrupts both (#2311).
+            //
+            // `update(field, value, …)` addresses fields positionally. Appending
+            // there emits `set(field, value, …, { merge: true })`, where `set` reads
+            // the field NAME as the document data and every argument past the second
+            // is a type error.
+            //
+            // `update(data, precondition)` guards the write on the document's
+            // existence or its version. Appending there emits
+            // `set(data, precondition, { merge: true })`: `set` reads the
+            // precondition as its `SetOptions`, which carries neither `merge` nor
+            // `mergeFields`, so the guard is dropped AND the merge never applies —
+            // and a `set` without merge overwrites the whole document, deleting
+            // every field the partial update was not naming. That rewrite exits 0
+            // and produces no diagnostic without type information, which is why the
+            // fix is withheld rather than approximated.
+            //
+            // The REPORT stands in both cases. Neither form has a mechanical `set`
+            // equivalent — the varargs one has to be folded into an object literal
+            // and the precondition has no `set` counterpart at all — so the author is
+            // told, converts by hand, or opts out with a reviewable
+            // `eslint-disable-next-line`. Suppressing the report instead would hand
+            // the decision to a receiver-name heuristic: a receiver this rule fails
+            // to recognise as a batch would stop reporting a violation it can see,
+            // turning a declined FIX into an unenforced RULE.
+            const dataIndex = takesReferenceFirst(callee.object) ? 1 : 0;
+            if (args.length !== dataIndex + 1 || !isDocumentData(args[dataIndex])) {
+                return null;
+            }
+            // A receiver NAMED like a batch may still be a document — `const batch =
+            // db.collection('batches').doc(id)` — and its two-argument call is then
+            // the precondition overload after all. No batch or transaction passes a
+            // document's data where its reference goes, so an object literal in the
+            // first position withdraws the name's evidence and the call declines.
+            if (dataIndex === 1 &&
+                unwrapTransparent(args[0]).type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return null;
+            }
             const appended = appendArguments(fixer, node, [MERGE_OPTION], 'set'.length - callee.property.name.length);
             if (!appended) {
                 return null;
@@ -1164,11 +1307,19 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
          * fix that never ships would make its own report decline too.
          */
         function rewriteCall(fixer, rewrite) {
+            // The modular SDK spells the varargs overload
+            // `updateDoc(ref, field, value, …)`, which the append corrupts exactly as
+            // it corrupts the method form: `setDoc(ref, field, value, …)` reads the
+            // field NAME as the document data and overwrites the document with it
+            // (#2311). `setDoc` has no third parameter past its options, so anything
+            // beyond `updateDoc(ref, data)` declines.
+            const args = rewrite.call.arguments;
+            if (args.length > 2 || (args.length === 2 && !isDocumentData(args[1]))) {
+                return null;
+            }
             // `setDoc` takes the document data between the reference and the
             // options, so a call that passed no data gets an empty object to merge.
-            const appended = appendArguments(fixer, rewrite.call, rewrite.call.arguments.length > 1
-                ? [MERGE_OPTION]
-                : [EMPTY_DATA, MERGE_OPTION], SET_DOC.length - rewrite.identifier.name.length);
+            const appended = appendArguments(fixer, rewrite.call, args.length > 1 ? [MERGE_OPTION] : [EMPTY_DATA, MERGE_OPTION], SET_DOC.length - rewrite.identifier.name.length);
             if (!appended) {
                 return null;
             }

package/lib/rules/enforce-object-literal-as-const.js

@@ -117,15 +117,93 @@ function declaredReturnTypeOf(fn) {
     }
     return undefined;
 }
+/**
+ * Every `return` statement lexically owned by `fn` — a `return` inside a
+ * nested function returns from that function, not this one, so descent stops
+ * at each function boundary. Both single-node and array-valued child
+ * properties are walked (`BlockStatement.body` is an array,
+ * `IfStatement.consequent` a single node): a walk keyed on a plain `isNode`
+ * check alone silently skips every array-shaped child.
+ */
+function returnStatementsOf(fn) {
+    const returns = [];
+    function visit(node) {
+        if (node.type === 'ReturnStatement') {
+            returns.push(node);
+            return;
+        }
+        if (node !== fn && FUNCTION_TYPES.has(node.type)) {
+            return;
+        }
+        for (const key in node) {
+            if (key === 'parent') {
+                continue;
+            }
+            const value = node[key];
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    if (ASTHelpers_1.ASTHelpers.isNode(item)) {
+                        visit(item);
+                    }
+                }
+            }
+            else if (ASTHelpers_1.ASTHelpers.isNode(value)) {
+                visit(value);
+            }
+        }
+    }
+    visit(fn.body);
+    return returns;
+}
+/**
+ * The type carried by the sole `return` statement's own `as` assertion — a
+ * fallback reading used only when the signature itself states nothing. A
+ * single return whose expression is asserted to a type states that type as
+ * forcefully as a signature would: TS infers nothing beyond it, since there
+ * is nothing else to union it with. Two or more returns lose this — each
+ * return's own assertion describes only its branch, and the signature TS
+ * infers unions them, so no single assertion speaks for the whole function.
+ *
+ * Reading only the signature is exactly what let
+ * `no-redundant-annotation-assertion`'s `--fix` disarm this rule: deleting a
+ * signature that repeats a sole return's assertion moves the type
+ * information rather than removing it, and this rule read only the moved-from
+ * location (#2319).
+ *
+ * `as const` is excluded: it names no separate type to read here — it is the
+ * very rewrite this rule is deciding whether to apply, not a statement of
+ * what a signature would accept.
+ */
+function soleReturnAssertionTypeOf(fn) {
+    const returns = returnStatementsOf(fn);
+    if (returns.length !== 1) {
+        return undefined;
+    }
+    const { argument } = returns[0];
+    if (!argument || argument.type !== 'TSAsExpression') {
+        return undefined;
+    }
+    const { typeAnnotation } = argument;
+    const isAsConst = typeAnnotation.type === 'TSTypeReference' &&
+        typeAnnotation.typeName.type === 'Identifier' &&
+        typeAnnotation.typeName.name === 'const';
+    return isAsConst ? undefined : typeAnnotation;
+}
 /**
  * The type the *returned expression* must satisfy. For an async function or a
  * generator the declared return type wraps that expression's type, so the
  * wrapper is peeled off before the annotation is judged.
+ *
+ * With no signature annotation in view, the sole return statement's own
+ * assertion (`soleReturnAssertionTypeOf`) is read directly as the value's
+ * type instead: it targets the returned expression itself, not a
+ * function-level return type, so it carries no Promise/Generator wrapper to
+ * peel the way a signature annotation would.
  */
 function returnedValueTypeOf(fn) {
     const declared = declaredReturnTypeOf(fn);
     if (!declared) {
-        return undefined;
+        return soleReturnAssertionTypeOf(fn);
     }
     const referenceName = typeReferenceNameOf(declared);
     if (fn.generator) {
@@ -238,9 +316,12 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
                 return false;
             }
             const enclosingFunction = enclosingFunctionOf(ancestors);
-            // With no declared return type in view, the inferred tuple is what the
-            // callers get.
-            if (!enclosingFunction || !declaredReturnTypeOf(enclosingFunction)) {
+            // With no declared return type in view — neither the signature nor, as
+            // a fallback, the sole return statement's own assertion — the inferred
+            // tuple is what the callers get.
+            if (!enclosingFunction ||
+                (!declaredReturnTypeOf(enclosingFunction) &&
+                    !soleReturnAssertionTypeOf(enclosingFunction))) {
                 return true;
             }
             const returnedValueType = returnedValueTypeOf(enclosingFunction);

package/lib/rules/enforce-positive-naming.js

@@ -903,6 +903,21 @@ function splitNameIntoWords(name) {
     const spacedName = name.replace(/([A-Z])/g, ' $1');
     return spacedName.toLowerCase().trim().split(/\s+/).filter(Boolean);
 }
+// Name prefixes that mark a binding as a predicate rather than a value.
+const BOOLEAN_NAME_PREFIXES = ['is', 'has', 'can', 'should', 'will', 'does'];
+/**
+ * Whether a name reads as boolean-like, judged on the name's WORDS rather than
+ * its raw spelling. A casing-sensitive prefix test answers `hasNoAccess` and
+ * `HAS_NO_ACCESS` differently even though they carry the same meaning, and
+ * `global-const-style` mandates the SCREAMING_SNAKE spelling for module-level
+ * constants — so every module constant would sit outside this rule's reach.
+ * Joining the split words normalizes camelCase, PascalCase, SCREAMING_SNAKE and
+ * snake_case onto one lowercase form before the prefix test runs.
+ */
+function hasBooleanNamePrefix(name) {
+    const normalizedName = splitNameIntoWords(name).join('');
+    return BOOLEAN_NAME_PREFIXES.some((prefix) => normalizedName.startsWith(prefix));
+}
 // Map of negative boolean terms to suggested positive alternatives
 const BOOLEAN_POSITIVE_ALTERNATIVES = {
     // Boolean prefixes - These will be removed from suggestions
@@ -1248,14 +1263,8 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                     return { isNegative: false, alternatives: [] };
                 }
             }
-            const nameLowercase = name.toLowerCase();
             // Check for negative prefixes in boolean-like variables
-            if (nameLowercase.startsWith('is') ||
-                nameLowercase.startsWith('has') ||
-                nameLowercase.startsWith('can') ||
-                nameLowercase.startsWith('should') ||
-                nameLowercase.startsWith('will') ||
-                nameLowercase.startsWith('does')) {
+            if (hasBooleanNamePrefix(name)) {
                 // We already checked exception words above, so no need to check again
                 for (const prefix of BOOLEAN_NEGATIVE_PREFIXES) {
                     const prefixCapitalized = prefix.charAt(0).toUpperCase() + prefix.slice(1);
@@ -1405,12 +1414,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             }
             // Check if the node has a name that suggests it's a boolean
             if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
-                (node.name.startsWith('is') ||
-                    node.name.startsWith('has') ||
-                    node.name.startsWith('can') ||
-                    node.name.startsWith('should') ||
-                    node.name.startsWith('will') ||
-                    node.name.startsWith('does'))) {
+                hasBooleanNamePrefix(node.name)) {
                 return true;
             }
             return false;

package/lib/rules/enforce-snapshot-state-narrowing.d.ts

@@ -1,5 +1,5 @@
 import { TSESLint } from '@typescript-eslint/utils';
-type MessageIds = 'noFalsyCheck' | 'noRawTypeof';
+type MessageIds = 'noFalsyCheck' | 'noNullishFallback' | 'noRawTypeof';
 type Options = [
     {
         snapshotHooks?: string[];

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

@@ -82,6 +82,10 @@ exports.enforceSnapshotStateNarrowing = (0, createRule_1.createRule)({
             // renames it is not told to call a function their config says does not
             // exist. Every report and suggestion supplies it.
             noFalsyCheck: "Do not use boolean coercion on FirestoreSnapshotState<T>. All string states ('idle', 'loading', 'not-found') are truthy, so '{{expression}}' does not behave as intended. Use {{guard}}(state) to narrow to T, or compare explicitly (e.g., state === 'loading').",
+            // `??` is a distinct mistake from `||`, so it gets its own wording: the
+            // problem is not truthiness but that no state is nullish, which makes the
+            // fallback unreachable rather than merely unreliable.
+            noNullishFallback: "Do not use nullish coalescing on FirestoreSnapshotState<T>. No state ('idle', 'loading', 'not-found') is null or undefined, so '{{expression}}' always evaluates to the state itself and the fallback is unreachable, leaving a state string bound where data was expected. Use {{guard}}(state) to choose between them (e.g., {{guard}}(state) ? state : fallback), or compare explicitly (e.g., state === 'loading').",
             noRawTypeof: "Do not use '{{expression}}' to narrow FirestoreSnapshotState<T> to data. Use {{guard}}(state) instead to maintain the abstraction boundary.",
         },
     },
@@ -342,21 +346,28 @@ exports.enforceSnapshotStateNarrowing = (0, createRule_1.createRule)({
             }
         }
         /**
-         * Reports a falsy/truthy check on a snapshot-state identifier.
+         * Reports a narrowing violation on a snapshot-state identifier and attaches
+         * the guard-based rewrite as its suggestion.
          *
          * `replacement` must match the polarity of the flagged expression: a falsy
          * check reads `!isSnapshotReady(state)`, a truthy one `isSnapshotReady(state)`.
          * `fixNode` defaults to the reported node but can be widened when the whole
          * surrounding expression has to be rewritten (e.g. `state || fallback`).
          */
-        function reportFalsyCheck(node, expression, replacement, fixNode = node) {
+        function reportNarrowing(messageId, node, expression, replacement, fixNode = node) {
             context.report({
                 node,
-                messageId: 'noFalsyCheck',
+                messageId,
                 data: { expression, guard: guardName },
-                suggest: guardSuggestion('noFalsyCheck', fixNode, replacement, context.getScope()),
+                suggest: guardSuggestion(messageId, fixNode, replacement, context.getScope()),
             });
         }
+        /**
+         * Reports a falsy/truthy check on a snapshot-state identifier.
+         */
+        function reportFalsyCheck(node, expression, replacement, fixNode = node) {
+            reportNarrowing('noFalsyCheck', node, expression, replacement, fixNode);
+        }
         return {
             // Track variable declarations that come from snapshot hooks.
             // Supports:
@@ -425,24 +436,33 @@ exports.enforceSnapshotStateNarrowing = (0, createRule_1.createRule)({
                     reportFalsyCheck(test, test.name, `${guardName}(${test.name})`);
                 }
             },
-            // LogicalExpression: state && expr, state || expr
+            // LogicalExpression: state && expr, state || expr, state ?? expr
             LogicalExpression(node) {
                 const left = node.left;
-                if ((node.operator === '&&' || node.operator === '||') &&
-                    left.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    isSnapshotVar(left)) {
-                    if (node.operator === '&&') {
-                        // `state && expr` guards expr, so swapping the operand for the
-                        // guard keeps both the polarity and the narrowing of `state`.
-                        reportFalsyCheck(left, left.name, `${guardName}(${left.name})`);
-                        return;
-                    }
-                    // `state || fallback` evaluates to the state itself when it is
-                    // usable, so a bare operand swap would yield `true` instead of the
-                    // data. Only the conditional form preserves that value.
-                    const guarded = `${guardName}(${left.name}) ? ${left.name} : ${getText(node.right)}`;
-                    reportFalsyCheck(left, left.name, needsParentheses(node) ? `(${guarded})` : guarded, node);
+                if (left.type !== utils_1.AST_NODE_TYPES.Identifier || !isSnapshotVar(left)) {
+                    return;
+                }
+                if (node.operator === '&&') {
+                    // `state && expr` guards expr, so swapping the operand for the
+                    // guard keeps both the polarity and the narrowing of `state`.
+                    reportFalsyCheck(left, left.name, `${guardName}(${left.name})`);
+                    return;
                 }
+                // `??` joins the `||` arm rather than the `&&` one: both are fallback
+                // forms whose left operand carries the value, so both need the same
+                // conditional rewrite. `??` is no safer than `||` on a snapshot state —
+                // every non-data member of the union is a truthy string and none is
+                // nullish, so neither operator can reach its fallback — but it fails
+                // for a different reason, so it reports under its own message.
+                const isNullishFallback = node.operator === '??';
+                // `state || fallback` evaluates to the state itself when it is
+                // usable, so a bare operand swap would yield `true` instead of the
+                // data. Only the conditional form preserves that value.
+                const guarded = `${guardName}(${left.name}) ? ${left.name} : ${getText(node.right)}`;
+                reportNarrowing(isNullishFallback ? 'noNullishFallback' : 'noFalsyCheck', left, 
+                // The nullish message turns on the whole expression being dead, so it
+                // shows the operator and the fallback it can never reach.
+                isNullishFallback ? getText(node) : left.name, needsParentheses(node) ? `(${guarded})` : guarded, node);
             },
             // BinaryExpression: typeof state === 'object', typeof state !== 'string'
             BinaryExpression(node) {

package/lib/rules/memo-nested-react-components.js

@@ -4,9 +4,21 @@ exports.memoNestedReactComponents = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const minimatch_1 = require("minimatch");
 const createRule_1 = require("../utils/createRule");
+/**
+ * Memoization hooks whose first argument this rule inspects for a nested
+ * component.
+ *
+ * `useLatestCallback` belongs here because the sibling `use-latest-callback`
+ * rule rewrites `useCallback(fn, [])` into `useLatestCallback(fn)` under
+ * `--fix`. That rewrite changes only which hook wraps the callback; the
+ * component is still constructed inline inside render scope, which is the
+ * identity churn this rule reports. Omitting the name let the sibling's fix
+ * silently disarm this rule on the very code it had just flagged (#2313).
+ */
 const CALLBACK_HOOKS = new Set([
     'useCallback',
     'useDeepCompareCallback',
+    'useLatestCallback',
     'useMemo',
     'useDeepCompareMemo',
 ]);

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

@@ -4,13 +4,33 @@ exports.noEntireObjectHookDeps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const typescript_1 = require("typescript");
-const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
+/**
+ * The hook calls whose last argument is a dependency array.
+ *
+ * why: the deep-compare family mirrors React's hooks argument-for-argument —
+ * callback first, dependency array last — so every analysis below applies to
+ * them unchanged. They are enumerated rather than matched by prefix because two
+ * fixable rules in this plugin (`prefer-use-deep-compare-memo` and
+ * `no-useless-usememo-primitives`) rewrite `useMemo` into `useDeepCompareMemo`
+ * while leaving the dependency array byte-identical; without these entries that
+ * rename would take the call out of this rule's sight. Deep comparison makes an
+ * entire-object dependency strictly WORSE, not acceptable: every render walks
+ * every property of the object rather than comparing one reference (#2309).
+ */
+const HOOK_NAMES = new Set([
+    'useEffect',
+    'useCallback',
+    'useMemo',
+    'useDeepCompareEffect',
+    'useDeepCompareCallback',
+    'useDeepCompareMemo',
+]);
 /**
  * Hooks that run for their side effects rather than producing a value. An
  * unread dependency means something different here than in useMemo/useCallback
  * — see `callsCorrespondingSetter`.
  */
-const EFFECT_HOOK_NAMES = new Set(['useEffect']);
+const EFFECT_HOOK_NAMES = new Set(['useEffect', 'useDeepCompareEffect']);
 /**
  * Hooks that do not run their callback: they hand it back as a value, so the
  * body executes only if — and when — the consumer invokes it.
@@ -20,7 +40,10 @@ const EFFECT_HOOK_NAMES = new Set(['useEffect']);
  * body dereferences is therefore not licensed to appear in the array; see
  * `collectGuardedPaths`.
  */
-const DEFERRED_BODY_HOOK_NAMES = new Set(['useCallback']);
+const DEFERRED_BODY_HOOK_NAMES = new Set([
+    'useCallback',
+    'useDeepCompareCallback',
+]);
 /**
  * A string key quoted the way a formatter quotes it.
  *

package/lib/rules/no-hungarian.js

@@ -757,6 +757,20 @@ exports.noHungarian = (0, createRule_1.createRule)({
                 }
                 const parts = variableName.split('_');
                 const lastIndex = parts.length - 1;
+                // A leading single-letter segment (B_, I_) carries the same tag as the
+                // camelCase prefix (bIsActive), so global-const-style's rename to
+                // SCREAMING_SNAKE_CASE (bIsActive -> B_IS_ACTIVE) must not disarm the
+                // rule. Gated on `parts.length > 1` (guaranteed here, since the
+                // no-underscore case already returned above) so a lone `B` — with no
+                // following segment — is left alone: there is no tagged name to catch,
+                // only an isolated identifier. Reuses SINGLE_LETTER_PREFIXES rather than
+                // hardcoding b/i so the two casings can never diverge on which letters
+                // count. Real first-word segments (TAB_INDEX, LIB_VERSION, UI_CONFIG)
+                // are untouched because they are longer than one letter.
+                if (parts.length > 1 &&
+                    SINGLE_LETTER_PREFIXES.has(parts[0].toLowerCase())) {
+                    return true;
+                }
                 return TYPE_MARKERS.some((marker) => {
                     const markerUpper = marker.toUpperCase();
                     const normalizedMarker = marker.toLowerCase();