@blumintinc/eslint-plugin-blumint 1.7.0 → 1.7.1

package/lib/index.js

@@ -68,10 +68,11 @@ const no_mock_firebase_admin_1 = require("./rules/no-mock-firebase-admin");
 const enforce_centralized_mock_firestore_1 = require("./rules/enforce-centralized-mock-firestore");
 const require_hooks_default_params_1 = require("./rules/require-hooks-default-params");
 const prefer_destructuring_no_class_1 = require("./rules/prefer-destructuring-no-class");
+const enforce_render_hits_memoization_1 = require("./rules/enforce-render-hits-memoization");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.7.0',
+        version: '1.7.1',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -145,6 +146,7 @@ module.exports = {
                 '@blumintinc/blumint/enforce-centralized-mock-firestore': 'error',
                 '@blumintinc/blumint/require-hooks-default-params': 'error',
                 '@blumintinc/blumint/prefer-destructuring-no-class': 'error',
+                '@blumintinc/blumint/enforce-render-hits-memoization': 'error',
             },
         },
     },
@@ -214,6 +216,7 @@ module.exports = {
         'enforce-centralized-mock-firestore': enforce_centralized_mock_firestore_1.enforceCentralizedMockFirestore,
         'require-hooks-default-params': require_hooks_default_params_1.requireHooksDefaultParams,
         'prefer-destructuring-no-class': prefer_destructuring_no_class_1.preferDestructuringNoClass,
+        'enforce-render-hits-memoization': enforce_render_hits_memoization_1.enforceRenderHitsMemoization,
     },
 };
 //# sourceMappingURL=index.js.map

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/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/prefer-batch-operations.js

@@ -69,6 +69,40 @@ function findLoopNode(node) {
     }
     return undefined;
 }
+function isFirestoreSetterInstance(node) {
+    // Check if it's a DocSetter instance
+    if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
+        return (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.callee.name === 'DocSetter');
+    }
+    return false;
+}
+function isMapInstance(node) {
+    // Check if it's a Map instance
+    if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
+        return (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.callee.name === 'Map');
+    }
+    return false;
+}
+function findVariableDeclaration(node, varName) {
+    let current = node;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.Program) {
+            for (const statement of current.body) {
+                if (statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                    for (const decl of statement.declarations) {
+                        if (decl.id.type === utils_1.AST_NODE_TYPES.Identifier && decl.id.name === varName) {
+                            return decl;
+                        }
+                    }
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
 function isSetterMethodCall(node) {
     if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
         return { isValid: false };
@@ -84,6 +118,16 @@ function isSetterMethodCall(node) {
     if (object.type !== utils_1.AST_NODE_TYPES.Identifier)
         return { isValid: false };
     const setterInstance = object.name;
+    // Find the variable declaration
+    const decl = findVariableDeclaration(node, setterInstance);
+    if (!decl || !decl.init)
+        return { isValid: false };
+    // Skip if it's a Map instance
+    if (isMapInstance(decl.init))
+        return { isValid: false };
+    // Check if it's a Firestore setter instance
+    if (!isFirestoreSetterInstance(decl.init))
+        return { isValid: false };
     // Get the method name
     const methodName = callee.property.name;
     return { isValid: true, methodName, setterInstance };

package/lib/rules/require-hooks-default-params.js

@@ -41,9 +41,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                 const scope = context.getScope();
                 const variable = scope.variables.find(v => v.name === typeName.name);
                 if (!variable || !variable.defs[0]?.node) {
-                    // If we can't find the type definition, assume it's a type with all optional properties
+                    // If we can't find the type definition, assume it's a type with required properties
                     // This handles cases where the type is imported from another module
-                    return true;
+                    return false;
                 }
                 const def = variable.defs[0].node;
                 if (def.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
@@ -58,9 +58,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                     });
                 }
                 // If we found the type definition but it's not a type alias or interface declaration,
-                // assume it's a type with all optional properties
+                // assume it's a type with required properties
                 // This handles cases where the type is imported from another module
-                return true;
+                return false;
             }
             // Handle type alias declarations
             if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
@@ -77,71 +77,130 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
             }
             return false;
         }
