@blumintinc/eslint-plugin-blumint 1.8.0 → 1.8.1

package/lib/rules/ensure-pointer-events-none.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePointerEventsNone = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * Checks if a string contains a pseudo-element selector (::before or ::after)
+ */
+function hasPseudoElementSelector(selector) {
+    return /::?(before|after)\b/i.test(selector);
+}
+/**
+ * Checks if a property name is position with absolute or fixed value
+ */
+function isAbsoluteOrFixedPosition(propertyName, propertyValue) {
+    if (propertyName !== 'position')
+        return false;
+    return propertyValue === 'absolute' || propertyValue === 'fixed';
+}
+/**
+ * Checks if a property is pointer-events with a value
+ */
+function isPointerEventsProperty(propertyName) {
+    return propertyName === 'pointerEvents' || propertyName === 'pointer-events';
+}
+exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
+    name: 'ensure-pointer-events-none',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensure pointer-events: none is added to non-interactive pseudo-elements',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            missingPointerEventsNone: 'Pseudo-elements (::before, ::after) with position: absolute or fixed should have pointer-events: none to prevent blocking interactions with underlying elements',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track style objects that have position: absolute or fixed
+        const absolutePositionedStyles = new Map();
+        // Track style objects that already have pointer-events defined
+        const stylesWithPointerEvents = new Map();
+        /**
+         * Process a CSS-in-JS style object to check for position: absolute/fixed and pointer-events
+         */
+        function processStyleObject(node) {
+            let hasAbsolutePosition = false;
+            let pointerEventsValue;
+            // Check each property in the style object
+            for (const property of node.properties) {
+                if (property.type !== utils_1.AST_NODE_TYPES.Property)
+                    continue;
+                let propertyName = '';
+                let propertyValue;
+                // Get property name
+                if (property.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    propertyName = property.key.name;
+                }
+                else if (property.key.type === utils_1.AST_NODE_TYPES.Literal && typeof property.key.value === 'string') {
+                    propertyName = property.key.value;
+                }
+                // Get property value if it's a string literal
+                if (property.value.type === utils_1.AST_NODE_TYPES.Literal) {
+                    propertyValue = String(property.value.value);
+                }
+                else if (property.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    propertyValue = property.value.name;
+                }
+                // Check if this is position: absolute/fixed
+                if (isAbsoluteOrFixedPosition(propertyName, propertyValue)) {
+                    hasAbsolutePosition = true;
+                }
+                // Check if this is pointer-events property
+                if (isPointerEventsProperty(propertyName)) {
+                    if (property.value.type === utils_1.AST_NODE_TYPES.Literal) {
+                        pointerEventsValue = String(property.value.value);
+                    }
+                    else if (property.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        pointerEventsValue = property.value.name;
+                    }
+                }
+            }
+            // Store the results for this style object
+            absolutePositionedStyles.set(node, hasAbsolutePosition);
+            if (pointerEventsValue !== undefined) {
+                stylesWithPointerEvents.set(node, pointerEventsValue);
+            }
+        }
+        /**
+         * Check if a style object needs pointer-events: none
+         */
+        function checkStyleObject(node, selector) {
+            const isPseudoElement = selector && hasPseudoElementSelector(selector);
+            const isAbsolutePositioned = absolutePositionedStyles.get(node) || false;
+            const pointerEventsValue = stylesWithPointerEvents.get(node);
+            // If this is a pseudo-element with absolute positioning but no pointer-events
+            if (isPseudoElement && isAbsolutePositioned && pointerEventsValue === undefined) {
+                context.report({
+                    node,
+                    messageId: 'missingPointerEventsNone',
+                    fix(fixer) {
+                        // Find the last property in the object
+                        const sourceCode = context.getSourceCode();
+                        const properties = node.properties;
+                        if (properties.length === 0)
+                            return null;
+                        const lastProperty = properties[properties.length - 1];
+                        const lastPropertyToken = sourceCode.getLastToken(lastProperty);
+                        if (lastPropertyToken) {
+                            return fixer.insertTextAfter(lastPropertyToken, `, pointerEvents: 'none'`);
+                        }
+                        return null;
+                    }
+                });
+            }
+            // If this is a pseudo-element with absolute positioning and pointer-events: auto
+            if (isPseudoElement && isAbsolutePositioned && pointerEventsValue === 'auto') {
+                // Don't report an error if pointer-events is explicitly set to 'auto'
+                // This is an intentional choice by the developer
+            }
+        }
+        return {
+            // Check for pseudo-element selectors in styled-components and similar libraries
+            TaggedTemplateExpression(node) {
+                // Check if this is a styled-components template
+                const tag = node.tag;
+                let isStyledComponent = false;
+                if (tag.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    tag.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    tag.object.name === 'styled') {
+                    isStyledComponent = true;
+                }
+                else if (tag.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (tag.name === 'styled' || tag.name === 'css')) {
+                    isStyledComponent = true;
+                }
+                if (isStyledComponent) {
+                    // For styled-components, we need to check the template content
+                    const template = node.quasi.quasis.map(q => q.value.raw).join('');
+                    // Check if it contains a pseudo-element with position: absolute/fixed
+                    if (hasPseudoElementSelector(template) &&
+                        (template.includes('position: absolute') || template.includes('position: fixed'))) {
+                        // Check if it's missing pointer-events: none
+                        if (!template.includes('pointer-events: none') && !template.includes('pointer-events:none')) {
+                            context.report({
+                                node,
+                                messageId: 'missingPointerEventsNone'
+                            });
+                        }
+                    }
+                }
+            },
+            // Process style objects in JSX
+            JSXAttribute(node) {
+                if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier || node.name.name !== 'style')
+                    return;
+                if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+                    node.value.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    processStyleObject(node.value.expression);
+                    checkStyleObject(node.value.expression);
+                }
+            },
+            // Process style objects in regular JavaScript/TypeScript
+            ObjectExpression(node) {
+                // Skip if parent is not a variable declaration or assignment
+                const parent = node.parent;
+                if (!parent)
+                    return;
+                // Check if this might be a style object
+                let isStyleObject = false;
+                let selector;
+                if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    /style/i.test(parent.id.name)) {
+                    isStyleObject = true;
+                }
+                else if (parent.type === utils_1.AST_NODE_TYPES.Property &&
+                    parent.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    /style/i.test(parent.key.name)) {
+                    isStyleObject = true;
+                }
+                else if (parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    // Check for CSS-in-JS libraries like emotion's css() function
+                    const callee = parent.callee;
+                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier && callee.name === 'css') {
+                        isStyleObject = true;
+                    }
+                }
+                if (isStyleObject) {
+                    processStyleObject(node);
+                    checkStyleObject(node, selector);
+                }
+            },
+            // Process CSS-in-JS libraries that use objects with selectors
+            Property(node) {
+                // Check for patterns like { '&::before': { ... } }
+                if (node.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.key.value === 'string' &&
+                    hasPseudoElementSelector(node.key.value) &&
+                    node.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    processStyleObject(node.value);
+                    checkStyleObject(node.value, node.key.value);
+                }
+            }
+        };
+    },
+});
+//# sourceMappingURL=ensure-pointer-events-none.js.map

package/lib/rules/key-only-outermost-element.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'keyOnlyOutermostElement' | 'fragmentShouldHaveKey';
+export declare const keyOnlyOutermostElement: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

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>;