@blumintinc/eslint-plugin-blumint 1.20.126 → 1.20.128

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

package/lib/rules/enforce-assert-safe-object-key.js

@@ -129,6 +129,10 @@ function isInsideMockFactory(node) {
  *
  * The peel repeats because the wrappers nest: `(x as any)!` is a non-null
  * assertion over a type assertion.
+ *
+ * Everything peeled here erases before the code runs, which is why the peel is
+ * unconditional. An optional chain does not, so it is handled apart from these
+ * — see `unwrapOptionalChain`.
  */
 function unwrapKeyExpression(node) {
     let current = node;
@@ -148,6 +152,43 @@ function unwrapKeyExpression(node) {
         }
     }
 }
+/**
+ * Reads through an optional chain to the member access or call it holds.
+ * `source?.key` parses as a `ChainExpression` wrapping the member expression,
+ * so a classification that matches a bare `MemberExpression` — or a numeric
+ * proof that matches `.length` — sees the wrapper and recognizes nothing.
+ *
+ * Kept apart from `unwrapKeyExpression` rather than folded into it because the
+ * two make different claims. Those wrappers are gone before the code runs; `?.`
+ * survives and short-circuits, so it is read through only where the question is
+ * "what value names this property", never where the question is what the
+ * expression does. That value is what the chain evaluates to, `undefined`
+ * included — and the chain guards a nullish RECEIVER, not a hostile KEY:
+ * `"__proto__"` is a perfectly non-nullish string, so `store[req.body?.key]`
+ * reaches the prototype surface exactly as `store[req.body.key]` does.
+ */
+function unwrapOptionalChain(node) {
+    return node.type === utils_1.AST_NODE_TYPES.ChainExpression ? node.expression : node;
+}
+/**
+ * The key expression stripped of every wrapper standing between it and the
+ * value that names the property: the compile-time assertions and the `await`
+ * that `unwrapKeyExpression` peels, plus an optional chain.
+ *
+ * The peel repeats because the two kinds nest in either order — `source?.key as
+ * string` is an assertion over a chain, `(source as Raw)?.key` a chain over an
+ * assertion.
+ */
+function unwrapWrittenKey(node) {
+    let current = node;
+    for (;;) {
+        const peeled = unwrapOptionalChain(unwrapKeyExpression(current));
+        if (peeled === current) {
+            return current;
+        }
+        current = peeled;
+    }
+}
 /** Names that read as a positional sequence rather than a keyed record. */
 const ARRAY_LIKE_NAME = /^(array|arr|items|elements|list|collection|data)s?$/i;
 /**
@@ -534,7 +575,8 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
             },
         });
         /**
-         * Reports a key whose written form may carry assertion or await wrappers.
+         * Reports a key whose written form may carry assertion or await wrappers or
+         * an optional chain.
          *
          * The report and the fix sit on the outermost written node, so the wrapper
          * the author put there survives the rewrite: `m[assertSafe(k as string)]`
@@ -542,7 +584,10 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
          * own. `assertSafe` is identity-typed (`<T extends PropertyKey>(key: T): T`),
          * so wrapping the asserted expression preserves the key's type, and wrapping
          * an `await` keeps the validation on the resolved key rather than moving it
-         * onto the promise.
+         * onto the promise. Wrapping the whole chain is what keeps the short-circuit
+         * intact: `m[assertSafe(source?.key)]` evaluates `source?.key` once, in the
+         * position the author wrote it, and hands assertSafe what it produces — the
+         * rewrite adds a validation, it does not move a dereference.
          *
          * A key written without a wrapper keeps the narrower argument the fix has
          * always emitted: `String(id)` and `` `${id}` `` collapse to `id`, whose
@@ -563,8 +608,11 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
             if (!variable)
                 return false;
             return variable.defs.some((def) => {
-                const init = def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator
-                    ? def.node.init
+                // `assertSafe?.(rawKey)` produces the very same validated key as
+                // `assertSafe(rawKey)` — the chain guards only a nullish callee — so
+                // the exemption reads through it rather than re-reporting the binding.
+                const init = def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator && def.node.init
+                    ? unwrapOptionalChain(def.node.init)
                     : null;
                 return (!!init &&
                     init.type === utils_1.AST_NODE_TYPES.CallExpression &&
@@ -584,8 +632,11 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
             // An assertion or an await around an operand leaves its run-time value
             // alone, so the proof reads through to what the wrapper holds. The
             // annotation on the binding underneath is what proves the key numeric —
-            // an assertion asserts and proves nothing on its own.
-            const target = unwrapKeyExpression(node);
+            // an assertion asserts and proves nothing on its own. An optional chain
+            // is read through as well: `xs?.length` is the same `.length` proof, and
+            // its short-circuit yields `undefined`, which stringifies to "undefined"
+            // and so still names no field of the prototype surface.
+            const target = unwrapWrittenKey(node);
             switch (target.type) {
                 case utils_1.AST_NODE_TYPES.Literal:
                     return typeof target.value === 'number';
@@ -662,7 +713,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
             Property(node) {
                 if (node.computed && node.key) {
                     const written = node.key;
-                    const key = unwrapKeyExpression(written);
+                    const key = unwrapWrittenKey(written);
                     // Check for String(id) pattern
                     if (key.type === utils_1.AST_NODE_TYPES.CallExpression &&
                         key.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -687,7 +738,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
             BinaryExpression(node) {
                 if (node.operator === 'in') {
                     const written = node.left;
-                    const left = unwrapKeyExpression(written);
+                    const left = unwrapWrittenKey(written);
                     // Check for String(id) pattern
                     if (left.type === utils_1.AST_NODE_TYPES.CallExpression &&
                         left.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -712,9 +763,9 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                 if (node.computed) {
                     const written = node.property;
                     // The written key may sit under assertion or await wrappers that erase
-                    // at run time; what they hold is what names the property, so that is
-                    // what the branches below classify.
-                    const property = unwrapKeyExpression(written);
+                    // at run time, or under an optional chain; what they hold is what
+                    // names the property, so that is what the branches below classify.
+                    const property = unwrapWrittenKey(written);
                     // Skip if already using assertSafe
                     if (property.type === utils_1.AST_NODE_TYPES.CallExpression &&
                         property.callee.type === utils_1.AST_NODE_TYPES.Identifier &&

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/enforce-querykey-ts.js

@@ -377,6 +377,16 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
          * Check if a node represents a valid query key usage
          */
         function isValidQueryKeyUsage(node) {
+            // `config?.getQueryKey()` parses as a `ChainExpression` wrapping the call,
+            // a type this switch does not name — so the optional spelling alone fell
+            // through to `return false` and bypassed the carve-outs below, reporting a
+            // key the plain spelling is allowed to build (#1832). Optionality is
+            // orthogonal to what this function asks: the question is where the key
+            // comes from, and a short-circuit changes only whether the same source is
+            // evaluated, never which source it is.
+            if (node.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                return isValidQueryKeyUsage(node.expression);
+            }
             if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
                 const importInfo = queryKeyImports.get(node.name);
                 if (importInfo && isQueryKeysSource(importInfo.source)) {

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 {};