@blumintinc/eslint-plugin-blumint 1.7.3 → 1.8.1

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-render-hits-memoization.js

@@ -21,63 +21,182 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const isReactComponent = (node) => {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            return /^[A-Z]/.test(node.name);
+        };
         const isMemoizedCall = (node) => {
             if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
                 return false;
-            const callee = node.callee;
-            if (callee.type !== utils_1.AST_NODE_TYPES.Identifier)
-                return false;
-            return callee.name === 'useCallback' || callee.name === 'useMemo';
-        };
-        const isReactComponent = (node) => {
-            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+            if (!node.callee || node.callee.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return false;
-            const name = node.name;
-            return /^[A-Z]/.test(name);
+            return (node.callee.name === 'useCallback' || node.callee.name === 'useMemo');
         };
         const isMemoizedVariable = (node) => {
             if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return false;
             // Get the variable declaration for this identifier
-            const variable = context.getScope().variables.find(v => v.name === node.name);
+            const variable = context
+                .getScope()
+                .variables.find((v) => v.name === node.name);
             if (!variable)
                 return false;
             // Check if the variable is initialized with a memoized call
-            const def = variable.defs[0];
-            if (!def || !def.node)
-                return false;
-            if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator && def.node.init) {
-                return isMemoizedCall(def.node.init);
+            for (const def of variable.defs) {
+                if (!def || !def.node)
+                    continue;
+                if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    def.node.init) {
+                    if (isMemoizedCall(def.node.init)) {
+                        return true;
+                    }
+                }
             }
             return false;
         };
         const isInsideMemoizedCall = (node) => {
+            // Handle the case when node is already a memoized call
+            if (isMemoizedCall(node))
+                return true;
             // Check if the node is a reference to a memoized variable
             if (isMemoizedVariable(node))
                 return true;
             // Check if the node is inside a memoization hook call
             let current = node;
             while (current?.parent) {
-                if (isMemoizedCall(current.parent))
-                    return true;
+                if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const callee = current.parent.callee;
+                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        (callee.name === 'useCallback' || callee.name === 'useMemo')) {
+                        return true;
+                    }
+                }
                 current = current.parent;
             }
+            // Check if the node is a reference to a memoized value
+            const scope = context.getScope();
+            // Make sure node is an Identifier before accessing name property
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            const variable = scope.variables.find((v) => v.name === node.name);
+            if (!variable) {
+                return false;
+            }
+            // Check if any definition is a memoized value
+            for (const def of variable.defs) {
+                const parent = def.node.parent;
+                if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.init?.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const callee = parent.init.callee;
+                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        (callee.name === 'useCallback' || callee.name === 'useMemo')) {
+                        return true;
+                    }
+                }
+            }
+            // Check if any reference is inside a memoized call
+            for (const ref of variable.references) {
+                let current = ref.identifier;
+                while (current?.parent) {
+                    if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                        const callee = current.parent.callee;
+                        if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            (callee.name === 'useCallback' || callee.name === 'useMemo')) {
+                            return true;
+                        }
+                    }
+                    current = current.parent;
+                }
+            }
+            // Check if the node is a property of an object that is memoized
+            const parent = node.parent;
+            if (parent?.type === utils_1.AST_NODE_TYPES.Property &&
+                parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                const objectExpression = parent.parent;
+                let current = objectExpression;
+                while (current?.parent) {
+                    if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                        const callee = current.parent.callee;
+                        if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            (callee.name === 'useCallback' || callee.name === 'useMemo')) {
+                            return true;
+                        }
+                    }
+                    current = current.parent;
+                }
+            }
             return false;
         };
+        let useRenderHitsName = 'useRenderHits';
+        let renderHitsName = 'renderHits';
         return {
+            ImportDeclaration(node) {
+                if (node.source.value.endsWith('useRenderHits')) {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.imported.name === 'useRenderHits') {
+                            useRenderHitsName = specifier.local.name;
+                            break;
+                        }
+                    }
+                }
+                else if (node.source.value.endsWith('renderHits')) {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.imported.name === 'renderHits') {
+                            renderHitsName = specifier.local.name;
+                            break;
+                        }
+                    }
+                }
+            },
             CallExpression(node) {
-                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier && node.callee.name === 'useRenderHits') {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === useRenderHitsName) {
                     if (node.arguments.length === 0)
                         return;
                     const options = node.arguments[0];
                     if (options.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
                         return;
+                    // Variable to track if we need to check properties (check both by default)
+                    const checkProps = {
+                        transformBefore: true,
+                        render: true,
+                    };
+                    // First pass: Check if transformBefore or render properties exist as shorthand
                     for (const prop of options.properties) {
                         if (prop.type !== utils_1.AST_NODE_TYPES.Property)
                             continue;
                         if (prop.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                             continue;
-                        if (prop.key.name === 'transformBefore') {
+                        // If it's shorthand property syntax like { transformBefore } and already a memoized variable
+                        if (prop.key.name === 'transformBefore' &&
+                            prop.shorthand &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            checkProps.transformBefore = !isMemoizedVariable(prop.key);
+                        }
+                        else if (prop.key.name === 'render' &&
+                            prop.shorthand &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            checkProps.render = !isMemoizedVariable(prop.key);
+                        }
+                    }
+                    // Second pass: Check non-shorthand properties
+                    for (const prop of options.properties) {
+                        if (prop.type !== utils_1.AST_NODE_TYPES.Property)
+                            continue;
+                        if (prop.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                            continue;
+                        // Skip shorthand properties that we already checked
+                        if (prop.shorthand)
+                            continue;
+                        if (prop.key.name === 'transformBefore' &&
+                            checkProps.transformBefore) {
+                            // Skip if the value is already a memoized call
+                            if (isMemoizedCall(prop.value))
+                                continue;
                             if (!isInsideMemoizedCall(prop.value)) {
                                 context.report({
                                     node: prop.value,
@@ -85,7 +204,7 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
                                 });
                             }
                         }
-                        if (prop.key.name === 'render') {
+                        else if (prop.key.name === 'render' && checkProps.render) {
                             if (isReactComponent(prop.value)) {
                                 context.report({
                                     node: prop.value,
@@ -101,13 +220,23 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
                         }
                     }
                 }
-                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier && node.callee.name === 'renderHits') {
-                    if (!isInsideMemoizedCall(node)) {
-                        context.report({
-                            node,
-                            messageId: 'requireMemoizedRenderHits',
-                        });
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === renderHitsName) {
+                    let current = node;
+                    while (current?.parent) {
+                        if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                            const callee = current.parent.callee;
+                            if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                (callee.name === 'useCallback' || callee.name === 'useMemo')) {
+                                return;
+                            }
+                        }
+                        current = current.parent;
                     }
+                    context.report({
+                        node,
+                        messageId: 'requireMemoizedRenderHits',
+                    });
                 }
             },
         };

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'))
+                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-timestamp-now.d.ts

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