@blumintinc/eslint-plugin-blumint 1.2.0 → 1.3.0

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

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceVerbNounNaming = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const compromise_1 = __importDefault(require("compromise"));
+const PREPOSITIONS = ['to', 'from', 'with', 'by', 'at', 'of'];
+exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
+    name: 'enforce-verb-noun-naming',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce verb phrases for functions and methods',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            functionVerbPhrase: 'Function names should start with a verb phrase (e.g., fetchData, processRequest)',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function extractFirstWord(name) {
+            const firstChar = name.charAt(0);
+            const rest = name.slice(1);
+            const words = rest.split(/(?=[A-Z])/);
+            return firstChar + words[0];
+        }
+        function toSentence(name) {
+            return name.split(/(?=[A-Z])/).join(' ');
+        }
+        function getPossibleTags(sentence) {
+            const doc = (0, compromise_1.default)(sentence);
+            const terms = doc.terms().json();
+            if (terms.length === 0 || !terms[0].terms || !terms[0].terms[0].tags)
+                return [];
+            const tags = terms[0].terms[0].tags;
+            return tags;
+        }
+        function isVerbPhrase(name) {
+            const firstWord = extractFirstWord(name);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (PREPOSITIONS.includes(firstWord.toLowerCase())) {
+                return true;
+            }
+            const tags = getPossibleTags(toSentence(name));
+            const isVerb = tags.includes('Verb');
+            const isPreposition = tags.includes('Preposition');
+            const isConjunction = tags.includes('Conjunction');
+            return isVerb || isPreposition || isConjunction;
+        }
+        function isJsxReturnFunction(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+                node.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                node.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+                return false;
+            }
+            // Check if function returns JSX
+            const sourceCode = context.getSourceCode();
+            const text = sourceCode.getText(node);
+            return text.includes('return <') || text.includes('=> <');
+        }
+        return {
+            FunctionDeclaration(node) {
+                if (!node.id)
+                    return;
+                if (isJsxReturnFunction(node)) {
+                    return;
+                }
+                if (!isVerbPhrase(node.id.name)) {
+                    context.report({
+                        node: node.id,
+                        messageId: 'functionVerbPhrase',
+                    });
+                }
+            },
+            VariableDeclarator(node) {
+                if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                // Only check if it's a function
+                if (node.init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    node.init?.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    if (isJsxReturnFunction(node.init)) {
+                        return;
+                    }
+                    if (!isVerbPhrase(node.id.name)) {
+                        context.report({
+                            node: node.id,
+                            messageId: 'functionVerbPhrase',
+                        });
+                    }
+                }
+            },
+            MethodDefinition(node) {
+                if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                if (!isVerbPhrase(node.key.name)) {
+                    context.report({
+                        node: node.key,
+                        messageId: 'functionVerbPhrase',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-verb-noun-naming.js.map

package/lib/rules/export-if-in-doubt.js

@@ -9,7 +9,7 @@ exports.exportIfInDoubt = (0, createRule_1.createRule)({
         type: 'suggestion',
         docs: {
             description: 'All top-level const definitions, type definitions, and functions should be exported',
-            recommended: 'warn',
+            recommended: 'error',
         },
         schema: [],
         messages: {

package/lib/rules/extract-global-constants.js

@@ -19,13 +19,42 @@ function isFunctionDefinition(node) {
     return (node?.type === 'FunctionExpression' ||
         node?.type === 'ArrowFunctionExpression');
 }
+function isImmutableValue(node) {
+    if (!node)
+        return false;
+    switch (node.type) {
+        case 'Literal':
+            return true;
+        case 'TemplateLiteral':
+            return node.expressions.length === 0;
+        case 'UnaryExpression':
+            return isImmutableValue(node.argument);
+        case 'BinaryExpression':
+            if (node.left.type === 'PrivateIdentifier')
+                return false;
+            return isImmutableValue(node.left) && isImmutableValue(node.right);
+        default:
+            return false;
+    }
+}
 function isMutableValue(node) {
     if (!node)
         return false;
-    // Check for array literals and object expressions
-    if (node.type === 'ArrayExpression' || node.type === 'ObjectExpression') {
+    // Check for object expressions (always mutable)
+    if (node.type === 'ObjectExpression') {
         return true;
     }
+    // Check array literals - mutable if empty or if they contain mutable values
+    if (node.type === 'ArrayExpression') {
+        // Empty arrays are mutable since they can be modified later
+        if (node.elements.length === 0)
+            return true;
+        // Arrays with spread elements are mutable
+        if (node.elements.some(element => !element || element.type === 'SpreadElement'))
+            return true;
+        // Arrays with non-immutable values are mutable
+        return node.elements.some(element => !isImmutableValue(element));
+    }
     // Check for new expressions (e.g., new Map(), new Set())
     if (node.type === 'NewExpression') {
         return true;

package/lib/rules/global-const-style.d.ts

@@ -1,5 +1,3 @@
-import { TSESTree } from '@typescript-eslint/utils';
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"upperSnakeCase" | "asConst", never[], {
-    VariableDeclaration(node: TSESTree.VariableDeclaration): void;
-}>;
+type MessageIds = 'upperSnakeCase' | 'asConst';
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export default _default;

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,23 +108,53 @@ 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
+                            // Skip regular expressions as they are already immutable
+                            if (node.type === utils_1.AST_NODE_TYPES.Literal && 'regex' in node) {
+                                return false;
+                            }
                             return (node.type === utils_1.AST_NODE_TYPES.Literal ||
                                 node.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
                                 node.type === utils_1.AST_NODE_TYPES.ObjectExpression);
                         };
                         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.js

@@ -5,7 +5,7 @@ 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()}`);
+    return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
 }
 // Normalize property name to kebab-case for consistent lookup
 function normalizePropertyName(name) {
@@ -38,7 +38,7 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
         type: 'suggestion',
         docs: {
             description: 'Warn when using CSS properties that trigger compositing layers',
-            recommended: 'warn',
+            recommended: 'error',
         },
         schema: [],
         messages: {
@@ -49,10 +49,10 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
     create(context) {
         const seenNodes = new WeakSet();
         function checkPropertyValue(value) {
-            return COMPOSITING_VALUES.has(value) ||
+            return (COMPOSITING_VALUES.has(value) ||
                 value.includes('translate3d') ||
                 value.includes('scale3d') ||
-                value.includes('translateZ');
+                value.includes('translateZ'));
         }
         function checkProperty(propertyName, propertyValue) {
             const normalizedName = normalizePropertyName(propertyName);
@@ -73,11 +73,45 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
             }
             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

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-explicit-return-type.d.ts

@@ -0,0 +1,11 @@
+type Options = [
+    {
+        allowRecursiveFunctions?: boolean;
+        allowOverloadedFunctions?: boolean;
+        allowInterfaceMethodSignatures?: boolean;
+        allowAbstractMethodSignatures?: boolean;
+        allowDtsFiles?: boolean;
+    }
+];
+export declare const noExplicitReturnType: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noExplicitReturnType", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};