@blumintinc/eslint-plugin-blumint 1.2.0 → 1.3.0

package/lib/rules/no-explicit-return-type.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noExplicitReturnType = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = {
+    allowRecursiveFunctions: true,
+    allowOverloadedFunctions: true,
+    allowInterfaceMethodSignatures: true,
+    allowAbstractMethodSignatures: true,
+    allowDtsFiles: true,
+};
+function isRecursiveFunction(node) {
+    const functionName = node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ? node.id?.name :
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression && node.id ? node.id.name :
+            undefined;
+    if (!functionName || !node.body)
+        return false;
+    let hasRecursiveCall = false;
+    function checkNode(node) {
+        if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.callee.name === functionName) {
+            hasRecursiveCall = true;
+            return;
+        }
+        // Only traverse specific node types to avoid circular references
+        if (node.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+            node.body.forEach(checkNode);
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+            checkNode(node.expression);
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            checkNode(node.callee);
+            node.arguments.forEach(checkNode);
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+            checkNode(node.left);
+            checkNode(node.right);
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.ReturnStatement && node.argument) {
+            checkNode(node.argument);
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.IfStatement) {
+            checkNode(node.test);
+            checkNode(node.consequent);
+            if (node.alternate) {
+                checkNode(node.alternate);
+            }
+        }
+    }
+    checkNode(node.body);
+    return hasRecursiveCall;
+}
+function isOverloadedFunction(node) {
+    if (!node.parent)
+        return false;
+    if (node.type === utils_1.AST_NODE_TYPES.TSMethodSignature) {
+        const interfaceBody = node.parent;
+        if (interfaceBody.type !== utils_1.AST_NODE_TYPES.TSInterfaceBody)
+            return false;
+        const methodName = node.key.type === utils_1.AST_NODE_TYPES.Identifier ? node.key.name : undefined;
+        if (!methodName)
+            return false;
+        return interfaceBody.body.filter(member => member.type === utils_1.AST_NODE_TYPES.TSMethodSignature &&
+            member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+            member.key.name === methodName).length > 1;
+    }
+    return false;
+}
+function isInterfaceOrAbstractMethodSignature(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.TSMethodSignature)
+        return true;
+    if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+        let current = node;
+        while (current) {
+            if (current.type === utils_1.AST_NODE_TYPES.ClassDeclaration && current.abstract) {
+                return true;
+            }
+            current = current.parent;
+        }
+    }
+    return false;
+}
+exports.noExplicitReturnType = (0, createRule_1.createRule)({
+    name: 'no-explicit-return-type',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow explicit return types on functions',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowRecursiveFunctions: { type: 'boolean' },
+                    allowOverloadedFunctions: { type: 'boolean' },
+                    allowInterfaceMethodSignatures: { type: 'boolean' },
+                    allowAbstractMethodSignatures: { type: 'boolean' },
+                    allowDtsFiles: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noExplicitReturnType: 'Explicit return type is not allowed. Let TypeScript infer it.',
+        },
+    },
+    defaultOptions: [defaultOptions],
+    create(context, [options]) {
+        const mergedOptions = { ...defaultOptions, ...options };
+        const filename = context.getFilename();
+        if (mergedOptions.allowDtsFiles && filename.endsWith('.d.ts')) {
+            return {};
+        }
+        function fixReturnType(fixer, node) {
+            const returnType = node.returnType || node.value?.returnType;
+            if (!returnType)
+                return null;
+            // Create a fix that removes the return type annotation
+            return fixer.remove(returnType);
+        }
+        return {
+            FunctionDeclaration(node) {
+                if (!node.returnType)
+                    return;
+                if (mergedOptions.allowRecursiveFunctions && isRecursiveFunction(node)) {
+                    return;
+                }
+                context.report({
+                    node: node.returnType,
+                    messageId: 'noExplicitReturnType',
+                    fix: fixer => fixReturnType(fixer, node),
+                });
+            },
+            FunctionExpression(node) {
+                if (!node.returnType)
+                    return;
+                if (mergedOptions.allowRecursiveFunctions && isRecursiveFunction(node)) {
+                    return;
+                }
+                context.report({
+                    node: node.returnType,
+                    messageId: 'noExplicitReturnType',
+                    fix: fixer => fixReturnType(fixer, node),
+                });
+            },
+            ArrowFunctionExpression(node) {
+                if (!node.returnType)
+                    return;
+                context.report({
+                    node: node.returnType,
+                    messageId: 'noExplicitReturnType',
+                    fix: fixer => fixReturnType(fixer, node),
+                });
+            },
+            TSMethodSignature(node) {
+                if (!node.returnType)
+                    return;
+                if (mergedOptions.allowInterfaceMethodSignatures) {
+                    return;
+                }
+                if (mergedOptions.allowOverloadedFunctions && isOverloadedFunction(node)) {
+                    return;
+                }
+                context.report({
+                    node: node.returnType,
+                    messageId: 'noExplicitReturnType',
+                    fix: fixer => fixReturnType(fixer, node),
+                });
+            },
+            MethodDefinition(node) {
+                if (!node.value.returnType)
+                    return;
+                if (mergedOptions.allowAbstractMethodSignatures && isInterfaceOrAbstractMethodSignature(node)) {
+                    return;
+                }
+                context.report({
+                    node: node.value.returnType,
+                    messageId: 'noExplicitReturnType',
+                    fix: fixer => fixReturnType(fixer, node),
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-explicit-return-type.js.map

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-type-over-interface.js

@@ -8,7 +8,7 @@ exports.preferTypeOverInterface = (0, createRule_1.createRule)({
         type: 'suggestion',
         docs: {
             description: 'Prefer using type alias over interface',
-            recommended: 'warn',
+            recommended: 'error',
         },
         schema: [],
         messages: {

package/lib/rules/require-https-error.js

@@ -42,30 +42,39 @@ module.exports = (0, createRule_1.createRule)({
                 }
             },
             ThrowStatement(node) {
+                if (!node.argument) {
+                    return;
+                }
                 const argument = node.argument;
-                if (argument &&
-                    argument.type === utils_1.AST_NODE_TYPES.NewExpression &&
-                    argument.callee) {
-                    if (argument.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        argument.callee.name === 'Error') {
-                        context.report({
-                            node,
-                            messageId: 'useHttpsError',
-                        });
-                    }
-                    else if (hasFirebaseAdminImport &&
-                        ((argument.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            argument.callee.name === 'HttpsError') ||
-                            (argument.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                                argument.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                argument.callee.object.name === httpsIdentifier &&
-                                argument.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                argument.callee.property.name === 'HttpsError'))) {
-                        context.report({
-                            node,
-                            messageId: 'useProprietaryHttpsError',
-                        });
-                    }
+                if (argument.type !== utils_1.AST_NODE_TYPES.NewExpression) {
+                    return;
+                }
+                const callee = argument.callee;
+                // Check for direct Error usage
+                if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    callee.name === 'Error') {
+                    context.report({
+                        node,
+                        messageId: 'useHttpsError',
+                    });
+                    return;
+                }
+                // Check for firebase-admin HttpsError usage
+                if (!hasFirebaseAdminImport) {
+                    return;
+                }
+                const isHttpsError = callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    callee.name === 'HttpsError';
+                const isFirebaseHttpsError = callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    callee.object.name === httpsIdentifier &&
+                    callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    callee.property.name === 'HttpsError';
+                if (isHttpsError || isFirebaseHttpsError) {
+                    context.report({
+                        node,
+                        messageId: 'useProprietaryHttpsError',
+                    });
                 }
             },
         };

package/lib/rules/require-image-optimized.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"useImageOptimized", {
+    componentPath: string;
+}[], {
+    JSXElement(node: any): void;
+    ImportDeclaration(node: any): void;
+}>;
+export = _default;

package/lib/rules/require-image-optimized.js

@@ -0,0 +1,82 @@
+"use strict";
+const createRule_1 = require("../utils/createRule");
+module.exports = (0, createRule_1.createRule)({
+    name: 'require-image-optimized',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce using ImageOptimized component instead of next/image or img tags',
+            recommended: 'error',
+            requiresTypeChecking: false,
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    componentPath: {
+                        type: 'string',
+                        description: 'The import path for the ImageOptimized component',
+                        default: 'src/components/image/ImageOptimized',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            useImageOptimized: 'Use ImageOptimized component from {{ componentPath }} instead of {{ component }}',
+        },
+    },
+    defaultOptions: [{ componentPath: 'src/components/image/ImageOptimized' }],
+    create(context) {
+        const options = context.options[0] || {
+            componentPath: 'src/components/image/ImageOptimized',
+        };
+        const sourceCode = context.getSourceCode();
+        return {
+            // Handle JSX img elements
+            JSXElement(node) {
+                if (node.openingElement.name.name === 'img') {
+                    context.report({
+                        node,
+                        messageId: 'useImageOptimized',
+                        data: {
+                            componentPath: options.componentPath,
+                            component: 'img tag',
+                        },
+                        fix(fixer) {
+                            const attributes = node.openingElement.attributes
+                                .map((attr) => sourceCode.getText(attr))
+                                .join(' ');
+                            return fixer.replaceText(node, `<ImageOptimized ${attributes} />`);
+                        },
+                    });
+                }
+            },
+            // Handle next/image imports and usage
+            ImportDeclaration(node) {
+                if (node.source.value === 'next/image' && node.specifiers.length > 0) {
+                    const imageSpecifier = node.specifiers.find((spec) => (spec.type === 'ImportDefaultSpecifier' ||
+                        spec.type === 'ImportSpecifier') &&
+                        (spec.local.name === 'Image' || spec.imported?.name === 'Image'));
+                    if (imageSpecifier) {
+                        const localName = imageSpecifier.local.name;
+                        // Report the import
+                        context.report({
+                            node,
+                            messageId: 'useImageOptimized',
+                            data: {
+                                componentPath: options.componentPath,
+                                component: 'next/image',
+                            },
+                            fix(fixer) {
+                                return fixer.replaceText(node, `import ${localName} from '${options.componentPath}';`);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-image-optimized.js.map

package/lib/rules/semantic-function-prefixes.d.ts

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

package/lib/rules/semantic-function-prefixes.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.semanticFunctionPrefixes = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const DISALLOWED_PREFIXES = new Set(['get', 'update', 'check', 'manage', 'process', 'do']);
+const SUGGESTED_ALTERNATIVES = {
+    get: ['fetch', 'retrieve', 'compute', 'derive'],
+    update: ['modify', 'set', 'apply'],
+    check: ['validate', 'assert', 'ensure'],
+    manage: ['control', 'coordinate', 'schedule'],
+    process: ['transform', 'sanitize', 'compute'],
+    do: ['execute', 'perform', 'apply'],
+};
+exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
+    name: 'semantic-function-prefixes',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce semantic function prefixes over generic ones like "get" and "update"',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            avoidGenericPrefix: 'Avoid using generic prefix "{{prefix}}". Consider using one of these alternatives: {{alternatives}}',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function checkFunctionName(node) {
+            // Skip anonymous functions
+            if (!node.id && node.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                return;
+            }
+            // Get function name from either the function declaration or variable declarator
+            let functionName = '';
+            if (node.id) {
+                functionName = node.id.name;
+            }
+            else if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                functionName = node.parent.id.name;
+            }
+            if (!functionName)
+                return;
+            // Skip if function starts with 'is' (boolean check functions are okay)
+            if (functionName.startsWith('is'))
+                return;
+            // Skip class getters
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition && node.parent.kind === 'get') {
+                return;
+            }
+            // Check for disallowed prefixes
+            for (const prefix of DISALLOWED_PREFIXES) {
+                if (functionName.toLowerCase().startsWith(prefix.toLowerCase())) {
+                    context.report({
+                        node: node.id || node,
+                        messageId: 'avoidGenericPrefix',
+                        data: {
+                            prefix,
+                            alternatives: SUGGESTED_ALTERNATIVES[prefix].join(', '),
+                        },
+                    });
+                    break;
+                }
+            }
+        }
+        return {
+            FunctionDeclaration: checkFunctionName,
+            FunctionExpression: checkFunctionName,
+            ArrowFunctionExpression: checkFunctionName,
+        };
+    },
+});
+//# sourceMappingURL=semantic-function-prefixes.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",
@@ -45,6 +45,7 @@
     "commitlint": "commitlint --edit"
   },
   "dependencies": {
+    "compromise": "14.14.4",
     "requireindex": "1.2.0"
   },
   "devDependencies": {