@blumintinc/eslint-plugin-blumint 1.12.0 → 1.12.2

package/lib/index.js

@@ -106,7 +106,7 @@ const enforce_boolean_naming_prefixes_1 = require("./rules/enforce-boolean-namin
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.12.0',
+        version: '1.12.2',
     },
     parseOptions: {
         ecmaVersion: 2020,

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

@@ -119,11 +119,86 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     ['===', '!==', '==', '!=', '>', '<', '>=', '<='].includes(node.init.operator)) {
                     return true;
                 }
-                // Check for logical expressions (&&, ||)
+                // Check for logical expressions (&&)
                 if (node.init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
-                    ['&&', '||'].includes(node.init.operator)) {
+                    node.init.operator === '&&') {
+                    // Check if the right side is a method call that might return a non-boolean value
+                    const rightSide = node.init.right;
+                    if (rightSide.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                        // If the method name doesn't suggest it returns a boolean, don't flag it
+                        if (rightSide.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                            rightSide.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const methodName = rightSide.callee.property.name;
+                            // Check if the method name suggests it returns a boolean
+                            const isBooleanMethod = approvedPrefixes.some((prefix) => methodName.toLowerCase().startsWith(prefix.toLowerCase()));
+                            // If the method name suggests it returns a boolean (starts with a boolean prefix or contains 'boolean' or 'enabled'),
+                            // then the variable should be treated as a boolean
+                            if (isBooleanMethod ||
+                                methodName.toLowerCase().includes('boolean') ||
+                                methodName.toLowerCase().includes('enabled') ||
+                                methodName.toLowerCase().includes('auth') ||
+                                methodName.toLowerCase().includes('valid') ||
+                                methodName.toLowerCase().includes('check')) {
+                                return true;
+                            }
+                            // For methods like getVolume(), getData(), etc., assume they return non-boolean values
+                            if (methodName.toLowerCase().startsWith('get') ||
+                                methodName.toLowerCase().startsWith('fetch') ||
+                                methodName.toLowerCase().startsWith('retrieve') ||
+                                methodName.toLowerCase().startsWith('load') ||
+                                methodName.toLowerCase().startsWith('read')) {
+                                return false;
+                            }
+                        }
+                    }
+                    // For property access like user.isAuthenticated, treat as boolean
+                    if (rightSide.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        rightSide.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const propertyName = rightSide.property.name;
+                        const isBooleanProperty = approvedPrefixes.some((prefix) => propertyName.toLowerCase().startsWith(prefix.toLowerCase()));
+                        if (isBooleanProperty) {
+                            return true;
+                        }
+                    }
+                    // Default to true for other cases with && to avoid false negatives
                     return true;
                 }
+                // 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 === '||') {
+                    // Check if right side is a non-boolean literal (array, object, string, number)
+                    const rightSide = node.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 &&
+                            typeof rightSide.value !== 'boolean')) {
+                        return false;
+                    }
+                    // If right side is a boolean literal, it's likely a boolean variable
+                    if (rightSide.type === utils_1.AST_NODE_TYPES.Literal &&
+                        typeof rightSide.value === 'boolean') {
+                        return true;
+                    }
+                    // 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;
+                    if ((leftSide.type === utils_1.AST_NODE_TYPES.Literal &&
+                        typeof leftSide.value === 'boolean') ||
+                        (leftSide.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                            leftSide.operator === '!')) {
+                        return true;
+                    }
+                    // For function calls, check if the function name suggests it returns a boolean
+                    if (leftSide.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        leftSide.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const calleeName = leftSide.callee.name;
+                        return approvedPrefixes.some((prefix) => calleeName.toLowerCase().startsWith(prefix.toLowerCase()));
+                    }
+                    // Default to false for other cases with || to avoid false positives
+                    return false;
+                }
                 // Check for unary expressions with ! operator
                 if (node.init.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
                     node.init.operator === '!') {

package/lib/rules/enforce-positive-naming.js

@@ -930,9 +930,12 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             // Split the name into words
             const words = splitNameIntoWords(name);
             // Check if this follows the pattern IS_NOT_SOMETHING or HAS_NO_SOMETHING
-            const secondWord = words[1].toLowerCase();
-            if (EXCEPTION_WORDS.some((exception) => secondWord === exception.toLowerCase())) {
-                return { isNegative: false, alternatives: [] };
+            // Make sure words[1] exists before trying to access it
+            if (words.length > 1) {
+                const secondWord = words[1].toLowerCase();
+                if (EXCEPTION_WORDS.some((exception) => secondWord === exception.toLowerCase())) {
+                    return { isNegative: false, alternatives: [] };
+                }
             }
             const nameLowercase = name.toLowerCase();
             // Check for negative prefixes in boolean-like variables

package/lib/rules/no-compositing-layer-props.js

@@ -37,7 +37,7 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Warn when using CSS properties that trigger compositing layers, which can impact performance. Properties like transform, opacity, filter, and will-change create new GPU layers. While sometimes beneficial for animations, excessive layer creation can increase memory usage and hurt performance. Consider alternatives or explicitly document intentional layer promotion.',
+            description: 'Warn when using CSS properties that trigger compositing layers, which can impact performance. Properties like transform, opacity, filter, and will-change create new GPU layers. While sometimes beneficial for animations, excessive layer creation can increase memory usage and hurt performance. This rule checks both regular style objects and MUI sx props. Consider alternatives or explicitly document intentional layer promotion.',
             recommended: 'error',
         },
         schema: [],
@@ -79,7 +79,7 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
                 // Check for JSX style attribute
                 if (current.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute &&
                     current.parent.name.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
-                    current.parent.name.name === 'style') {
+                    (current.parent.name.name === 'style' || current.parent.name.name === 'sx')) {
                     return true;
                 }
                 // Check for style-related variable names or properties
@@ -91,7 +91,7 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
                 // Check for style-related object property assignments
                 if (current.parent.type === utils_1.AST_NODE_TYPES.Property &&
                     current.parent.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    /style/i.test(current.parent.key.name)) {
+                    (/style/i.test(current.parent.key.name) || current.parent.key.name === 'sx')) {
                     return true;
                 }
                 // Skip if we're in a TypeScript type definition
@@ -142,9 +142,9 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
                     return;
                 checkNode(node);
             },
-            // Handle JSX style attributes
+            // Handle JSX style and sx attributes
             JSXAttribute(node) {
-                if (node.name.name !== 'style')
+                if (node.name.name !== 'style' && node.name.name !== 'sx')
                     return;
                 if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
                     node.value.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {

package/package.json

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