@blumintinc/eslint-plugin-blumint 1.6.0 → 1.7.1

package/lib/rules/enforce-exported-function-types.js

@@ -91,6 +91,7 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
         }
         function isBuiltInType(typeName) {
             const builtInTypes = new Set([
+                // Primitive types
                 'string',
                 'number',
                 'boolean',
@@ -101,6 +102,9 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
                 'never',
                 'unknown',
                 'object',
+                'symbol',
+                'bigint',
+                // Built-in objects
                 'Date',
                 'RegExp',
                 'Error',
@@ -113,6 +117,259 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
                 'Set',
                 'WeakMap',
                 'WeakSet',
+                'Proxy',
+                'DataView',
+                'ArrayBuffer',
+                'SharedArrayBuffer',
+                'Atomics',
+                'Intl',
+                'JSON',
+                'Math',
+                'Reflect',
+                'WeakRef',
+                'FinalizationRegistry',
+                // TypeScript utility types
+                'Record',
+                'Partial',
+                'Required',
+                'Readonly',
+                'Pick',
+                'Omit',
+                'Exclude',
+                'Extract',
+                'NonNullable',
+                'Parameters',
+                'ConstructorParameters',
+                'ReturnType',
+                'InstanceType',
+                'ThisParameterType',
+                'OmitThisParameter',
+                'ThisType',
+                'Uppercase',
+                'Lowercase',
+                'Capitalize',
+                'Uncapitalize',
+                'Awaited',
+                'PropertyKey',
+                'Mutable',
+                'DeepPartial',
+                'DeepReadonly',
+                'DeepRequired',
+                'Merge',
+                'MergeExclusive',
+                'OptionalKeys',
+                'RequiredKeys',
+                'ReadonlyKeys',
+                'WritableKeys',
+                'UnionToIntersection',
+                'UnionToTuple',
+                'Promisable',
+                // React types
+                'ReactElement',
+                'ReactNode',
+                'ReactChild',
+                'ReactChildren',
+                'ReactFragment',
+                'ReactPortal',
+                'ReactText',
+                'JSX',
+                'JSXElement',
+                'JSXElementConstructor',
+                'ComponentType',
+                'ComponentProps',
+                'ComponentRef',
+                'ElementType',
+                'ElementRef',
+                'Ref',
+                'RefObject',
+                'RefCallback',
+                'LegacyRef',
+                'PropsWithRef',
+                'PropsWithChildren',
+                'PropsWithoutRef',
+                'FC',
+                'FunctionComponent',
+                'VFC',
+                'VoidFunctionComponent',
+                'ForwardRefRenderFunction',
+                'ForwardRefExoticComponent',
+                'MutableRefObject',
+                'ClassAttributes',
+                'DOMAttributes',
+                'CSSProperties',
+                'StyleHTMLAttributes',
+                'AriaAttributes',
+                'DOMElement',
+                'ReactHTML',
+                'ReactSVG',
+                // Node.js types
+                'Buffer',
+                'ReadableStream',
+                'WritableStream',
+                'DuplexStream',
+                'TransformStream',
+                'ReadStream',
+                'WriteStream',
+                'EventEmitter',
+                'Timeout',
+                'Immediate',
+                'NodeJS',
+                'Process',
+                'Global',
+                // DOM types
+                'HTMLElement',
+                'Element',
+                'Node',
+                'Document',
+                'Window',
+                'Event',
+                'CustomEvent',
+                'MouseEvent',
+                'KeyboardEvent',
+                'TouchEvent',
+                'DragEvent',
+                'ClipboardEvent',
+                'FocusEvent',
+                'FormEvent',
+                'ChangeEvent',
+                'AnimationEvent',
+                'TransitionEvent',
+                'SVGElement',
+                'File',
+                'FileList',
+                'Blob',
+                'URL',
+                'URLSearchParams',
+                'FormData',
+                'Headers',
+                'Request',
+                'Response',
+                'WebSocket',
+                'Worker',
+                'ServiceWorker',
+                'MessagePort',
+                'Storage',
+                'CSSStyleDeclaration',
+                // Common library types
+                'Observable',
+                'Subscription',
+                'Subject',
+                'BehaviorSubject',
+                'ReplaySubject',
+                'AsyncSubject',
+                'Observer',
+                'Operator',
+                'Scheduler',
+                'Unsubscribable',
+                'SubscriptionLike',
+                'TeardownLogic',
+                'MonoTypeOperatorFunction',
+                'OperatorFunction',
+                'UnaryFunction',
+                'Action',
+                'AnyAction',
+                'Dispatch',
+                'Reducer',
+                'Store',
+                'Middleware',
+                'Selector',
+                'ThunkAction',
+                'ThunkDispatch',
+                'Query',
+                'Mutation',
+                'QueryResult',
+                'MutationResult',
+                'UseQueryResult',
+                'UseMutationResult',
+                'UseInfiniteQueryResult',
+                'Schema',
+                'Model',
+                'Document',
+                'ObjectId',
+                'Collection',
+                'Db',
+                'Client',
+                'Session',
+                'Transaction',
+                'ValidationError',
+                'ValidationResult',
+                'Validator',
+                'Logger',
+                'LogLevel',
+                'Options',
+                'Settings',
+                'Context',
+                'Next',
+                'Middleware',
+                'Route',
+                'Router',
+                'Handler',
+                'Controller',
+                'Service',
+                'Repository',
+                'Entity',
+                'DTO',
+                'Enum',
+                'Union',
+                'Intersection',
+                'Tuple',
+                'Readonly',
+                'ReadonlyArray',
+                'ReadonlyMap',
+                'ReadonlySet',
+                'Iterable',
+                'Iterator',
+                'Generator',
+                'AsyncIterator',
+                'AsyncGenerator',
+                'Thenable',
+                'PromiseLike',
+                'ArrayLike',
+                'Indexable',
+                'Nullable',
+                'Optional',
+                'NonOptional',
+                'NonNullable',
+                'NonUndefined',
+                'NonVoid',
+                'NonEmptyArray',
+                'DeepReadonly',
+                'DeepPartial',
+                'DeepRequired',
+                'DeepNonNullable',
+                'DeepMutable',
+                'Primitive',
+                'Nullish',
+                'Falsy',
+                'Truthy',
+                'Exact',
+                'Strict',
+                'Loose',
+                'Writable',
+                'Mutable',
+                'Immutable',
+                'Frozen',
+                'Sealed',
+                'Extensible',
+                'Constructable',
+                'Abstract',
+                'Concrete',
+                'Override',
+                'Overwrite',
+                'OmitByValue',
+                'PickByValue',
+                'RequiredBy',
+                'OptionalBy',
+                'ReadonlyBy',
+                'MutableBy',
+                'NullableBy',
+                'NonNullableBy',
+                'UndefinedBy',
+                'NonUndefinedBy',
+                'NeverBy',
+                'UnknownBy',
+                'AnyBy',
+                'VoidBy',
             ]);
             return builtInTypes.has(typeName);
         }
