@blumintinc/eslint-plugin-blumint 1.1.3 → 1.1.4

package/lib/index.js

@@ -33,10 +33,11 @@ const use_custom_router_1 = require("./rules/use-custom-router");
 const require_image_overlayed_1 = __importDefault(require("./rules/require-image-overlayed"));
 const require_usememo_object_literals_1 = require("./rules/require-usememo-object-literals");
 const enforce_safe_stringify_1 = require("./rules/enforce-safe-stringify");
+const avoid_utils_directory_1 = require("./rules/avoid-utils-directory");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.1.3',
+        version: '1.1.4',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -45,6 +46,7 @@ module.exports = {
         recommended: {
             plugins: ['@blumintinc/blumint'],
             rules: {
+                '@blumintinc/blumint/avoid-utils-directory': 'error',
                 '@blumintinc/blumint/no-jsx-whitespace-literal': 'error',
                 '@blumintinc/blumint/array-methods-this-context': 'warn',
                 '@blumintinc/blumint/class-methods-read-top-to-bottom': 'warn',
@@ -109,6 +111,7 @@ module.exports = {
         'require-image-overlayed': require_image_overlayed_1.default,
         'require-usememo-object-literals': require_usememo_object_literals_1.requireUseMemoObjectLiterals,
         'enforce-safe-stringify': enforce_safe_stringify_1.enforceStableStringify,
+        'avoid-utils-directory': avoid_utils_directory_1.avoidUtilsDirectory,
     },
 };
 //# sourceMappingURL=index.js.map

package/lib/rules/avoid-utils-directory.d.ts

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

package/lib/rules/avoid-utils-directory.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.avoidUtilsDirectory = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.avoidUtilsDirectory = (0, createRule_1.createRule)({
+    name: 'avoid-utils-directory',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using util/ instead of utils/ directory',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            avoidUtils: 'Use "util/" directory instead of "utils/"',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            Program(node) {
+                const filename = context.getFilename();
+                // Skip files in node_modules
+                if (filename.includes('node_modules')) {
+                    return;
+                }
+                // Match /utils/ directory (case insensitive) but not as part of another word
+                const utilsPattern = /(?:^|\/)utils\/(?!.*\/)/i;
+                if (utilsPattern.test(filename)) {
+                    context.report({
+                        node,
+                        messageId: 'avoidUtils',
+                        fix() {
+                            // We can't provide an auto-fix since directory renaming is beyond ESLint's scope
+                            return null;
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=avoid-utils-directory.js.map

package/lib/rules/consistent-callback-naming.js

@@ -1,5 +1,29 @@
 "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;
+};
 const createRule_1 = require("../utils/createRule");
+const ts = __importStar(require("typescript"));
 module.exports = (0, createRule_1.createRule)({
     name: 'consistent-callback-naming',
     meta: {
@@ -23,6 +47,29 @@ module.exports = (0, createRule_1.createRule)({
             throw new Error('You have to enable the `project` setting in parser options to use this rule');
         }
         const checker = parserServices.program.getTypeChecker();
+        function isReactComponentType(node) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            const symbol = type.getSymbol();
+            if (!symbol)
+                return false;
+            // Check if type is a React component type
+            const isComponent = symbol.declarations?.some((decl) => {
+                const declaration = decl;
+                if (ts.isClassDeclaration(declaration) ||
+                    ts.isInterfaceDeclaration(declaration)) {
+                    const name = declaration.name?.text ?? '';
+                    return (
+                    // Check for common React component patterns
+                    name.includes('Component') ||
+                        name.includes('Element') ||
+                        name.includes('FC') ||
+                        name.includes('FunctionComponent'));
+                }
+                return false;
+            });
+            return isComponent || false;
+        }
         function isFunctionType(node) {
             const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
             const type = checker.getTypeAtLocation(tsNode);
@@ -38,10 +85,11 @@ module.exports = (0, createRule_1.createRule)({
                     if (propName?.match(/^on[A-Z]/)) {
                         return;
                     }
-                    // Check if the value is a function type
+                    // Check if the value is a function type and not a React component
                     if (isFunctionType(node.value.expression) &&
                         propName &&
-                        !propName.startsWith('on')) {
+                        !propName.startsWith('on') &&
+                        !isReactComponentType(node.value.expression)) {
                         context.report({
                             node,
                             messageId: 'callbackPropPrefix',

package/lib/rules/enforce-identifiable-firestore-type.js

@@ -63,25 +63,50 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
             TSTypeAliasDeclaration(node) {
                 if (node.id.name === folderName) {
                     hasExpectedType = true;
-                    // Check if type extends Identifiable
-                    const checkIdentifiableExtension = (type) => {
-                        // Check for direct Identifiable extension
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                            type.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            type.typeName.name === 'Identifiable') {
-                            return true;
-                        }
-                        // Check intersection types
-                        if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            return type.types.some(checkIdentifiableExtension);
+                    // Find Identifiable in type's dependencies
+                    const findIdentifiable = (type, checkedTypes = new Set()) => {
+                        if (!type)
+                            return false;
+                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference && type.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const typeName = type.typeName.name;
+                            if (typeName === 'Identifiable') {
+                                return true;
+                            }
+                            if (!checkedTypes.has(typeName)) {
+                                checkedTypes.add(typeName);
+                                // Look for the type in all scopes
+                                const scope = context.getScope();
+                                const variable = scope.variables.find(v => v.name === typeName);
+                                if (variable) {
+                                    const def = variable.defs.find(d => d.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration);
+                                    if (def && 'typeAnnotation' in def.node && def.node.typeAnnotation) {
+                                        return findIdentifiable(def.node.typeAnnotation, checkedTypes);
+                                    }
+                                }
+                                // Try looking in the parent scope
+                                if (scope.upper) {
+                                    const parentVariable = scope.upper.variables.find(v => v.name === typeName);
+                                    if (parentVariable) {
+                                        const def = parentVariable.defs.find(d => d.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration);
+                                        if (def && 'typeAnnotation' in def.node && def.node.typeAnnotation) {
+                                            return findIdentifiable(def.node.typeAnnotation, checkedTypes);
+                                        }
+                                    }
+                                }
+                            }
                         }
-                        // Check generic type parameters
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                            type.typeParameters?.params) {
-                            return type.typeParameters.params.some(checkIdentifiableExtension);
+                        else if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            // For intersection types, check each part
+                            return type.types.some(part => findIdentifiable(part, checkedTypes));
                         }
                         return false;
                     };
+                    // Check if type extends Identifiable
+                    const checkIdentifiableExtension = (type) => {
+                        if (!type)
+                            return false;
+                        return findIdentifiable(type);
+                    };
                     // Check if type has id: string field
                     const checkIdField = (type) => {
                         // Check for id: string field in type literal

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

@@ -19,6 +19,40 @@ function isFunctionDefinition(node) {
     return (node?.type === 'FunctionExpression' ||
         node?.type === 'ArrowFunctionExpression');
 }
+function isMutableValue(node) {
+    if (!node)
+        return false;
+    // Check for array literals and object expressions
+    if (node.type === 'ArrayExpression' || node.type === 'ObjectExpression') {
+        return true;
+    }
+    // Check for new expressions (e.g., new Map(), new Set())
+    if (node.type === 'NewExpression') {
+        return true;
+    }
+    // Check for array/object methods that return mutable values
+    if (node.type === 'CallExpression') {
+        const callee = node.callee;
+        if (callee.type === 'MemberExpression') {
+            const methodName = callee.property.name;
+            const mutatingMethods = [
+                'slice',
+                'map',
+                'filter',
+                'concat',
+                'from',
+                'reduce',
+                'flatMap',
+                'splice',
+                'reverse',
+                'sort',
+                'fill'
+            ];
+            return mutatingMethods.includes(methodName);
+        }
+    }
+    return false;
+}
 exports.extractGlobalConstants = (0, createRule_1.createRule)({
     create(context) {
         return {
@@ -26,8 +60,8 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                 if (node.kind !== 'const') {
                     return;
                 }
-                // Skip if any of the declarations are function definitions
-                if (node.declarations.some((d) => isFunctionDefinition(d.init))) {
+                // Skip if any of the declarations are function definitions or mutable values
+                if (node.declarations.some((d) => isFunctionDefinition(d.init) || isMutableValue(d.init))) {
                     return;
                 }
                 const scope = context.getScope();

package/package.json

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