@blumintinc/eslint-plugin-blumint 1.20.163 → 1.20.164

package/lib/index.js

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

package/lib/rules/enforce-empty-object-check.js

@@ -234,24 +234,49 @@ function isObjectLikeType(type, checker) {
     }
     return 'object';
 }
+/**
+ * Reads through an optional chain to the member access or call it holds.
+ * `Object?.keys?.(payload)?.length` parses as a single `ChainExpression`
+ * wrapping the whole chain, so a matcher written against a bare
+ * `MemberExpression` sees the wrapper and recognizes nothing.
+ *
+ * Reading through it is sound for the only question asked of it — "is an
+ * emptiness check already written here?" — because every optional link guards a
+ * nullish RECEIVER, and neither the `Object` global nor the array `Object.keys`
+ * hands back is ever nullish. The chained spelling therefore evaluates to
+ * exactly what the plain one does, making the two the same guard.
+ */
+function unwrapOptionalChain(node) {
+    let current = node;
+    while (current.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        current = current.expression;
+    }
+    return current;
+}
 function isObjectKeysLengthExpression(node, name) {
-    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-        !node.computed &&
-        node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-        node.property.name === 'length' &&
-        node.object.type === utils_1.AST_NODE_TYPES.CallExpression &&
-        node.object.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-        !node.object.callee.computed &&
-        node.object.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-        node.object.callee.object.name === 'Object' &&
-        node.object.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-        node.object.callee.property.name === 'keys' &&
-        node.object.arguments.length === 1 &&
-        node.object.arguments[0].type === utils_1.AST_NODE_TYPES.Identifier &&
-        node.object.arguments[0].name === name) {
-        return true;
+    const lengthRead = unwrapOptionalChain(node);
+    if (lengthRead.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+        lengthRead.computed ||
+        lengthRead.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+        lengthRead.property.name !== 'length') {
+        return false;
     }
-    return false;
+    const keysCall = unwrapOptionalChain(lengthRead.object);
+    if (keysCall.type !== utils_1.AST_NODE_TYPES.CallExpression ||
+        keysCall.arguments.length !== 1) {
+        return false;
+    }
+    const callee = unwrapOptionalChain(keysCall.callee);
+    if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+        callee.computed ||
+        callee.object.type !== utils_1.AST_NODE_TYPES.Identifier ||
+        callee.object.name !== 'Object' ||
+        callee.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+        callee.property.name !== 'keys') {
+        return false;
+    }
+    const argument = keysCall.arguments[0];
+    return argument.type === utils_1.AST_NODE_TYPES.Identifier && argument.name === name;
 }
 function isZeroLiteral(node) {
     return node.type === utils_1.AST_NODE_TYPES.Literal && node.value === 0;
@@ -297,8 +322,18 @@ function conditionHasEmptyCheck(node, name, emptyCheckFunctions, negationDepth =
                 return conditionHasEmptyCheck(node.argument, name, emptyCheckFunctions, negationDepth + 1);
             }
             return conditionHasEmptyCheck(node.argument, name, emptyCheckFunctions, negationDepth);
+        /**
+         * A whole optional chain arrives wrapped, so every arm below — each written
+         * against a bare member access or call — is handed a node type it does not
+         * match. Delegating to the wrapped expression at the SAME negation depth
+         * keeps the wrapper invisible, which is what lets
+         * `!Object.keys(data)?.length` and `isEmpty?.(data)` count as the emptiness
+         * checks they already are instead of being reported as missing ones.
+         */
+        case utils_1.AST_NODE_TYPES.ChainExpression:
+            return conditionHasEmptyCheck(node.expression, name, emptyCheckFunctions, negationDepth);
         case utils_1.AST_NODE_TYPES.CallExpression: {
-            const callee = node.callee;
+            const callee = unwrapOptionalChain(node.callee);
             const firstArgIsTarget = node.arguments[0] &&
                 node.arguments[0].type === utils_1.AST_NODE_TYPES.Identifier &&
                 node.arguments[0].name === name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.163",
+  "version": "1.20.164",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.164",
+    "date": "2026-08-17T22:26:37.717Z",
+    "rules": [
+      {
+        "name": "enforce-empty-object-check",
+        "changeType": "fix",
+        "issues": [
+          2034
+        ],
+        "summary": "see through optional chains (closes #2034)"
+      }
+    ]
+  },
   {
     "version": "1.20.163",
     "date": "2026-08-17T20:02:54.585Z",