@blumintinc/eslint-plugin-blumint 1.20.126 → 1.20.127

package/lib/index.js

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

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -261,26 +261,49 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, callee), 'Boolean');
             return !variable || variable.defs.length === 0;
         }
+        /**
+         * An optional link wraps the member access or call it belongs to in a
+         * `ChainExpression`, so `user?.isLoggedIn` and `canDelete?.('x')` reach a
+         * value check as a wrapper node rather than as the member/call the check
+         * looks for.
+         *
+         * Unwrapping is the right answer for THIS rule even though `a?.b` is
+         * `boolean | undefined` where `a.b` is `boolean`: the rule's remedy is a
+         * rename of the binding, which never changes how the initializer
+         * short-circuits, and the rule already requires the prefix on
+         * possibly-undefined booleans elsewhere — `deletable?: boolean` on a
+         * parameter, class property or method all report, and so does
+         * `const loggedIn = user && user.isLoggedIn`, whose type is exactly the
+         * `boolean | undefined` an optional chain produces. A value that may be
+         * absent is where an unprefixed name misleads most, because a falsy result
+         * no longer distinguishes "false" from "receiver was missing".
+         */
+        function unwrapChainExpression(expression) {
+            return expression.type === utils_1.AST_NODE_TYPES.ChainExpression
+                ? expression.expression
+                : expression;
+        }
         /**
          * Check if a node is initialized with a boolean value
          */
         function hasInitialBooleanValue(node) {
             if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator && node.init) {
+                const init = unwrapChainExpression(node.init);
                 // Check for direct boolean literal initialization
-                if (node.init.type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof node.init.value === 'boolean') {
+                if (init.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof init.value === 'boolean') {
                     return true;
                 }
                 // Check for logical expressions that typically return boolean
-                if (node.init.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
-                    BOOLEANISH_BINARY_OPERATORS.has(node.init.operator)) {
+                if (init.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+                    BOOLEANISH_BINARY_OPERATORS.has(init.operator)) {
                     return true;
                 }
                 // Check for logical expressions (&&)
-                if (node.init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
-                    node.init.operator === '&&') {
-                    const left = evaluateBooleanishExpression(node.init.left);
-                    const right = evaluateBooleanishExpression(node.init.right);
+                if (init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                    init.operator === '&&') {
+                    const left = evaluateBooleanishExpression(init.left);
+                    const right = evaluateBooleanishExpression(init.right);
                     // If both sides are boolean, the result is boolean.
                     if (left === 'boolean' && right === 'boolean') {
                         return true;
@@ -297,10 +320,10 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 // Special case for logical OR (||) - only consider it boolean if:
                 // 1. It's used with boolean literals or
                 // 2. It's not used with array/object literals as fallbacks
-                if (node.init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
-                    node.init.operator === '||') {
+                if (init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                    init.operator === '||') {
                     // Check if right side is a non-boolean literal (array, object, string, number)
-                    const rightSide = node.init.right;
+                    const rightSide = init.right;
                     if (rightSide.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
                         rightSide.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
                         (rightSide.type === utils_1.AST_NODE_TYPES.Literal &&
@@ -314,7 +337,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     }
                     // For other cases, we need to be more careful
                     // If we can determine the left side is a boolean, then it's a boolean variable
-                    const leftSide = node.init.left;
+                    const leftSide = unwrapChainExpression(init.left);
                     if ((leftSide.type === utils_1.AST_NODE_TYPES.Literal &&
                         typeof leftSide.value === 'boolean') ||
                         (leftSide.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
@@ -336,20 +359,20 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     return false;
                 }
                 // Check for unary expressions with ! operator
-                if (node.init.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
-                    node.init.operator === '!') {
+                if (init.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                    init.operator === '!') {
                     return true;
                 }
                 // Check for function calls that might return boolean
-                if (node.init.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                    node.init.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                if (init.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    init.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
                     // A coercion through the global `Boolean` is as definitive as `!!x`,
                     // and its callee carries no approved prefix for the name heuristic
                     // below to recognize.
-                    if (isGlobalBooleanCall(node.init)) {
+                    if (isGlobalBooleanCall(init)) {
                         return true;
                     }
-                    const calleeName = node.init.callee.name;
+                    const calleeName = init.callee.name;
                     const lowerCallee = calleeName.toLowerCase();
                     // For assert*-style utilities, only treat as boolean if we can confirm boolean return type
                     if (lowerCallee.startsWith('assert')) {
@@ -1110,7 +1133,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             const variableDeclarator = node.parent;
             if (variableDeclarator?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
                 variableDeclarator.init) {
-                const init = variableDeclarator.init;
+                const init = unwrapChainExpression(variableDeclarator.init);
                 // Check for direct boolean initialization
                 if (init.type === utils_1.AST_NODE_TYPES.Literal &&
                     typeof init.value === 'boolean') {

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -39,6 +39,22 @@ const referenceTypeNameOf = (typeName) => {
     }
     return undefined;
 };
+/**
+ * The expression an optional link wraps, so a receiver spelled with `?.` is
+ * read as the expression it actually evaluates.
+ *
+ * `a?.b` interposes a `ChainExpression` between the member/call and its real
+ * parent. That link perturbs nullability, not the document schema:
+ * `db?.collection<T>('x')` has type `CollectionReference<T> | undefined`, whose
+ * schema is still `T`, never `DocumentData`. Leaving the wrapper in place makes
+ * a typed collection look unrecognizable, and the `.doc()` that inherits its
+ * schema draws a missing-generic report whose only remedy — `doc<T>(...)` —
+ * does not compile, since `CollectionReference<T>.doc` declares no type
+ * parameters.
+ */
+function unwrapOptionalChain(node) {
+    return node.type === utils_1.AST_NODE_TYPES.ChainExpression ? node.expression : node;
+}
 /**
  * The type declaration a statement makes, looking through `export`.
  *
@@ -344,9 +360,10 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
             return false;
         }
         const isTypedCollectionReferenceCache = new Map();
-        function isTypedCollectionReference(node) {
-            if (!node)
+        function isTypedCollectionReference(receiver) {
+            if (!receiver)
                 return false;
+            const node = unwrapOptionalChain(receiver);
             if (isTypedCollectionReferenceCache.has(node)) {
                 return isTypedCollectionReferenceCache.get(node);
             }
@@ -511,10 +528,11 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
             }
             return isTypedCollectionInitializer(declarator.init);
         }
-        function isTypedCollectionInitializer(init) {
-            if (!init) {
+        function isTypedCollectionInitializer(initializer) {
+            if (!initializer) {
                 return false;
             }
+            const init = unwrapOptionalChain(initializer);
             // An explicit assertion states the schema just as an annotation does.
             if (init.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
                 return hasCollectionReferenceType(init.typeAnnotation);

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

@@ -193,9 +193,37 @@ function isPrimitiveLiteral(node) {
         typeof value === 'boolean' ||
         typeof value === 'bigint');
 }
-/** Whether a declarator is initialized from a `<x>.firestore()` call. */
+/**
+ * Strips the wrappers that leave an expression's shape intact, assertions plus
+ * the `ChainExpression` an optional link parks on the outermost node of a chain.
+ *
+ * The two are kept apart rather than merged into `unwrapAssertions` because a
+ * chain is not erased at runtime: `admin?.firestore()` evaluates to the handle
+ * or to `undefined`, so a caller reasoning about the *value* an expression
+ * produces — `isPrimitiveLiteral` — must keep seeing the chain. A caller
+ * reasoning about the *shape* it is written in, which is what the evidence scan
+ * asks, must look through it: the optional link decides whether the handle is
+ * produced, never which instance it is.
+ */
+function unwrapTransparent(node) {
+    const stripped = unwrapAssertions(node);
+    return stripped.type === utils_1.AST_NODE_TYPES.ChainExpression
+        ? unwrapTransparent(stripped.expression)
+        : stripped;
+}
+/**
+ * Whether a declarator is initialized from a `<x>.firestore()` call.
+ *
+ * Both optional spellings — `admin?.firestore()` and `admin.firestore?.()` —
+ * parse as `ChainExpression > CallExpression`, so testing the initializer's own
+ * type read `ChainExpression` and answered no. Since this scan is the last
+ * detector left for a bare-identifier receiver, that miss dropped the report
+ * silently, and it hit the more careful spellings hardest: `admin.apps[0]?.
+ * firestore()` and `admin.app()?.firestore()` are the idiomatic admin-SDK
+ * singleton bootstrap, not exotic code.
+ */
 function initializesFirestore(declarator) {
-    const { init } = declarator;
+    const init = declarator.init ? unwrapTransparent(declarator.init) : null;
     return (init?.type === utils_1.AST_NODE_TYPES.CallExpression &&
         init.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
         init.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&

package/lib/rules/fast-deep-equal-over-microdiff.js

@@ -66,6 +66,17 @@ function bindsFastDeepEqual(variable) {
                 fastDeepEqualModules_1.FAST_DEEP_EQUAL_MODULES.has(String(declaration.source.value)));
         }));
 }
+/**
+ * The expression an optional chain wraps. ESTree interposes a
+ * `ChainExpression` between an optional member/call and its real parent, so
+ * `changes?.length` reaches an operand test as a ChainExpression while
+ * `changes.length` reaches it as a MemberExpression. Every arm that inspects an
+ * operand has to unwrap first, or one spelling of a single idiom escapes the
+ * rule while the other is reported.
+ */
+function unwrapChain(node) {
+    return node.type === utils_1.AST_NODE_TYPES.ChainExpression ? node.expression : node;
+}
 /**
  * Whether two edits touch the same characters. ESLint sorts the fixes of one
  * report and asserts each starts at or after the end of the previous one, so
@@ -107,7 +118,6 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
          * violations still emit `isEqual(...)` calls, leaving them unbound.
          */
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
-        const isChainExpression = (node) => node.type === utils_1.AST_NODE_TYPES.ChainExpression;
         function isMicrodiffCallee(callee) {
             if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                 callee.name === microdiffImportName) {
@@ -265,11 +275,16 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
                     '!=',
                 ];
                 if (operators.includes(node.operator)) {
+                    // `diff(a, b)?.length`, `changes?.length` and `diff?.(a, b).length`
+                    // each reach the operand as a ChainExpression, so the unwrap is what
+                    // keeps the comparison spellings of one idiom from diverging.
+                    const left = unwrapChain(node.left);
+                    const right = unwrapChain(node.right);
                     // side A: MemberExpression .length, side B: 0
-                    if (node.right.type === utils_1.AST_NODE_TYPES.Literal &&
-                        node.right.value === 0 &&
-                        node.left.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                        const { diffCall } = getMicrodiffCallFromLengthAccess(node.left);
+                    if (right.type === utils_1.AST_NODE_TYPES.Literal &&
+                        right.value === 0 &&
+                        left.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        const { diffCall } = getMicrodiffCallFromLengthAccess(left);
                         if (diffCall) {
                             return {
                                 isEquality: node.operator === '===' || node.operator === '==',
@@ -278,10 +293,10 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
                         }
                     }
                     // side A: 0, side B: MemberExpression .length
-                    if (node.left.type === utils_1.AST_NODE_TYPES.Literal &&
-                        node.left.value === 0 &&
-                        node.right.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                        const { diffCall } = getMicrodiffCallFromLengthAccess(node.right);
+                    if (left.type === utils_1.AST_NODE_TYPES.Literal &&
+                        left.value === 0 &&
+                        right.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        const { diffCall } = getMicrodiffCallFromLengthAccess(right);
                         if (diffCall) {
                             return {
                                 isEquality: node.operator === '===' || node.operator === '==',
@@ -294,10 +309,7 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
             // Check for unary expressions like !diff(a, b).length or !changes.length (including optional chaining)
             if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
                 node.operator === '!') {
-                const argumentNode = node.argument;
-                const target = isChainExpression(argumentNode)
-                    ? argumentNode.expression
-                    : argumentNode;
+                const target = unwrapChain(node.argument);
                 if (target.type === utils_1.AST_NODE_TYPES.MemberExpression) {
                     const { diffCall } = getMicrodiffCallFromLengthAccess(target);
                     if (diffCall) {
@@ -315,13 +327,18 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
          * Try to find the identifier used as `<id>.length` for the given equality node
          */
         function getLengthIdentifierFromNode(node) {
+            // The operands are unwrapped for the same reason the detection arm
+            // unwraps them: `changes?.length` hides the identifier behind a
+            // ChainExpression. Missing it here does not silence the report — it
+            // rewrites the comparison and leaves the now-dead
+            // `const changes = diff(a, b);` behind.
+            const isLengthMember = (n) => n.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !n.computed &&
+                n.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                n.property.name === 'length';
             if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
-                const left = node.left;
-                const right = node.right;
-                const isLengthMember = (n) => n.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                    !n.computed &&
-                    n.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    n.property.name === 'length';
+                const left = unwrapChain(node.left);
+                const right = unwrapChain(node.right);
                 if (isLengthMember(left) &&
                     left.object.type === utils_1.AST_NODE_TYPES.Identifier) {
                     return left.object;
@@ -332,11 +349,8 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
                 }
             }
             if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
-                const arg = node.argument;
-                if (arg.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                    !arg.computed &&
-                    arg.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    arg.property.name === 'length' &&
+                const arg = unwrapChain(node.argument);
+                if (isLengthMember(arg) &&
                     arg.object.type === utils_1.AST_NODE_TYPES.Identifier) {
                     return arg.object;
                 }

package/lib/rules/no-direct-function-state.d.ts

@@ -4,5 +4,6 @@ type Options = [
         functionPatterns?: string[];
     }
 ];
-export declare const noDirectFunctionState: TSESLint.RuleModule<"noDirectFunctionState", Options, TSESLint.RuleListener>;
+type MessageIds = 'noDirectFunctionState' | 'noDirectFunctionStateAssertion';
+export declare const noDirectFunctionState: TSESLint.RuleModule<MessageIds, Options, TSESLint.RuleListener>;
 export {};

package/lib/rules/no-direct-function-state.js

@@ -104,13 +104,68 @@ function useStateHasFunctionTypeParam(callNode, resolveFrom) {
     }
     return isFunctionTypeAnnotation(typeParams.params[0], resolveFrom);
 }
+/**
+ * The expression a runtime-transparent wrapper stands in for.
+ *
+ * `a?.b` parses as a `ChainExpression` around the member read, and `x as T`,
+ * `<T>x`, `x satisfies T`, `x!` and `fn<T>` each wrap their operand in a node
+ * that is erased before execution. Every one of them evaluates to exactly what
+ * its operand evaluates to, so a question about what a setter argument *is* has
+ * to be asked of the operand — asking the wrapper answers about the wrapper and
+ * silently loses the argument, in whichever direction the caller's default
+ * happens to point.
+ *
+ * Recursive because the wrappers stack: `props?.onClose as any` is a
+ * `TSAsExpression` over a `ChainExpression` over the member read.
+ */
+function unwrapTransparent(node) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.ChainExpression:
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+        case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+        case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+        case utils_1.AST_NODE_TYPES.TSInstantiationExpression:
+            return unwrapTransparent(node.expression);
+        default:
+            return node;
+    }
+}
+/**
+ * Whether wrapping this argument in a thunk would leave an arrow whose body is
+ * a type assertion.
+ *
+ * `no-type-assertion-returns` is `error` in the same recommended config and
+ * reports exactly that shape, so emitting `setX(() => props.onClose as any)`
+ * would trade one error for another and leave `eslint --fix` non-converging.
+ * Moving the assertion outside the thunk instead — `(() => x) as T` — is not an
+ * option either: it asserts a different value, and for a `T` that is neither
+ * assignable to nor from `() => T` it does not even compile. So the report
+ * stands without a fix and names the hoist that does converge (verified end to
+ * end under the whole recommended config).
+ *
+ * Only a top-level assertion matters. An assertion nested inside the argument
+ * (`(props as any).onClose`) leaves the thunk returning a member read, which
+ * that rule exempts.
+ */
+function thunkWouldReturnAssertion(arg) {
+    return (arg.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        arg.type === utils_1.AST_NODE_TYPES.TSTypeAssertion);
+}
 /**
  * Returns true when the AST node is a safe value to pass to a setter — i.e.,
  * NOT a bare identifier or member expression that could be a function reference.
  * Arrow/function expressions are always safe (they are intentional).
  * Literals, null, undefined, call expressions, arrays, objects are all safe.
+ *
+ * The argument is unwrapped first so the carve-outs below are decided by what
+ * actually reaches the setter. Without it a wrapped argument falls to the
+ * `default` arm, which is the *unsafe* verdict — so `factory?.build()` would
+ * lose the deliberate CallExpression exemption and be rewritten into
+ * `() => factory?.build()`, deferring the call into a React updater.
  */
-function isDefinitelySafeArg(node) {
+function isDefinitelySafeArg(argNode) {
+    const node = unwrapTransparent(argNode);
     switch (node.type) {
         case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
         case utils_1.AST_NODE_TYPES.FunctionExpression:
@@ -137,11 +192,6 @@ function isDefinitelySafeArg(node) {
         case utils_1.AST_NODE_TYPES.ArrayExpression:
         case utils_1.AST_NODE_TYPES.ObjectExpression:
             return true;
-        case utils_1.AST_NODE_TYPES.TSAsExpression:
-        case utils_1.AST_NODE_TYPES.TSTypeAssertion:
-        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
-            // Unwrap type assertions and recurse
-            return isDefinitelySafeArg(node.expression);
         default:
             // MemberExpression, Identifier (non-undefined), etc. are NOT definitely safe
             return false;
@@ -169,8 +219,14 @@ function matchesFunctionPattern(name, patterns) {
  * Extracts the identifier name from an argument node for pattern matching.
  * For MemberExpression like `obj.handler`, returns `handler`.
  * For Identifier like `myCallback`, returns `myCallback`.
+ *
+ * The argument is unwrapped first: `props?.onClose` and `props.onClose as any`
+ * name the same property as `props.onClose`. Under an untyped `useState` the
+ * name pattern is the only live signal, so returning `null` for a wrapped
+ * argument silences the rule entirely rather than merely weakening it.
  */
-function getArgName(node) {
+function getArgName(argNode) {
+    const node = unwrapTransparent(argNode);
     if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
         return node.name;
     }
@@ -236,6 +292,10 @@ exports.noDirectFunctionState = (0, createRule_1.createRule)({
             noDirectFunctionState: 'What\'s wrong: "{{argText}}" is passed directly to "{{setterName}}", but React invokes a function argument as a functional updater (prev => next) instead of storing it. ' +
                 'Why it matters: The function will be called with the previous state value and its return value stored — a silent bug with no error. ' +
                 'How to fix: Wrap it in a thunk so React stores the function as a value: {{setterName}}(() => {{argText}})',
+            noDirectFunctionStateAssertion: 'What\'s wrong: "{{argText}}" is passed directly to "{{setterName}}", but React invokes a function argument as a functional updater (prev => next) instead of storing it. ' +
+                'Why it matters: The function will be called with the previous state value and its return value stored — a silent bug with no error. ' +
+                'How to fix: Give the asserted value a name, then store that name through a thunk: const value = {{argText}}; {{setterName}}(() => value). ' +
+                'The assertion is hoisted out because a thunk that returned it would be an arrow returning a cast, which no-type-assertion-returns reports.',
         },
     },
     defaultOptions: [{ functionPatterns: DEFAULT_FUNCTION_PATTERNS }],
@@ -252,12 +312,18 @@ exports.noDirectFunctionState = (0, createRule_1.createRule)({
             VariableDeclarator(node) {
                 // Look for `const [state, setter] = useState<T>(...)` or
                 // `const [state, setter] = React.useState<T>(...)`.
-                if (node.id.type !== utils_1.AST_NODE_TYPES.ArrayPattern ||
-                    !node.init ||
-                    node.init.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                if (node.id.type !== utils_1.AST_NODE_TYPES.ArrayPattern || !node.init) {
                     return;
                 }
-                const callNode = node.init;
+                // `React?.useState(...)` and `useState?.(...)` wrap the call in a
+                // ChainExpression. Reading `init` without unwrapping registers no
+                // setter, which blinds every setter call in the file rather than just
+                // this declaration.
+                const init = unwrapTransparent(node.init);
+                if (init.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                    return;
+                }
+                const callNode = init;
                 const callee = callNode.callee;
                 const isUseStateCall = (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                     callee.name === 'useState') ||
@@ -304,7 +370,8 @@ exports.noDirectFunctionState = (0, createRule_1.createRule)({
                 // skip without further checks
                 if (isDefinitelySafeArg(arg))
                     return;
-                // At this point arg is an Identifier (non-undefined) or MemberExpression.
+                // At this point arg is an Identifier (non-undefined) or MemberExpression,
+                // possibly behind transparent wrappers (`?.`, `as`, `!`).
                 // Decide whether it is a function reference.
                 const isFunctionTypedState = setterFunctionTyped.get(setterName) === true;
                 if (isFunctionTypedState) {
@@ -320,11 +387,14 @@ exports.noDirectFunctionState = (0, createRule_1.createRule)({
                     reportAndFix(node, arg, setterName, context);
                     return;
                 }
-                // Check if the identifier is bound to a function in scope
-                if (arg.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    arg.name !== 'undefined') {
+                // Check if the identifier is bound to a function in scope. This reads
+                // the same argument the two signals above do, so it has to see through
+                // the same wrappers: `myCallback!` still references `myCallback`.
+                const unwrappedArg = unwrapTransparent(arg);
+                if (unwrappedArg.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    unwrappedArg.name !== 'undefined') {
                     const scope = context.getScope();
-                    if (isIdentifierBoundToFunction(arg.name, scope)) {
+                    if (isIdentifierBoundToFunction(unwrappedArg.name, scope)) {
                         reportAndFix(node, arg, setterName, context);
                         return;
                     }
@@ -336,14 +406,20 @@ exports.noDirectFunctionState = (0, createRule_1.createRule)({
 function reportAndFix(callNode, arg, setterName, context) {
     const sourceCode = context.getSourceCode();
     const argText = sourceCode.getText(arg);
+    const returnsAssertion = thunkWouldReturnAssertion(arg);
     context.report({
         node: callNode,
-        messageId: 'noDirectFunctionState',
+        messageId: returnsAssertion
+            ? 'noDirectFunctionStateAssertion'
+            : 'noDirectFunctionState',
         data: {
             argText,
             setterName,
         },
         fix(fixer) {
+            if (returnsAssertion) {
+                return null;
+            }
             return fixer.replaceText(arg, `() => ${argText}`);
         },
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.126",
+  "version": "1.20.127",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",
@@ -72,6 +72,7 @@
     "@semantic-release/release-notes-generator": "14.1.0",
     "@types/eslint": "8.37.0",
     "@types/jest": "29.5.14",
+    "@types/js-yaml": "4.0.9",
     "@types/node": "22.20.0",
     "@types/semver": "7.5.8",
     "@typescript-eslint/eslint-plugin": "5.34.0",
@@ -96,6 +97,7 @@
     "husky": "9.1.7",
     "jest": "29.7.0",
     "jest-junit": "14.0.0",
+    "js-yaml": "4.3.1",
     "jsonc-eslint-parser": "2.3.0",
     "markdown-eslint-parser": "1.2.1",
     "npm-run-all": "4.1.5",

package/release-manifest.json

@@ -1,4 +1,50 @@
 [
+  {
+    "version": "1.20.127",
+    "date": "2026-08-07T02:31:31.437Z",
+    "rules": [
+      {
+        "name": "enforce-boolean-naming-prefixes",
+        "changeType": "fix",
+        "issues": [
+          1828
+        ],
+        "summary": "read an optional-chained initializer as boolean (closes #1828)"
+      },
+      {
+        "name": "enforce-firestore-doc-ref-generic",
+        "changeType": "fix",
+        "issues": [
+          1826
+        ],
+        "summary": "resolve a typed collection through an optional link (closes #1826)"
+      },
+      {
+        "name": "enforce-firestore-set-merge",
+        "changeType": "fix",
+        "issues": [
+          1827
+        ],
+        "summary": "see a Firestore handle through an optional link (closes #1827)"
+      },
+      {
+        "name": "fast-deep-equal-over-microdiff",
+        "changeType": "fix",
+        "issues": [
+          1825
+        ],
+        "summary": "unwrap ChainExpression in the binary comparison arm (closes #1825)"
+      },
+      {
+        "name": "no-direct-function-state",
+        "changeType": "fix",
+        "issues": [
+          1824
+        ],
+        "summary": "read the setter argument through transparent wrappers (closes #1824)"
+      }
+    ]
+  },
   {
     "version": "1.20.126",
     "date": "2026-08-06T22:42:22.372Z",