@blumintinc/eslint-plugin-blumint 1.20.134 → 1.20.136

package/lib/rules/enforce-props-naming-consistency.js

@@ -42,6 +42,33 @@ const getEnclosingClass = (node) => {
  * cannot be resolved through scope analysis, the fix is withheld whenever the
  * name occurs anywhere in the class other than at its declaration.
  */
+/**
+ * The member name a `this.<x>` access reads, whatever its spelling.
+ *
+ * Keying the check on the dot spelling alone left `this['settings']` invisible,
+ * so the rename shipped and stranded it — the class no longer had the member the
+ * getter reads (#1882, the sibling of #1881). A computed access with a static
+ * string is the SAME member as the dot form, and the fixer cannot rewrite it
+ * either, so it has to count. `null` marks a genuinely dynamic key, which names
+ * no member statically and therefore strands nothing.
+ */
+const staticMemberName = (node) => {
+    if (!node.computed) {
+        return node.property.type === utils_1.AST_NODE_TYPES.Identifier
+            ? node.property.name
+            : null;
+    }
+    if (node.property.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof node.property.value === 'string') {
+        return node.property.value;
+    }
+    if (node.property.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.property.expressions.length === 0 &&
+        node.property.quasis.length === 1) {
+        return node.property.quasis[0].value.cooked;
+    }
+    return null;
+};
 const parameterPropertyRenameIsUnsafe = (classNode, name, declarationId) => {
     let unsafe = false;
     const visit = (node) => {
@@ -50,8 +77,7 @@ const parameterPropertyRenameIsUnsafe = (classNode, name, declarationId) => {
         }
         if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
             node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
-            node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-            node.property.name === name) {
+            staticMemberName(node) === name) {
             unsafe = true;
             return;
         }

package/lib/rules/no-inline-component-prop.js

@@ -414,17 +414,20 @@ exports.noInlineComponentProp = (0, createRule_1.createRule)({
             if (!definition)
                 return;
             const defNode = definition.node;
-            if (!defNode ||
-                defNode.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
-                !defNode.init ||
-                defNode.init.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+            if (!defNode || defNode.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                return;
+            }
+            // `global-const-style` autofixes a module-scope object literal to
+            // `as const`, so reading `init` raw lets one fixer silence this rule.
+            const holder = unwrapExpression(defNode.init);
+            if (!holder || holder.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
                 return;
             }
             if (resolvedOptions.allowModuleScopeFactories &&
                 isStableForConsumer(defNode, consumerFunction)) {
                 return;
             }
-            const fnNode = findObjectPropertyFunction(defNode.init, member.property.name);
+            const fnNode = findObjectPropertyFunction(holder, member.property.name);
             if (fnNode &&
                 isComponentLikeFunction(fnNode, context, member.property.name)) {
                 report(member, propName, member.property.name);

package/lib/rules/no-object-values-on-strings.js

@@ -68,18 +68,33 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
                 node.callee.property.name === 'values' &&
                 node.arguments.length > 0);
         }
+        /**
+         * `a?.b()` parses as a ChainExpression wrapping the call. The wrapper is
+         * ESTree-only, so it has no TypeScript node: leaving it in place defeats
+         * both the syntactic tests below and `getTypeAtLocation`, and a nullable
+         * receiver is exactly where `?.` gets written.
+         */
+        function unwrapChain(node) {
+            let current = node;
+            while (current.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                current = current.expression;
+            }
+            return current;
+        }
         /**
          * Checks if a node is a string literal or template literal
          */
         function isStringLiteral(node) {
-            return ((node.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof node.value === 'string') ||
-                node.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
+            const inner = unwrapChain(node);
+            return ((inner.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof inner.value === 'string') ||
+                inner.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
         }
         /**
          * Checks if a node is likely to produce a string value based on AST patterns
          */
-        function isLikelyStringExpression(node) {
+        function isLikelyStringExpression(maybeChained) {
+            const node = unwrapChain(maybeChained);
             // Check for string concatenation
             if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
                 node.operator === '+' &&
@@ -190,8 +205,10 @@ exports.noObjectValuesOnStrings = (0, createRule_1.createRule)({
             CallExpression(node) {
                 // Check if the call is Object.values()
                 if (isObjectValuesCall(node)) {
-                    const argument = node.arguments[0];
-                    const argumentText = sourceCode.getText(argument);
+                    // The message quotes what the author wrote, so text comes from the
+                    // original node while every test below reads through the chain.
+                    const argumentText = sourceCode.getText(node.arguments[0]);
+                    const argument = unwrapChain(node.arguments[0]);
                     // Quick check for string literals and template literals
                     if (isStringLiteral(argument)) {
                         context.report({

package/lib/rules/no-passthrough-getters.js

@@ -421,8 +421,16 @@ exports.noPassthroughGetters = (0, createRule_1.createRule)({
             if (node.type === 'ConditionalExpression') {
                 return true;
             }
-            // Check for optional chaining like this.settings?.property
-            if (node.type === 'MemberExpression' && node.optional) {
+            // Check for optional chaining like this.settings?.property. `a?.b` parses
+            // as a ChainExpression wrapping the member access, so the wrapper has to
+            // be stripped here or this arm never fires — the shape stays silent only
+            // because the member walker cannot follow it, which would reverse the
+            // moment that walker learns to.
+            let unchained = node;
+            while (unchained.type === 'ChainExpression') {
+                unchained = unchained.expression;
+            }
+            if (unchained.type === 'MemberExpression' && unchained.optional) {
                 return true;
             }
             // The nullish coalescing check is already covered by the LogicalExpression check above