-        function checkHookParam(param) {
-            // If it's already an assignment pattern, check if the left side is an object pattern
-            if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
-                if (param.left.type === utils_1.AST_NODE_TYPES.ObjectPattern && param.left.typeAnnotation) {
-                    if (hasAllOptionalProperties(param.left.typeAnnotation.typeAnnotation)) {
-                        return; // Already has a default value and is correctly typed
+        return {
+            'ArrowFunctionExpression, FunctionDeclaration'(node) {
+                // Check if it's a hook function
+                let isHook = false;
+                if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                    isHook = node.id ? isHookName(node.id.name) : false;
+                }
+                else {
+                    const parent = node.parent;
+                    if (parent &&
+                        parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        parent.id &&
+                        parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        isHook = isHookName(parent.id.name);
                     }
                 }
-                return;
-            }
-            // If it's an object pattern, check if it needs a default value
-            if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern && param.typeAnnotation) {
-                const typeAnnotation = param.typeAnnotation.typeAnnotation;
-                if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
-                    const typeName = typeAnnotation.typeName;
-                    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const scope = context.getScope();
-                        const variable = scope.variables.find(v => v.name === typeName.name);
-                        if (!variable || !variable.defs[0]?.node) {
-                            // If we can't find the type definition, assume it's a type with all optional properties
-                            // This handles cases where the type is imported from another module
-                            context.report({
-                                node: param,
-                                messageId: 'requireDefaultParams',
-                                fix(fixer) {
-                                    const paramText = context.getSourceCode().getText(param);
-                                    return fixer.replaceText(param, `${paramText} = {}`);
-                                },
-                            });
-                            return;
-                        }
-                        const def = variable.defs[0].node;
-                        if (def.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-                            if (hasAllOptionalProperties(def.typeAnnotation)) {
-                                context.report({
-                                    node: param,
-                                    messageId: 'requireDefaultParams',
-                                    fix(fixer) {
-                                        const paramText = context.getSourceCode().getText(param);
-                                        return fixer.replaceText(param, `${paramText} = {}`);
-                                    },
-                                });
+                if (!isHook) {
+                    return;
+                }
+                // Check if it has exactly one parameter
+                if (node.params.length !== 1) {
+                    return;
+                }
+                // Check if the parameter is already an assignment pattern
+                const param = node.params[0];
+                if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                    return;
+                }
+                // Check if the parameter has a type annotation
+                if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern && param.typeAnnotation) {
+                    const typeAnnotation = param.typeAnnotation.typeAnnotation;
+                    if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                        const typeName = typeAnnotation.typeName;
+                        if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const scope = context.getScope();
+                            const variable = scope.variables.find(v => v.name === typeName.name);
+                            if (variable && variable.defs[0]?.node) {
+                                const def = variable.defs[0].node;
+                                if (def.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                                    if (hasAllOptionalProperties(def.typeAnnotation)) {
+                                        context.report({
+                                            node: param,
+                                            messageId: 'requireDefaultParams',
+                                            fix(fixer) {
+                                                const paramText = context.getSourceCode().getText(param);
+                                                return fixer.replaceText(param, `${paramText} = {}`);
+                                            },
+                                        });
+                                    }
+                                }
+                                else if (def.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                                    if (def.body.body.every(member => {
+                                        if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                                            return false;
+                                        }
+                                        return member.optional === true;
+                                    })) {
+                                        context.report({
+                                            node: param,
+                                            messageId: 'requireDefaultParams',
+                                            fix(fixer) {
+                                                const paramText = context.getSourceCode().getText(param);
+                                                return fixer.replaceText(param, `${paramText} = {}`);
+                                            },
+                                        });
+                                    }
+                                }
                             }
-                        }
-                        else if (def.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
-                            if (def.body.body.every(member => {
-                                if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                            else {
+                                // If we can't find the type definition, check if it's defined in the same file
+                                const program = context.getSourceCode().ast;
+                                const typeDefinitions = program.body.filter(node => {
+                                    if (node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration || node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                                        if (node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                                            return node.id.name === typeName.name;
+                                        }
+                                        else {
+                                            return node.id.name === typeName.name;
+                                        }
+                                    }
                                     return false;
-                                }
-                                return member.optional === true;
-                            })) {
-                                context.report({
-                                    node: param,
-                                    messageId: 'requireDefaultParams',
-                                    fix(fixer) {
-                                        const paramText = context.getSourceCode().getText(param);
-                                        return fixer.replaceText(param, `${paramText} = {}`);
-                                    },
                                 });
+                                if (typeDefinitions.length > 0) {
+                                    const def = typeDefinitions[0];
+                                    if (def.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                                        if (hasAllOptionalProperties(def.typeAnnotation)) {
+                                            context.report({
+                                                node: param,
+                                                messageId: 'requireDefaultParams',
+                                                fix(fixer) {
+                                                    const paramText = context.getSourceCode().getText(param);
+                                                    return fixer.replaceText(param, `${paramText} = {}`);
+                                                },
+                                            });
+                                        }
+                                    }
+                                    else if (def.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                                        if (def.body.body.every(member => {
+                                            if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                                                return false;
+                                            }
+                                            return member.optional === true;
+                                        })) {
+                                            context.report({
+                                                node: param,
+                                                messageId: 'requireDefaultParams',
+                                                fix(fixer) {
+                                                    const paramText = context.getSourceCode().getText(param);
+                                                    return fixer.replaceText(param, `${paramText} = {}`);
+                                                },
+                                            });
+                                        }
+                                    }
+                                }
                             }
                         }
-                        else {
-                            // If we found the type definition but it's not a type alias or interface declaration,
-                            // assume it's a type with all optional properties
-                            // This handles cases where the type is imported from another module
+                    }
+                    else if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                        if (typeAnnotation.members.every(member => {
+                            if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                                return false;
+                            }
+                            return member.optional === true;
+                        })) {
                             context.report({
                                 node: param,
                                 messageId: 'requireDefaultParams',
@@ -153,41 +212,6 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                         }
                     }
                 }
-                else if (hasAllOptionalProperties(typeAnnotation)) {
-                    context.report({
-                        node: param,
-                        messageId: 'requireDefaultParams',
-                        fix(fixer) {
-                            const paramText = context.getSourceCode().getText(param);
-                            return fixer.replaceText(param, `${paramText} = {}`);
-                        },
-                    });
-                }
-            }
-        }
-        return {
-            FunctionDeclaration(node) {
-                if (!node.id || !isHookName(node.id.name)) {
-                    return;
-                }
-                if (node.params.length !== 1) {
-                    return;
-                }
-                checkHookParam(node.params[0]);
-            },
-            ArrowFunctionExpression(node) {
-                const parent = node.parent;
-                if (!parent ||
-                    parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
-                    !parent.id ||
-                    parent.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
-                    !isHookName(parent.id.name)) {
-                    return;
-                }
-                if (node.params.length !== 1) {
-                    return;
-                }
-                checkHookParam(node.params[0]);
             },
         };
     },

package/package.json

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