@blumintinc/eslint-plugin-blumint 1.1.9 → 1.2.1

package/lib/rules/global-const-style.js

@@ -21,7 +21,8 @@ exports.default = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         // Check if the file is a TypeScript file
-        const isTypeScript = context.getFilename().endsWith('.ts') || context.getFilename().endsWith('.tsx');
+        const isTypeScript = context.getFilename().endsWith('.ts') ||
+            context.getFilename().endsWith('.tsx');
         return {
             VariableDeclaration(node) {
                 // Only check top-level const declarations
@@ -33,7 +34,7 @@ exports.default = (0, createRule_1.createRule)({
                     return;
                 }
                 // Skip if any declaration is a function component, arrow function, forwardRef, or memo
-                const shouldSkip = node.declarations.some(declaration => {
+                const shouldSkip = node.declarations.some((declaration) => {
                     if (declaration.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
                         return false;
                     }
@@ -44,7 +45,8 @@ exports.default = (0, createRule_1.createRule)({
                         return false;
                     }
                     // Skip function components (uppercase name + arrow function)
-                    if (/^[A-Z]/.test(name) && init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    if (/^[A-Z]/.test(name) &&
+                        init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
                         return true;
                     }
                     // Skip any arrow function
@@ -84,26 +86,20 @@ exports.default = (0, createRule_1.createRule)({
                         init.type === utils_1.AST_NODE_TYPES.NewExpression) {
                         return;
                     }
-                    // Check for UPPER_SNAKE_CASE
-                    if (!isUpperSnakeCase(name)) {
-                        context.report({
-                            node: declaration.id,
-                            messageId: 'upperSnakeCase',
-                            fix(fixer) {
-                                const newName = name
-                                    .replace(/([A-Z])/g, '_$1')
-                                    .toUpperCase()
-                                    .replace(/^_/, '');
-                                return fixer.replaceText(declaration.id, newName);
-                            },
-                        });
-                    }
+                    const sourceCode = context.getSourceCode();
+                    const initText = sourceCode.getText(init);
+                    const typeAnnotation = declaration.id.typeAnnotation;
+                    const typeText = typeAnnotation
+                        ? sourceCode.getText(typeAnnotation)
+                        : '';
                     // Only check for as const in TypeScript files
                     if (isTypeScript) {
                         const isAsConstExpression = (node) => {
                             if (node.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
-                                return (node.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                                    node.typeAnnotation?.typeName?.name === 'const');
+                                return (node.typeAnnotation?.type ===
+                                    utils_1.AST_NODE_TYPES.TSTypeReference &&
+                                    node.typeAnnotation?.typeName
+                                        ?.name === 'const');
                             }
                             return false;
                         };
@@ -112,6 +108,15 @@ exports.default = (0, createRule_1.createRule)({
                             if (isAsConstExpression(node)) {
                                 return false;
                             }
+                            // Handle type assertions
+                            if (node.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+                                node.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                                return shouldHaveAsConst(node.expression);
+                            }
+                            // Skip if there's an explicit type annotation
+                            if (declaration.id.typeAnnotation) {
+                                return false;
+                            }
                             // Check if it's a literal, array, or object that should have as const
                             return (node.type === utils_1.AST_NODE_TYPES.Literal ||
                                 node.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
@@ -119,16 +124,33 @@ exports.default = (0, createRule_1.createRule)({
                         };
                         if (shouldHaveAsConst(init)) {
                             context.report({
-                                node: init,
+                                node: declaration,
                                 messageId: 'asConst',
                                 fix(fixer) {
-                                    const sourceCode = context.getSourceCode();
-                                    const initText = sourceCode.getText(init);
                                     return fixer.replaceText(init, `${initText} as const`);
                                 },
                             });
                         }
                     }
+                    // Check for UPPER_SNAKE_CASE
+                    if (!isUpperSnakeCase(name)) {
+                        const newName = name
+                            .replace(/([A-Z])/g, '_$1')
+                            .toUpperCase()
+                            .replace(/^_/, '');
+                        context.report({
+                            node: declaration,
+                            messageId: 'upperSnakeCase',
+                            fix(fixer) {
+                                if (typeAnnotation) {
+                                    return fixer.replaceText(declaration, `${newName}${typeText} = ${initText}`);
+                                }
+                                else {
+                                    return fixer.replaceText(declaration.id, newName);
+                                }
+                            },
+                        });
+                    }
                 });
             },
         };

package/lib/rules/no-compositing-layer-props.d.ts

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

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

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noCompositingLayerProps = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+// Convert camelCase to kebab-case
+function toKebabCase(str) {
+    return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+// Normalize property name to kebab-case for consistent lookup
+function normalizePropertyName(name) {
+    // If already contains hyphens, assume it's kebab-case
+    if (name.includes('-'))
+        return name.toLowerCase();
+    // Convert camelCase to kebab-case
+    return toKebabCase(name).toLowerCase();
+}
+const COMPOSITING_PROPERTIES = new Set([
+    'filter',
+    'backdrop-filter',
+    'will-change',
+    'transform',
+    'perspective',
+    'backface-visibility',
+    'contain',
+    'mix-blend-mode',
+    'opacity',
+]);
+const COMPOSITING_VALUES = new Set([
+    'translate3d',
+    'scale3d',
+    'translateZ',
+    'transparent',
+]);
+exports.noCompositingLayerProps = (0, createRule_1.createRule)({
+    name: 'no-compositing-layer-props',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Warn when using CSS properties that trigger compositing layers',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            compositingLayer: '{{property}} may trigger a new compositing layer which can impact performance. Consider using alternative properties or add an eslint-disable comment if the layer promotion is intentional.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const seenNodes = new WeakSet();
+        function checkPropertyValue(value) {
+            return (COMPOSITING_VALUES.has(value) ||
+                value.includes('translate3d') ||
+                value.includes('scale3d') ||
+                value.includes('translateZ'));
+        }
+        function checkProperty(propertyName, propertyValue) {
+            const normalizedName = normalizePropertyName(propertyName);
+            if (COMPOSITING_PROPERTIES.has(normalizedName)) {
+                // Special case for opacity - only warn if it's animated or fractional
+                if (normalizedName === 'opacity') {
+                    if (!propertyValue)
+                        return false;
+                    const numValue = Number.parseFloat(propertyValue);
+                    if (Number.isNaN(numValue))
+                        return false;
+                    return numValue > 0 && numValue < 1;
+                }
+                return true;
+            }
+            if (propertyValue && checkPropertyValue(propertyValue)) {
+                return true;
+            }
+            return false;
+        }
+        function isStyleContext(node) {
+            let current = node;
+            while (current?.parent) {
+                // 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') {
+                    return true;
+                }
+                // Check for style-related variable names or properties
+                if (current.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    current.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    /style/i.test(current.id.name)) {
+                    return true;
+                }
+                // 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)) {
+                    return true;
+                }
+                // Skip if we're in a TypeScript type definition
+                if (current.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                    return false;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        function checkNode(node) {
+            // Skip if we've already processed this node
+            if (seenNodes.has(node))
+                return;
+            seenNodes.add(node);
+            // Skip if not in a style context
+            if (!isStyleContext(node))
+                return;
+            let propertyName = '';
+            let propertyValue = '';
+            // Get property name
+            if (node.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                propertyName = node.key.name;
+            }
+            else if (node.key.type === utils_1.AST_NODE_TYPES.Literal) {
+                propertyName = String(node.key.value);
+            }
+            // Get property value if it's a string literal or numeric literal
+            if (node.value.type === utils_1.AST_NODE_TYPES.Literal) {
+                propertyValue = String(node.value.value);
+            }
+            if (checkProperty(propertyName, propertyValue)) {
+                context.report({
+                    node,
+                    messageId: 'compositingLayer',
+                    data: {
+                        property: propertyName,
+                    },
+                });
+            }
+        }
+        return {
+            // Handle object literal properties (inline styles)
+            Property(node) {
+                if (node.parent?.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                    return;
+                checkNode(node);
+            },
+            // Handle JSX style attributes
+            JSXAttribute(node) {
+                if (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) {
+                    node.value.expression.properties.forEach((prop) => {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            checkNode(prop);
+                        }
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-compositing-layer-props.js.map

package/lib/rules/no-entire-object-hook-deps.js

@@ -3,11 +3,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noEntireObjectHookDeps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const typescript_1 = require("typescript");
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
 function isHookCall(node) {
     const callee = node.callee;
-    return (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-        HOOK_NAMES.has(callee.name));
+    return (callee.type === utils_1.AST_NODE_TYPES.Identifier && HOOK_NAMES.has(callee.name));
+}
+function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
+    const tsNode = nodeMap.get(esTreeNode);
+    if (!tsNode)
+        return false;
+    const type = checker.getTypeAtLocation(tsNode);
+    // Check if it's a primitive type
+    if (type.flags &
+        (typescript_1.TypeFlags.String |
+            typescript_1.TypeFlags.Number |
+            typescript_1.TypeFlags.Boolean |
+            typescript_1.TypeFlags.Null |
+            typescript_1.TypeFlags.Undefined |
+            typescript_1.TypeFlags.Void |
+            typescript_1.TypeFlags.Never |
+            typescript_1.TypeFlags.Any |
+            typescript_1.TypeFlags.Unknown |
+            typescript_1.TypeFlags.BigInt |
+            typescript_1.TypeFlags.ESSymbol)) {
+        return true;
+    }
+    // Check if it's an array type
+    const typeNode = checker.typeToTypeNode(type, undefined, undefined);
+    if (type.symbol?.name === 'Array' ||
+        type.symbol?.escapedName === 'Array' ||
+        (typeNode && ((0, typescript_1.isArrayTypeNode)(typeNode) || (0, typescript_1.isTupleTypeNode)(typeNode)))) {
+        return true;
+    }
+    // If it's not a primitive or array, and has properties, it's an object
+    return false;
 }
 function getObjectUsagesInHook(hookBody, objectName) {
     const usages = new Set();
@@ -25,75 +55,44 @@ function getObjectUsagesInHook(hookBody, objectName) {
             parts.unshift(current.property.name);
             current = current.object;
         }
-        if (current.type === utils_1.AST_NODE_TYPES.Identifier && current.name === objectName) {
-            parts.unshift(objectName);
+        if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
+            current.name === objectName) {
             return parts.join('.');
         }
         return null;
     }
     function visit(node) {
-        if (visited.has(node)) {
+        if (visited.has(node))
             return;
-        }
         visited.add(node);
-        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression && !node.computed) {
-            const accessPath = buildAccessPath(node);
-            if (accessPath) {
-                usages.add(accessPath);
+        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            const path = buildAccessPath(node);
+            if (path) {
+                usages.add(`${objectName}.${path}`);
             }
         }
-        // Visit children
-        switch (node.type) {
-            case utils_1.AST_NODE_TYPES.BlockStatement:
-            case utils_1.AST_NODE_TYPES.Program:
-                node.body.forEach(child => visit(child));
-                break;
-            case utils_1.AST_NODE_TYPES.ExpressionStatement:
-                visit(node.expression);
-                break;
-            case utils_1.AST_NODE_TYPES.CallExpression:
-                visit(node.callee);
-                node.arguments.forEach(arg => visit(arg));
-                break;
-            case utils_1.AST_NODE_TYPES.MemberExpression:
-                visit(node.object);
-                if (!node.computed) {
-                    visit(node.property);
-                }
-                break;
-            case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
-            case utils_1.AST_NODE_TYPES.FunctionExpression:
-                if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                    visit(node.body);
-                }
-                else {
-                    visit(node.body);
+        // Visit all child nodes
+        for (const key in node) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const child = node[key];
+            if (child && typeof child === 'object') {
+                if (Array.isArray(child)) {
+                    child.forEach((item) => {
+                        if (item && typeof item === 'object') {
+                            visit(item);
+                        }
+                    });
                 }
-                break;
-            case utils_1.AST_NODE_TYPES.ReturnStatement:
-                if (node.argument) {
-                    visit(node.argument);
+                else if ('type' in child) {
+                    visit(child);
                 }
-                break;
-            case utils_1.AST_NODE_TYPES.ConditionalExpression:
-                visit(node.test);
-                visit(node.consequent);
-                visit(node.alternate);
-                break;
-            case utils_1.AST_NODE_TYPES.LogicalExpression:
-            case utils_1.AST_NODE_TYPES.BinaryExpression:
-                visit(node.left);
-                visit(node.right);
-                break;
-            case utils_1.AST_NODE_TYPES.TemplateLiteral:
-                node.expressions.forEach(expr => visit(expr));
-                break;
+            }
         }
     }
     visit(hookBody);
     // Filter out intermediate paths
     const paths = Array.from(usages);
-    const filteredPaths = paths.filter(path => !paths.some(otherPath => otherPath !== path && otherPath.startsWith(path + '.')));
+    const filteredPaths = paths.filter((path) => !paths.some((otherPath) => otherPath !== path && otherPath.startsWith(path + '.')));
     return new Set(filteredPaths);
 }
 exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
@@ -112,6 +111,13 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const parserServices = context.parserServices;
+        // Check if we have access to TypeScript services
+        if (!parserServices?.program || !parserServices?.esTreeNodeToTSNodeMap) {
+            throw new Error('You have to enable the `project` setting in parser options to use this rule');
+        }
+        const checker = parserServices.program.getTypeChecker();
+        const nodeMap = parserServices.esTreeNodeToTSNodeMap;
         return {
             CallExpression(node) {
                 if (!isHookCall(node)) {
@@ -119,8 +125,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                 }
                 // Get the dependency array argument
                 const depsArg = node.arguments[node.arguments.length - 1];
-                if (!depsArg ||
-                    depsArg.type !== utils_1.AST_NODE_TYPES.ArrayExpression) {
+                if (!depsArg || depsArg.type !== utils_1.AST_NODE_TYPES.ArrayExpression) {
                     return;
                 }
                 // Get the hook callback function
@@ -131,10 +136,13 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                     return;
                 }
                 // Check each dependency in the array
-                depsArg.elements.forEach(element => {
-                    if (element &&
-                        element.type === utils_1.AST_NODE_TYPES.Identifier) {
+                depsArg.elements.forEach((element) => {
+                    if (element && element.type === utils_1.AST_NODE_TYPES.Identifier) {
                         const objectName = element.name;
+                        // Skip if the dependency is an array or primitive type
+                        if (isArrayOrPrimitive(checker, element, nodeMap)) {
+                            return;
+                        }
                         const usages = getObjectUsagesInHook(callbackArg.body, objectName);
                         // If we found specific field usages and the entire object is in deps
                         if (usages.size > 0) {

package/lib/rules/no-unused-props.js

@@ -25,16 +25,28 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
         return {
             TSTypeAliasDeclaration(node) {
                 if (node.id.name.endsWith('Props')) {
-                    if (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
-                        const props = {};
-                        node.typeAnnotation.members.forEach((member) => {
-                            if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
-                                member.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                props[member.key.name] = member.key;
+                    const props = {};
+                    function extractProps(typeNode) {
+                        if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                            typeNode.members.forEach((member) => {
+                                if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                                    member.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    props[member.key.name] = member.key;
+                                }
+                            });
+                        }
+                        else if (typeNode.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            typeNode.types.forEach(extractProps);
+                        }
+                        else if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                            // For referenced types like FormControlLabelProps, we need to track that these props should be forwarded
+                            if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                props[`...${typeNode.typeName.name}`] = typeNode.typeName;
                             }
-                        });
-                        propsTypes.set(node.id.name, props);
+                        }
                     }
+                    extractProps(node.typeAnnotation);
+                    propsTypes.set(node.id.name, props);
                 }
             },
             VariableDeclaration(node) {
@@ -56,6 +68,19 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                         prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
                                         used.add(prop.key.name);
                                     }
+                                    else if (prop.type === utils_1.AST_NODE_TYPES.RestElement &&
+                                        prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                        // Handle rest spread operator {...rest}
+                                        // When a rest operator is used, all remaining props are considered used
+                                        const propsType = propsTypes.get(typeName);
+                                        if (propsType) {
+                                            Object.keys(propsType).forEach((key) => {
+                                                if (key.startsWith('...')) {
+                                                    used.add(key);
+                                                }
+                                            });
+                                        }
+                                    }
                                 });
                                 usedProps.set(typeName, used);
                             }

package/lib/rules/no-useless-fragment.js

@@ -35,7 +35,7 @@ exports.noUselessFragment = {
         type: 'suggestion',
         docs: {
             description: 'Prevent unnecessary use of React fragments',
-            recommended: 'warn',
+            recommended: 'error',
         },
         messages: {
             noUselessFragment: 'React fragment is unnecessary when wrapping a single child',

package/lib/rules/prefer-fragment-shorthand.js

@@ -28,7 +28,7 @@ exports.preferFragmentShorthand = {
         type: 'suggestion',
         docs: {
             description: 'Prefer <> shorthand for <React.Fragment>',
-            recommended: 'warn',
+            recommended: 'error',
         },
         messages: {
             preferShorthand: 'Use <> shorthand for <React.Fragment>, unless a key is required for an iterator',

package/lib/rules/prefer-settings-object.d.ts

@@ -0,0 +1,11 @@
+type MessageIds = 'tooManyParams' | 'sameTypeParams';
+type Options = [
+    {
+        minimumParameters?: number;
+        checkSameTypeParameters?: boolean;
+        ignoreBoundMethods?: boolean;
+        ignoreVariadicFunctions?: boolean;
+    }
+];
+export declare const preferSettingsObject: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};