@blumintinc/eslint-plugin-blumint 1.20.128 → 1.20.129

package/lib/index.js

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

package/lib/rules/no-circular-references.js

@@ -37,6 +37,28 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
                 ? current
                 : null;
         }
+        /**
+         * The expression a runtime-transparent wrapper stands in for.
+         *
+         * `a?.b` parses as a `ChainExpression` around the member read, and
+         * resolution has to see through it: the optional link records that the
+         * access short-circuits, not that it names something else. Whenever the
+         * receiver is non-nullish — and an object literal bound to a `const` always
+         * is — `cfg?.node` evaluates to exactly `cfg.node`, so it aliases the same
+         * object and belongs to the same cycle. Stopping at the wrapper drops the
+         * alias, and a real cycle goes unreported.
+         *
+         * Local rather than folded into `ASTHelpers.unwrapTSAssertions`, because
+         * that helper answers "which assertions restate this expression" for five
+         * other rules, and a chain is a different question for each of them.
+         */
+        function unwrapTransparent(node) {
+            let current = ASTHelpers_1.ASTHelpers.unwrapTSAssertions(node);
+            while (current.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                current = ASTHelpers_1.ASTHelpers.unwrapTSAssertions(current.expression);
+            }
+            return current;
+        }
         function isIdentifier(node) {
             return node.type === utils_1.AST_NODE_TYPES.Identifier;
         }
@@ -66,7 +88,7 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
             return null;
         }
         function getReferencedObject(node, visitedVariables = new Set(), visitedNodes = new Set()) {
-            const current = ASTHelpers_1.ASTHelpers.unwrapTSAssertions(node);
+            const current = unwrapTransparent(node);
             if (visitedNodes.has(current))
                 return null;
             visitedNodes.add(current);
@@ -129,14 +151,19 @@ exports.noCircularReferences = (0, createRule_1.createRule)({
                         }
                     }
                     if (propValue) {
-                        const unwrappedValue = getUnwrappedObjectOrArray(propValue);
+                        // The stored value keeps whatever notation it was written with, so
+                        // the dispatch below asks its question of the expression that
+                        // notation stands for — `{ b: level1?.a }` reaches here as a
+                        // ChainExpression and would otherwise match no arm at all.
+                        const resolvedValue = unwrapTransparent(propValue);
+                        const unwrappedValue = getUnwrappedObjectOrArray(resolvedValue);
                         if (unwrappedValue)
                             return unwrappedValue;
-                        if (isIdentifier(propValue) ||
-                            propValue.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                            return getReferencedObject(propValue, visitedVariables, visitedNodes);
+                        if (isIdentifier(resolvedValue) ||
+                            resolvedValue.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                            return getReferencedObject(resolvedValue, visitedVariables, visitedNodes);
                         }
-                        if (isFunction(propValue) || isPrimitive(propValue)) {
+                        if (isFunction(resolvedValue) || isPrimitive(resolvedValue)) {
                             return null;
                         }
                     }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.129",
+    "date": "2026-08-07T06:47:26.731Z",
+    "rules": [
+      {
+        "name": "no-circular-references",
+        "changeType": "fix",
+        "issues": [
+          1838
+        ],
+        "summary": "resolve an alias through an optional chain (closes #1838)"
+      }
+    ]
+  },
   {
     "version": "1.20.128",
     "date": "2026-08-07T05:47:06.312Z",