@blumintinc/eslint-plugin-blumint 1.1.9 → 1.2.1

package/lib/rules/prefer-settings-object.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferSettingsObject = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = {
+    minimumParameters: 3,
+    checkSameTypeParameters: true,
+    ignoreBoundMethods: true,
+    ignoreVariadicFunctions: true,
+};
+exports.preferSettingsObject = (0, createRule_1.createRule)({
+    name: 'prefer-settings-object',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using a settings object for functions with multiple parameters',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    minimumParameters: {
+                        type: 'number',
+                        minimum: 2,
+                    },
+                    checkSameTypeParameters: {
+                        type: 'boolean',
+                    },
+                    ignoreBoundMethods: {
+                        type: 'boolean',
+                    },
+                    ignoreVariadicFunctions: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            tooManyParams: 'Function has too many parameters ({{count}}). Use a settings object instead.',
+            sameTypeParams: 'Function has multiple parameters of the same type. Use a settings object instead.',
+        },
+    },
+    defaultOptions: [defaultOptions],
+    create(context, [options]) {
+        const finalOptions = { ...defaultOptions, ...options };
+        function getParameterType(param) {
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+                const typeNode = param.typeAnnotation.typeAnnotation;
+                if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                    return typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? typeNode.typeName.name
+                        : 'unknown';
+                }
+                return typeNode.type;
+            }
+            return 'unknown';
+        }
+        function hasSameTypeParameters(params) {
+            const typeMap = new Map();
+            for (const param of params) {
+                const type = getParameterType(param);
+                typeMap.set(type, (typeMap.get(type) || 0) + 1);
+                if (typeMap.get(type) > 1) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function shouldIgnoreNode(node) {
+            // Ignore variadic functions if configured
+            if (finalOptions.ignoreVariadicFunctions) {
+                const hasRestParam = node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+                    node.params.some(param => param.type === utils_1.AST_NODE_TYPES.RestElement);
+                if (hasRestParam)
+                    return true;
+            }
+            // Ignore bound methods if configured
+            if (finalOptions.ignoreBoundMethods) {
+                let parent = node.parent;
+                while (parent) {
+                    if (parent.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                        parent.type === utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration) {
+                        return true;
+                    }
+                    parent = parent.parent;
+                }
+            }
+            return false;
+        }
+        function checkFunction(node) {
+            if (shouldIgnoreNode(node))
+                return;
+            const params = node.params;
+            // Check for too many parameters
+            const minParams = finalOptions.minimumParameters !== undefined
+                ? finalOptions.minimumParameters
+                : defaultOptions.minimumParameters;
+            if (params.length >= minParams) {
+                context.report({
+                    node,
+                    messageId: 'tooManyParams',
+                    data: { count: params.length },
+                });
+                return;
+            }
+            // Check for same type parameters if enabled
+            if (finalOptions.checkSameTypeParameters && params.length >= 2) {
+                if (hasSameTypeParameters(params)) {
+                    context.report({
+                        node,
+                        messageId: 'sameTypeParams',
+                    });
+                }
+            }
+        }
+        return {
+            FunctionDeclaration: checkFunction,
+            FunctionExpression: checkFunction,
+            ArrowFunctionExpression: checkFunction,
+            TSMethodSignature: checkFunction,
+            TSFunctionType: checkFunction,
+        };
+    },
+});
+//# sourceMappingURL=prefer-settings-object.js.map

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-overlayed.js

@@ -7,6 +7,7 @@ module.exports = (0, createRule_1.createRule)({
         docs: {
             description: 'Enforce using ImageOverlayed component instead of next/image or img tags',
             recommended: 'error',
+            requiresTypeChecking: false,
         },
         fixable: 'code',
         schema: [
@@ -15,6 +16,7 @@ module.exports = (0, createRule_1.createRule)({
                 properties: {
                     componentPath: {
                         type: 'string',
+                        description: 'The import path for the ImageOverlayed component',
                         default: 'src/components/ImageOverlayed',
                     },
                 },

package/lib/rules/use-custom-memo.d.ts

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

package/lib/rules/use-custom-memo.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCustomMemo = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.useCustomMemo = (0, createRule_1.createRule)({
+    name: 'use-custom-memo',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using src/util/memo instead of React memo',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useCustomMemo: 'Import memo from src/util/memo instead of react',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === 'react') {
+                    const specifiers = node.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        specifier.imported.name === 'memo');
+                    if (specifiers.length > 0) {
+                        context.report({
+                            node,
+                            messageId: 'useCustomMemo',
+                            fix(fixer) {
+                                // If there are other imports from react, keep them
+                                const otherSpecifiers = node.specifiers.filter((specifier) => specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier ||
+                                    (specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                        specifier.imported.name !== 'memo'));
+                                if (otherSpecifiers.length === 0) {
+                                    // If memo is the only import, replace the entire import
+                                    return fixer.replaceText(node, `import { ${specifiers
+                                        .map((s) => s.local.name !== s.imported.name
+                                        ? `memo as ${s.local.name}`
+                                        : 'memo')
+                                        .join(', ')} } from 'src/util/memo';`);
+                                }
+                                else {
+                                    // Create a new import for memo and keep other imports
+                                    const memoImport = `import { ${specifiers
+                                        .map((s) => s.local.name !== s.imported.name
+                                        ? `memo as ${s.local.name}`
+                                        : 'memo')
+                                        .join(', ')} } from 'src/util/memo';\n`;
+                                    const otherImports = `import { ${otherSpecifiers
+                                        .map((s) => s.local.name)
+                                        .join(', ')} } from 'react';`;
+                                    return fixer.replaceText(node, memoImport + otherImports);
+                                }
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=use-custom-memo.js.map

package/lib/utils/ASTHelpers.js

@@ -91,6 +91,20 @@ class ASTHelpers {
                 return node.expressions.some((expr) => this.declarationIncludesIdentifier(expr));
             case 'TSAsExpression':
                 return this.declarationIncludesIdentifier(node.expression);
+            case 'TSTypeReference':
+                // Handle type references (e.g., T in generic types)
+                return false;
+            case 'TSTypeParameterDeclaration':
+                // Handle type parameter declarations (e.g., <T extends ...>)
+                return false;
+            case 'TSTypeParameterInstantiation':
+                // Handle type parameter instantiations (e.g., <string>)
+                return false;
+            case 'TSIntersectionType':
+            case 'TSUnionType':
+            case 'TSTypeLiteral':
+                // Handle type constraints and literals
+                return false;
             default:
                 return false;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.1.9",
+  "version": "1.2.1",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",