@blumintinc/eslint-plugin-blumint 1.8.0 → 1.8.2

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyOnlyOutermostElement = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.keyOnlyOutermostElement = (0, createRule_1.createRule)({
+    name: 'key-only-outermost-element',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that only the outermost element in list rendering has a key prop',
+            recommended: 'error',
+        },
+        messages: {
+            keyOnlyOutermostElement: 'Only the outermost element in a list rendering should have a key prop. Remove the key from this nested element.',
+            fragmentShouldHaveKey: 'Fragment used as the outermost element in a list should use <React.Fragment key={...}> instead of shorthand syntax.',
+        },
+        schema: [],
+        fixable: 'code',
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track JSXElements that are direct children of a map callback
+        const mapCallbackElements = new Set();
+        // Track JSXFragments that are direct children of a map callback
+        const mapCallbackFragments = new Set();
+        // Track JSX attributes that have already been reported to avoid duplicate reports
+        const reportedAttributes = new Set();
+        // Helper function to process map calls
+        const processMapCall = (node) => {
+            // Get the callback function
+            const callback = node.arguments[0];
+            if (callback && (callback.type === 'ArrowFunctionExpression' ||
+                callback.type === 'FunctionExpression')) {
+                // Find the return statement or expression
+                let returnExpr = null;
+                if (callback.type === 'ArrowFunctionExpression' &&
+                    callback.expression &&
+                    callback.body.type !== 'BlockStatement') {
+                    // Arrow function with implicit return
+                    returnExpr = callback.body;
+                }
+                else {
+                    // Look for return statements in the function body
+                    const body = callback.body;
+                    if (body.type === 'BlockStatement') {
+                        for (const stmt of body.body) {
+                            if (stmt.type === 'ReturnStatement' && stmt.argument) {
+                                returnExpr = stmt.argument;
+                                break;
+                            }
+                        }
+                    }
+                }
+                // If we found a JSX element or fragment as the return value, mark it
+                if (returnExpr) {
+                    if (returnExpr.type === 'JSXElement') {
+                        mapCallbackElements.add(returnExpr);
+                    }
+                    else if (returnExpr.type === 'JSXFragment') {
+                        mapCallbackFragments.add(returnExpr);
+                        // Check if it's a shorthand fragment (<>)
+                        // Shorthand fragments can't have keys, so suggest using React.Fragment
+                        context.report({
+                            node: returnExpr.openingFragment,
+                            messageId: 'fragmentShouldHaveKey',
+                        });
+                    }
+                }
+            }
+        };
+        return {
+            // Find array.map() calls
+            'CallExpression[callee.property.name="map"]'(node) {
+                processMapCall(node);
+            },
+            // Check all JSX elements for key props
+            JSXElement(node) {
+                // Skip if this is the outermost element in a map callback
+                if (mapCallbackElements.has(node)) {
+                    return;
+                }
+                // Check if this element has a key prop
+                const openingElement = node.openingElement;
+                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)) {
+                        // 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))) {
+                                isNestedInMapCallback = true;
+                                break;
+                            }
+                            parent = parent.parent;
+                        }
+                        if (isNestedInMapCallback) {
+                            // Mark this attribute as reported to avoid duplicate reports
+                            reportedAttributes.add(attr);
+                            const sourceCode = context.getSourceCode();
+                            context.report({
+                                node: attr,
+                                messageId: 'keyOnlyOutermostElement',
+                                fix(fixer) {
+                                    // Find the exact range of the attribute in the source code
+                                    const startPos = attr.range[0];
+                                    const endPos = attr.range[1];
+                                    // Get the text before and after the attribute to check for whitespace
+                                    const fullText = sourceCode.getText();
+                                    // Check if there's a space after the attribute
+                                    let rangeEnd = endPos;
+                                    if (rangeEnd < fullText.length && fullText[rangeEnd] === ' ') {
+                                        rangeEnd++;
+                                    }
+                                    return fixer.replaceTextRange([startPos, rangeEnd], '');
+                                },
+                            });
+                        }
+                    }
+                }
+            },
+            // Handle conditional expressions that might contain map callbacks
+            ConditionalExpression(node) {
+                // Check both the consequent and alternate branches
+                if (node.consequent.type === 'CallExpression' &&
+                    node.consequent.callee.type === 'MemberExpression' &&
+                    node.consequent.callee.property.type === 'Identifier' &&
+                    node.consequent.callee.property.name === 'map') {
+                    processMapCall(node.consequent);
+                }
+                if (node.alternate.type === 'CallExpression' &&
+                    node.alternate.callee.type === 'MemberExpression' &&
+                    node.alternate.callee.property.type === 'Identifier' &&
+                    node.alternate.callee.property.name === 'map') {
+                    processMapCall(node.alternate);
+                }
+            },
+            // Handle logical expressions (&&, ||) that might contain map callbacks
+            LogicalExpression(node) {
+                if (node.right.type === 'CallExpression' &&
+                    node.right.callee.type === 'MemberExpression' &&
+                    node.right.callee.property.type === 'Identifier' &&
+                    node.right.callee.property.name === 'map') {
+                    processMapCall(node.right);
+                }
+            }
+        };
+    },
+});
+//# sourceMappingURL=key-only-outermost-element.js.map

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

@@ -301,6 +301,25 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             }
             // For ||: if either side is always truthy, the whole expression is truthy
             if (node.operator === '||') {
+                // Skip evaluation if this is a destructuring assignment with fallback pattern
+                if (node.parent) {
+                    // Check for variable declarator with destructuring pattern
+                    if (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        (node.parent.id.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                            node.parent.id.type === utils_1.AST_NODE_TYPES.ArrayPattern)) {
+                        // This is a destructuring with fallback pattern like: const { x } = obj || {}
+                        // Don't flag this as an always true/false condition
+                        return {};
+                    }
+                    // Check for assignment expression with destructuring pattern
+                    if (node.parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+                        (node.parent.left.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                            node.parent.left.type === utils_1.AST_NODE_TYPES.ArrayPattern)) {
+                        // This is a destructuring with fallback pattern like: ({ x } = obj || {})
+                        // Don't flag this as an always true/false condition
+                        return {};
+                    }
+                }
                 if (leftResult.isTruthy) {
                     // Short circuit for || - if left is truthy, right is never evaluated
                     return { isTruthy: true };

package/lib/rules/no-circular-references.d.ts

@@ -0,0 +1 @@
+export declare const noCircularReferences: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"circularReference", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;