@@ -135,7 +392,16 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
                 }
             }
         }
+        function checkAndReportParameterType(param, messageId) {
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+                checkAndReportType(param.typeAnnotation.typeAnnotation, param.typeAnnotation, messageId);
+            }
+        }
         function isTypeExported(typeName) {
+            // If it's a built-in type, consider it as "exported"
+            if (isBuiltInType(typeName)) {
+                return true;
+            }
             const sourceCode = context.getSourceCode();
             const program = sourceCode.ast;
             // Check for imported types first - if found, return true immediately
@@ -159,6 +425,11 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
                     if (node.declaration?.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
                         return node.declaration.id.name === typeName;
                     }
+                    // Check for export { Type } statements
+                    if (node.specifiers) {
+                        return node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ExportSpecifier &&
+                            specifier.local.name === typeName);
+                    }
                 }
                 return false;
             });
@@ -186,15 +457,49 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
             }
             // Handle type aliases in variable declarations
             if (parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                // Check if the type alias itself is exported
                 if (parent.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
                     return true;
                 }
+                // If not exported, return false
+                return false;
             }
             // Handle type aliases in interface declarations
             if (parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                // Check if the interface itself is exported
                 if (parent.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
                     return true;
                 }
+                // If not exported, return false
+                return false;
+            }
+            // Handle type aliases in variable declarations
+            if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                if (parent.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                    if (parent.parent.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                        return true;
+                    }
+                }
+            }
+            // Handle type aliases in type declarations
+            if (parent.type === utils_1.AST_NODE_TYPES.Identifier) {
+                if (parent.parent?.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                    // Check if the type alias itself is exported
+                    if (parent.parent.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                        return true;
+                    }
+                    // If not exported, return false
+                    return false;
+                }
+            }
+            // Handle type aliases in type declarations
+            if (def.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                // Check if the type alias itself is exported
+                if (def.node.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                    return true;
+                }
+                // If not exported, return false
+                return false;
             }
             return false;
         }
