@blumintinc/eslint-plugin-blumint 1.8.0 → 1.8.2

package/lib/rules/enforce-react-type-naming.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceReactTypeNaming = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+// Types that should have lowercase variable names
+const LOWERCASE_TYPES = ['ReactNode', 'JSX.Element'];
+// Types that should have uppercase variable names
+const UPPERCASE_TYPES = ['ComponentType', 'FC', 'FunctionComponent'];
+exports.enforceReactTypeNaming = (0, createRule_1.createRule)({
+    name: 'enforce-react-type-naming',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce naming conventions for React types',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            reactNodeShouldBeLowercase: 'Variables or parameters of type "{{type}}" should use lowercase naming (e.g., "{{suggestion}}").',
+            componentTypeShouldBeUppercase: 'Variables or parameters of type "{{type}}" should use uppercase naming (e.g., "{{suggestion}}").',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * Checks if a string starts with an uppercase letter
+         */
+        function isUppercase(str) {
+            return /^[A-Z]/.test(str);
+        }
+        /**
+         * Converts a string to start with lowercase
+         */
+        function toLowercase(str) {
+            if (!str)
+                return str;
+            return str.charAt(0).toLowerCase() + str.slice(1);
+        }
+        /**
+         * Converts a string to start with uppercase
+         */
+        function toUppercase(str) {
+            if (!str)
+                return str;
+            return str.charAt(0).toUpperCase() + str.slice(1);
+        }
+        /**
+         * Extracts the type name from a type annotation
+         */
+        function getTypeName(typeAnnotation) {
+            if (!typeAnnotation)
+                return null;
+            // Handle TSTypeReference (e.g., ReactNode, ComponentType)
+            if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                if (typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return typeAnnotation.typeName.name;
+                }
+                // Handle qualified names like JSX.Element
+                if (typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                    const left = typeAnnotation.typeName.left.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? typeAnnotation.typeName.left.name
+                        : '';
+                    const right = typeAnnotation.typeName.right.name;
+                    return `${left}.${right}`;
+                }
+            }
+            return null;
+        }
+        /**
+         * Checks if a node is a destructured variable
+         */
+        function isDestructured(node) {
+            return (node.parent?.type === utils_1.AST_NODE_TYPES.Property ||
+                node.parent?.type === utils_1.AST_NODE_TYPES.ArrayPattern ||
+                (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)));
+        }
+        /**
+         * Checks if a node is a default import
+         */
+        function isDefaultImport(node) {
+            return (node.parent?.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                (node.parent?.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    node.parent.local.name !== node.parent.imported?.name));
+        }
+        /**
+         * Check variable declarations for React type naming conventions
+         */
+        function checkVariableDeclaration(node) {
+            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            // Skip destructured variables
+            if (isDestructured(node.id))
+                return;
+            const variableName = node.id.name;
+            // Get the type annotation
+            const typeAnnotation = node.id.typeAnnotation?.typeAnnotation;
+            const typeName = getTypeName(typeAnnotation);
+            if (!typeName)
+                return;
+            // Check if it's a ReactNode or JSX.Element (should be lowercase)
+            if (LOWERCASE_TYPES.includes(typeName) && isUppercase(variableName)) {
+                const suggestion = toLowercase(variableName);
+                context.report({
+                    node: node.id,
+                    messageId: 'reactNodeShouldBeLowercase',
+                    data: {
+                        type: typeName,
+                        suggestion,
+                    },
+                    fix: (fixer) => fixer.replaceText(node.id, suggestion),
+                });
+            }
+            // Check if it's a ComponentType or FC (should be uppercase)
+            if (UPPERCASE_TYPES.includes(typeName) && !isUppercase(variableName)) {
+                const suggestion = toUppercase(variableName);
+                context.report({
+                    node: node.id,
+                    messageId: 'componentTypeShouldBeUppercase',
+                    data: {
+                        type: typeName,
+                        suggestion,
+                    },
+                    fix: (fixer) => fixer.replaceText(node.id, suggestion),
+                });
+            }
+        }
+        /**
+         * Check function parameters for React type naming conventions
+         */
+        function checkParameter(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            // Skip destructured parameters
+            if (isDestructured(node))
+                return;
+            // Skip default imports
+            if (isDefaultImport(node))
+                return;
+            const paramName = node.name;
+            // Get the type annotation
+            const typeAnnotation = node.typeAnnotation?.typeAnnotation;
+            const typeName = getTypeName(typeAnnotation);
+            if (!typeName)
+                return;
+            // Check if it's a ReactNode or JSX.Element (should be lowercase)
+            if (LOWERCASE_TYPES.includes(typeName) && isUppercase(paramName)) {
+                const suggestion = toLowercase(paramName);
+                context.report({
+                    node,
+                    messageId: 'reactNodeShouldBeLowercase',
+                    data: {
+                        type: typeName,
+                        suggestion,
+                    },
+                    fix: (fixer) => fixer.replaceText(node, suggestion),
+                });
+            }
+            // Check if it's a ComponentType or FC (should be uppercase)
+            if (UPPERCASE_TYPES.includes(typeName) && !isUppercase(paramName)) {
+                const suggestion = toUppercase(paramName);
+                context.report({
+                    node,
+                    messageId: 'componentTypeShouldBeUppercase',
+                    data: {
+                        type: typeName,
+                        suggestion,
+                    },
+                    fix: (fixer) => fixer.replaceText(node, suggestion),
+                });
+            }
+        }
+        return {
+            VariableDeclarator: checkVariableDeclaration,
+            Identifier(node) {
+                // Check parameter names in function declarations
+                if (node.parent &&
+                    (node.parent.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                        node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) &&
+                    node.parent.params.includes(node)) {
+                    checkParameter(node);
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-react-type-naming.js.map

package/lib/rules/enforce-singular-type-names.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const enforceSingularTypeNames: TSESLint.RuleModule<'typeShouldBeSingular', never[]>;

package/lib/rules/enforce-singular-type-names.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceSingularTypeNames = void 0;
+const createRule_1 = require("../utils/createRule");
+const pluralize = __importStar(require("pluralize"));
+exports.enforceSingularTypeNames = (0, createRule_1.createRule)({
+    create(context) {
+        /**
+         * Check if a name is plural
+         * @param name The name to check
+         * @returns true if the name is plural, false otherwise
+         */
+        function isPlural(name) {
+            // Skip checking if name is too short (less than 3 characters)
+            if (name.length < 3)
+                return false;
+            // Skip checking if name ends with 'Props' or 'Params'
+            if (name.endsWith('Props') || name.endsWith('Params') || name.endsWith('Options') || name.endsWith('Settings'))
+                return false;
+            // Skip checking if name is already singular according to pluralize
+            if (pluralize.isSingular(name))
+                return false;
+            // Check if the singular form is different from the name
+            const singular = pluralize.singular(name);
+            return singular !== name;
+        }
+        /**
+         * Get the singular form of a name
+         * @param name The name to get the singular form of
+         * @returns The singular form of the name
+         */
+        function getSingularForm(name) {
+            return pluralize.singular(name);
+        }
+        /**
+         * Report a plural type name
+         * @param node The node to report
+         * @param name The plural name
+         * @param suggestedName The suggested singular name
+         */
+        function reportPluralName(node, name, suggestedName) {
+            context.report({
+                node,
+                messageId: 'typeShouldBeSingular',
+                data: {
+                    name,
+                    suggestedName,
+                },
+            });
+        }
+        return {
+            // Check type aliases
+            TSTypeAliasDeclaration(node) {
+                const name = node.id.name;
+                if (isPlural(name)) {
+                    reportPluralName(node.id, name, getSingularForm(name));
+                }
+            },
+            // Check interfaces
+            TSInterfaceDeclaration(node) {
+                const name = node.id.name;
+                if (isPlural(name)) {
+                    reportPluralName(node.id, name, getSingularForm(name));
+                }
+            },
+            // Check enums
+            TSEnumDeclaration(node) {
+                const name = node.id.name;
+                if (isPlural(name)) {
+                    reportPluralName(node.id, name, getSingularForm(name));
+                }
+            },
+        };
+    },
+    name: 'enforce-singular-type-names',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce TypeScript type names to be singular',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            typeShouldBeSingular: "Type name '{{name}}' should be singular. Consider using '{{suggestedName}}' instead.",
+        },
+    },
+    defaultOptions: [],
+});
+//# sourceMappingURL=enforce-singular-type-names.js.map

package/lib/rules/enforce-verb-noun-naming.js

@@ -4651,10 +4651,13 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                         }
                     }
                     return false;
-                })()
+                })(),
+                // 5. Component name ends with "Unmemoized" (common React pattern)
+                functionName && functionName.endsWith('Unmemoized')
             ];
             // Consider it a React component if it matches at least 2 indicators
-            return indicators.filter(Boolean).length >= 2;
+            // OR if it has the Unmemoized suffix (strong indicator of a React component)
+            return indicators.filter(Boolean).length >= 2 || (!!functionName && functionName.endsWith('Unmemoized'));
         }
         return {
             FunctionDeclaration(node) {

package/lib/rules/ensure-pointer-events-none.d.ts

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

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