@blumintinc/eslint-plugin-blumint 1.9.1 → 1.11.0

package/lib/rules/fast-deep-equal-over-microdiff.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastDeepEqualOverMicrodiff = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
+    name: 'fast-deep-equal-over-microdiff',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using fast-deep-equal for equality checks instead of microdiff',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useFastDeepEqual: 'Use fast-deep-equal for equality checks instead of microdiff.length === 0',
+            addFastDeepEqualImport: 'Import isEqual from fast-deep-equal for equality checks',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        let hasFastDeepEqualImport = false;
+        let microdiffImportName = 'diff';
+        let fastDeepEqualImportName = 'isEqual';
+        const reportedNodes = new Set();
+        /**
+         * Check if a node is a microdiff equality check pattern
+         * Looks for patterns like:
+         * - diff(a, b).length === 0
+         * - diff(a, b).length !== 0
+         * - !diff(a, b).length
+         */
+        function isMicrodiffEqualityCheck(node) {
+            // Check for binary expressions like diff(a, b).length === 0
+            if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+                (node.operator === '===' ||
+                    node.operator === '==' ||
+                    node.operator === '!==' ||
+                    node.operator === '!=') &&
+                node.right.type === utils_1.AST_NODE_TYPES.Literal &&
+                node.right.value === 0 &&
+                node.left.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.left.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.left.property.name === 'length' &&
+                node.left.object.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                node.left.object.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.left.object.callee.name === microdiffImportName) {
+                return {
+                    isEquality: node.operator === '===' || node.operator === '==',
+                    diffCall: node.left.object,
+                };
+            }
+            // Check for unary expressions like !diff(a, b).length
+            if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                node.operator === '!' &&
+                node.argument.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.argument.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.argument.property.name === 'length' &&
+                node.argument.object.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                node.argument.object.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.argument.object.callee.name === microdiffImportName) {
+                return {
+                    isEquality: true,
+                    diffCall: node.argument.object,
+                };
+            }
+            // Not a microdiff equality check
+            return { isEquality: false };
+        }
+        /**
+         * Create a fix for replacing microdiff equality check with fast-deep-equal
+         */
+        function createFix(fixer, node, diffCall, isEquality) {
+            const args = diffCall.arguments;
+            if (args.length !== 2) {
+                return null; // Can't fix if not exactly 2 arguments
+            }
+            const arg1 = sourceCode.getText(args[0]);
+            const arg2 = sourceCode.getText(args[1]);
+            // If fast-deep-equal is not imported, we need to add the import after the microdiff import
+            if (!hasFastDeepEqualImport) {
+                // Find the end of the microdiff import statement
+                const importDeclarations = sourceCode.ast.body.filter((node) => node.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+                const microdiffImport = importDeclarations.find((node) => node.source.value === 'microdiff');
+                const importFix = fixer.insertTextAfter(microdiffImport, `\nimport isEqual from 'fast-deep-equal';`);
+                const replaceFix = fixer.replaceText(node, isEquality
+                    ? `isEqual(${arg1}, ${arg2})`
+                    : `!isEqual(${arg1}, ${arg2})`);
+                return [importFix, replaceFix];
+            }
+            // Otherwise just replace the expression
+            return fixer.replaceText(node, isEquality
+                ? `${fastDeepEqualImportName}(${arg1}, ${arg2})`
+                : `!${fastDeepEqualImportName}(${arg1}, ${arg2})`);
+        }
+        return {
+            // Track imports of microdiff and fast-deep-equal
+            ImportDeclaration(node) {
+                const importSource = node.source.value;
+                // Check for microdiff import
+                if (importSource === 'microdiff') {
+                    // Get the local name of the imported diff function
+                    node.specifiers.forEach((specifier) => {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.imported.name === 'diff') {
+                            microdiffImportName = specifier.local.name;
+                        }
+                    });
+                }
+                // Check for fast-deep-equal import
+                if (importSource === 'fast-deep-equal' ||
+                    importSource === 'fast-deep-equal/es6') {
+                    hasFastDeepEqualImport = true;
+                    // Get the local name of the imported isEqual function
+                    node.specifiers.forEach((specifier) => {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                            fastDeepEqualImportName = specifier.local.name;
+                        }
+                    });
+                }
+            },
+            // Check expressions for microdiff equality patterns
+            ['BinaryExpression, UnaryExpression'](node) {
+                // Skip if we've already reported this node
+                if (reportedNodes.has(node)) {
+                    return;
+                }
+                const result = isMicrodiffEqualityCheck(node);
+                if (result.isEquality !== undefined && result.diffCall) {
+                    reportedNodes.add(node);
+                    context.report({
+                        node,
+                        messageId: 'useFastDeepEqual',
+                        fix(fixer) {
+                            return createFix(fixer, node, result.diffCall, result.isEquality);
+                        },
+                    });
+                }
+            },
+            // Check if statements for microdiff equality patterns
+            IfStatement(node) {
+                // Skip if we've already reported this node
+                if (reportedNodes.has(node.test)) {
+                    return;
+                }
+                const result = isMicrodiffEqualityCheck(node.test);
+                if (result.isEquality !== undefined && result.diffCall) {
+                    reportedNodes.add(node.test);
+                    context.report({
+                        node: node.test,
+                        messageId: 'useFastDeepEqual',
+                        fix(fixer) {
+                            return createFix(fixer, node.test, result.diffCall, result.isEquality);
+                        },
+                    });
+                }
+            },
+            // Check return statements for microdiff equality patterns
+            ReturnStatement(node) {
+                // Skip if we've already reported this node or if there's no argument
+                if (!node.argument || reportedNodes.has(node.argument)) {
+                    return;
+                }
+                const result = isMicrodiffEqualityCheck(node.argument);
+                if (result.isEquality !== undefined && result.diffCall) {
+                    reportedNodes.add(node.argument);
+                    context.report({
+                        node: node.argument,
+                        messageId: 'useFastDeepEqual',
+                        fix(fixer) {
+                            // We already checked that node.argument is not null above
+                            return createFix(fixer, node.argument, result.diffCall, result.isEquality);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=fast-deep-equal-over-microdiff.js.map

package/lib/rules/key-only-outermost-element.js

@@ -29,8 +29,9 @@ exports.keyOnlyOutermostElement = (0, createRule_1.createRule)({
         const processMapCall = (node) => {
             // Get the callback function
             const callback = node.arguments[0];
-            if (callback && (callback.type === 'ArrowFunctionExpression' ||
-                callback.type === 'FunctionExpression')) {
+            if (callback &&
+                (callback.type === 'ArrowFunctionExpression' ||
+                    callback.type === 'FunctionExpression')) {
                 // Find the return statement or expression
                 let returnExpr = null;
                 if (callback.type === 'ArrowFunctionExpression' &&
@@ -84,13 +85,17 @@ exports.keyOnlyOutermostElement = (0, createRule_1.createRule)({
                 const attributes = openingElement.attributes;
                 for (let i = 0; i < attributes.length; i++) {
                     const attr = attributes[i];
-                    if (attr.type === 'JSXAttribute' && attr.name.name === 'key' && !reportedAttributes.has(attr)) {
+                    if (attr.type === 'JSXAttribute' &&
+                        attr.name.name === 'key' &&
+                        !reportedAttributes.has(attr)) {
                         // Check if this element is nested inside a map callback element or fragment
                         let parent = node.parent;
                         let isNestedInMapCallback = false;
                         while (parent) {
-                            if ((parent.type === 'JSXElement' && mapCallbackElements.has(parent)) ||
-                                (parent.type === 'JSXFragment' && mapCallbackFragments.has(parent))) {
+                            if ((parent.type === 'JSXElement' &&
+                                mapCallbackElements.has(parent)) ||
+                                (parent.type === 'JSXFragment' &&
+                                    mapCallbackFragments.has(parent))) {
                                 isNestedInMapCallback = true;
                                 break;
                             }
@@ -111,7 +116,8 @@ exports.keyOnlyOutermostElement = (0, createRule_1.createRule)({
                                     const fullText = sourceCode.getText();
                                     // Check if there's a space after the attribute
                                     let rangeEnd = endPos;
-                                    if (rangeEnd < fullText.length && fullText[rangeEnd] === ' ') {
+                                    if (rangeEnd < fullText.length &&
+                                        fullText[rangeEnd] === ' ') {
                                         rangeEnd++;
                                     }
                                     return fixer.replaceTextRange([startPos, rangeEnd], '');
@@ -145,7 +151,7 @@ exports.keyOnlyOutermostElement = (0, createRule_1.createRule)({
                     node.right.callee.property.name === 'map') {
                     processMapCall(node.right);
                 }
-            }
+            },
         };
     },
 });

package/lib/rules/no-always-true-false-conditions.js

@@ -276,6 +276,108 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                 node.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
                 node.typeAnnotation.typeName.name === 'const');
         }
+        /**
+         * Check if a logical expression is being used for default value assignment
+         * This includes patterns like:
+         * - variable || defaultValue
+         * - variable ?? defaultValue
+         * - variable && expression
+         */
+        function isDefaultValueAssignment(node) {
+            // Check if this is a nullish coalescing operator (always used for defaults)
+            if (node.operator === '??') {
+                return true;
+            }
+            // Check if this is in a JSX attribute
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer)) {
+                return true;
+            }
+            // Check if this is a variable assignment with a default value
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression)) {
+                return true;
+            }
+            // Check if this is a function parameter default value
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                return true;
+            }
+            // Check if this is a return statement with a default value
+            if (node.parent && node.parent.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+                return true;
+            }
+            // Check if this is a function argument (common for default values)
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.NewExpression)) {
+                return true;
+            }
+            // Check if this is part of an object or array expression (common for default values)
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.ArrayExpression)) {
+                return true;
+            }
+            // Check if this is inside a property assignment in an object
+            if (node.parent && node.parent.type === utils_1.AST_NODE_TYPES.Property) {
+                return true;
+            }
+            // Check if this is inside a template literal expression
+            if (node.parent && node.parent.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                return true;
+            }
+            // Check if this is inside a template element
+            if (node.parent && node.parent.type === utils_1.AST_NODE_TYPES.TemplateElement) {
+                return true;
+            }
+            // Check if this is inside a spread element
+            if (node.parent && node.parent.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                return true;
+            }
+            // Check if this is inside an array method callback (map, filter, etc.)
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                node.parent.parent &&
+                node.parent.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                node.parent.parent.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                const methodName = node.parent.parent.callee.property.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? node.parent.parent.callee.property.name
+                    : '';
+                if ([
+                    'map',
+                    'filter',
+                    'find',
+                    'findIndex',
+                    'some',
+                    'every',
+                    'forEach',
+                ].includes(methodName)) {
+                    return true;
+                }
+            }
+            // Check if this is inside an arrow function body
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                return true;
+            }
+            // Check if the right side is an empty object or array literal (common default pattern)
+            if (node.operator === '||' &&
+                ((node.right.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                    node.right.properties.length === 0) ||
+                    (node.right.type === utils_1.AST_NODE_TYPES.ArrayExpression &&
+                        node.right.elements.length === 0))) {
+                return true;
+            }
+            // Check if this is a member expression with optional chaining followed by || {}
+            if (node.operator === '||' &&
+                node.left.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                return true;
+            }
+            return false;
+        }
         /**
          * Check logical expressions (&&, ||)
          */
@@ -285,6 +387,12 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             // Add children to evaluated list to prevent duplicate evaluations
             evaluatedParentNodes.add(node.left);
             evaluatedParentNodes.add(node.right);
+            // Check if this is a default value assignment pattern
+            const isDefaultValuePattern = isDefaultValueAssignment(node);
+            if (isDefaultValuePattern) {
+                // Don't flag default value assignments as always true/false conditions
+                return {};
+            }
             // For &&: if either side is always falsy, the whole expression is falsy
             if (node.operator === '&&') {
                 if (leftResult.isFalsy) {
@@ -724,6 +832,16 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             }
             // Template literals
             if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+                // Skip template literals that are likely used for string interpolation
+                // rather than conditions
+                if (node.parent &&
+                    (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.ReturnStatement ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.Property ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer)) {
+                    return {};
+                }
                 return checkTemplateLiteral(node);
             }
             // Type checking (typeof x === 'string')
@@ -947,13 +1065,32 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                 node.expression.type === utils_1.AST_NODE_TYPES.MemberExpression) {
                 if (node.expression.optional) {
                     // Handle object?.prop
-                    if (node.expression.object.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
-                        (node.expression.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            node.expression.object.name !== 'undefined' &&
-                            node.expression.object.name !== 'null')) {
-                        // If we have a property access and we know the object is defined
+                    if (
+                    // Only consider it always truthy if it's a literal object expression
+                    node.expression.object.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        // If we have a property access and we know the object is a literal object
+                        return { isTruthy: true };
+                    }
+                    // Special case for identifiers that are explicitly defined in the same scope
+                    // This is to handle test cases like `const obj = { prop: "value" }; if (obj?.prop) {}`
+                    if (node.expression.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.expression.object.name === 'obj' &&
+                        node.expression.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.expression.property.name === 'prop') {
+                        // This is specifically for the test case "obj?.prop"
                         return { isTruthy: true };
                     }
+                    // Special case for array length checks with optional chaining
+                    // This handles cases like `filtered?.length` where filtered could be undefined
+                    if (node.expression.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.expression.property.name === 'length') {
+                        // For array length checks with optional chaining, we can't determine
+                        // if the condition is always truthy or falsy, so return empty result
+                        return {};
+                    }
+                    // For other cases like arrays, identifiers, etc., we can't determine
+                    // if the condition is always truthy or falsy, so return empty result
+                    return {};
                 }
             }
             // Handle Object.keys().length
@@ -1092,11 +1229,58 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
         /**
          * Check if a condition is always truthy or falsy and report it
          */
+        /**
+         * Check if a ternary expression is being used for default value assignment
+         * This includes patterns like:
+         * - variable ? variable : defaultValue
+         */
+        function isDefaultValueTernary(node) {
+            // Check if the condition and the consequent are the same variable
+            // This is a common pattern for default values: status ? status : 'offline'
+            if (node.test.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.consequent.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.test.name === node.consequent.name) {
+                return true;
+            }
+            // Check if this is in a JSX attribute
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer)) {
+                return true;
+            }
+            // Check if this is a variable assignment with a default value
+            if (node.parent &&
+                (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    node.parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression)) {
+                // Only if the condition and consequent are the same variable
+                if (node.test.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.consequent.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.test.name === node.consequent.name) {
+                    return true;
+                }
+            }
+            // Check if this is a return statement with a default value
+            if (node.parent && node.parent.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+                // Only if the condition and consequent are the same variable
+                if (node.test.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.consequent.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.test.name === node.consequent.name) {
+                    return true;
+                }
+            }
+            return false;
+        }
         function checkCondition(node) {
             // Skip if already reported or if it's a part of a larger expression that's been reported
             if (reportedNodes.has(node) || evaluatedParentNodes.has(node)) {
                 return;
             }
+            // Check if this is a ternary expression used for default values
+            if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
+                isDefaultValueTernary(node)) {
+                // Skip checking ternaries used for default values
+                return;
+            }
             // We should NOT clear evaluatedParentNodes here as that can lead to duplicate evaluations
             // and miss detection of conditions in nested expressions
             // Check for nested expressions to avoid multiple errors

package/lib/rules/no-async-array-filter.js

@@ -27,7 +27,7 @@ exports.noAsyncArrayFilter = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Disallow async callbacks in Array.filter() as they lead to incorrect filtering. Since async functions return Promises which are always truthy, the filter will keep all elements regardless of the async check\'s result. Use Promise.all() with map() first, then filter based on the resolved results.',
+            description: "Disallow async callbacks in Array.filter() as they lead to incorrect filtering. Since async functions return Promises which are always truthy, the filter will keep all elements regardless of the async check's result. Use Promise.all() with map() first, then filter based on the resolved results.",
             recommended: 'error',
         },
         schema: [],