@@ -211,10 +516,7 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
                 }
                 // Check parameter types
                 node.params.forEach((param) => {
-                    if (param.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        param.typeAnnotation) {
-                        checkAndReportType(param.typeAnnotation.typeAnnotation, param.typeAnnotation, 'missingExportedType');
-                    }
+                    checkAndReportParameterType(param, 'missingExportedType');
                 });
             },
             'VariableDeclarator > ArrowFunctionExpression'(node) {
@@ -231,10 +533,7 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
                 }
                 // Check parameter types
                 node.params.forEach((param) => {
-                    if (param.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        param.typeAnnotation) {
-                        checkAndReportType(param.typeAnnotation.typeAnnotation, param.typeAnnotation, 'missingExportedType');
-                    }
+                    checkAndReportParameterType(param, 'missingExportedType');
                 });
             },
             // Handle React components

package/lib/rules/enforce-render-hits-memoization.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'requireMemoizedTransformBefore' | 'requireMemoizedRender' | 'requireMemoizedRenderHits' | 'noDirectComponentInRender';
+export declare const enforceRenderHitsMemoization: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/enforce-render-hits-memoization.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceRenderHitsMemoization = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
+    name: 'enforce-render-hits-memoization',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce proper memoization and usage of useRenderHits and renderHits',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            requireMemoizedTransformBefore: 'transformBefore prop must be memoized using useCallback',
+            requireMemoizedRender: 'render prop must be memoized using useCallback',
+            requireMemoizedRenderHits: 'renderHits must be used inside useMemo or useCallback',
+            noDirectComponentInRender: 'Do not pass React components directly to render prop, use a memoized arrow function instead',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        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)
+                return false;
+            const name = node.name;
+            return /^[A-Z]/.test(name);
+        };
+        const isInsideMemoizedCall = (node) => {
+            let current = node;
+            while (current?.parent) {
+                if (isMemoizedCall(current.parent))
+                    return true;
+                current = current.parent;
+            }
+            return false;
+        };
+        return {
+            CallExpression(node) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier && node.callee.name === 'useRenderHits') {
+                    if (node.arguments.length === 0)
+                        return;
+                    const options = node.arguments[0];
+                    if (options.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                        return;
+                    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 (!isInsideMemoizedCall(prop.value)) {
+                                context.report({
+                                    node: prop.value,
+                                    messageId: 'requireMemoizedTransformBefore',
+                                });
+                            }
+                        }
+                        if (prop.key.name === 'render') {
+                            if (isReactComponent(prop.value)) {
+                                context.report({
+                                    node: prop.value,
+                                    messageId: 'noDirectComponentInRender',
+                                });
+                            }
+                            else if (!isInsideMemoizedCall(prop.value)) {
+                                context.report({
+                                    node: prop.value,
+                                    messageId: 'requireMemoizedRender',
+                                });
+                            }
+                        }
+                    }
+                }
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier && node.callee.name === 'renderHits') {
+                    if (!isInsideMemoizedCall(node)) {
+                        context.report({
+                            node,
+                            messageId: 'requireMemoizedRenderHits',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-render-hits-memoization.js.map

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

@@ -69,6 +69,7 @@ const VERBS_SET = new Set([
     'auto',
     'avoid',
     'back',
+    'backfill',
     'backup',
     'bake',
     'balance',

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

@@ -40,6 +40,10 @@ function isImmutableValue(node) {
 function isMutableValue(node) {
     if (!node)
         return false;
+    // Check for JSX elements (always mutable due to props/context)
+    if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
+        return true;
+    }
     // Check for object expressions (always mutable)
     if (node.type === 'ObjectExpression') {
         return true;

package/lib/rules/no-entire-object-hook-deps.js

@@ -49,6 +49,12 @@ function getObjectUsagesInHook(hookBody, objectName) {
     const usages = new Set();
     const visited = new Set();
     let needsEntireObject = false;
+    // Built-in array methods that should not be considered as object properties
+    const ARRAY_METHODS = new Set([
+        'map', 'filter', 'reduce', 'forEach', 'some', 'every', 'find', 'findIndex',
+        'includes', 'indexOf', 'join', 'slice', 'splice', 'concat', 'push', 'pop',
+        'shift', 'unshift', 'sort', 'reverse', 'flat', 'flatMap'
+    ]);
     function buildAccessPath(node) {
         const parts = [];
         let current = node;
@@ -62,6 +68,10 @@ function getObjectUsagesInHook(hookBody, objectName) {
             if (memberExpr.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
                 return null;
             }
+            // Skip array methods
+            if (memberExpr.property.name && ARRAY_METHODS.has(memberExpr.property.name)) {
+                return null;
+            }
             parts.unshift(memberExpr.property.name);
             if (memberExpr.optional) {
                 hasOptionalChaining = true;

package/lib/rules/no-firestore-jest-mock.d.ts

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

package/lib/rules/no-firestore-jest-mock.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noFirestoreJestMock = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noFirestoreJestMock = (0, createRule_1.createRule)({
+    name: 'no-firestore-jest-mock',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent importing firestore-jest-mock in test files',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            noFirestoreJestMock: 'Do not import from firestore-jest-mock. Use mockFirestore from the centralized mock utility instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.getFilename();
+        // Only apply rule to test files
+        if (!filename.endsWith('.test.ts')) {
+            return {};
+        }
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === 'firestore-jest-mock') {
+                    context.report({
+                        node,
+                        messageId: 'noFirestoreJestMock',
+                        fix(fixer) {
+                            // Replace with mockFirestore import
+                            return fixer.replaceText(node, "import { mockFirestore } from '../../../../../__mocks__/functions/src/config/mockFirestore';");
+                        },
+                    });
+                }
+            },
+            CallExpression(node) {
+                // Check for jest.mock('firestore-jest-mock')
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.object.name === 'jest' &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'mock' &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.arguments[0].value === 'firestore-jest-mock') {
+                    context.report({
+                        node,
+                        messageId: 'noFirestoreJestMock',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-firestore-jest-mock.js.map

package/lib/rules/no-mock-firebase-admin.d.ts

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

package/lib/rules/no-mock-firebase-admin.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noMockFirebaseAdmin = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const FIREBASE_ADMIN_PATHS = [
+    '../../config/firebaseAdmin',
+    '../config/firebaseAdmin',
+    './config/firebaseAdmin',
+    'functions/src/config/firebaseAdmin',
+];
+exports.noMockFirebaseAdmin = (0, createRule_1.createRule)({
+    name: 'no-mock-firebase-admin',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent mocking of functions/src/config/firebaseAdmin',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noMockFirebaseAdmin: 'Do not mock firebaseAdmin directly. Use mockFirestore from __mocks__/functions/src/config/mockFirestore instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.object.name === 'jest' &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'mock' &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.arguments[0].value === 'string') {
+                    const mockPath = node.arguments[0].value;
+                    const isFirebaseAdminMock = FIREBASE_ADMIN_PATHS.some(path => mockPath.endsWith(path) || mockPath.includes('firebaseAdmin'));
+                    if (isFirebaseAdminMock) {
+                        context.report({
+                            node,
+                            messageId: 'noMockFirebaseAdmin',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-mock-firebase-admin.js.map