@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/enforce-firestore-set-merge.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceFirestoreSetMerge = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
     name: 'enforce-firestore-set-merge',
     meta: {
@@ -93,9 +94,7 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                             return true;
                         }
                         // Check if it's a Firestore document reference by looking at imports
-                        const program = context
-                            .getAncestors()
-                            .find((node) => node.type === utils_1.AST_NODE_TYPES.Program);
+                        const program = ASTHelpers_1.ASTHelpers.getAncestors(context, node).find((node) => node.type === utils_1.AST_NODE_TYPES.Program);
                         if (program) {
                             for (const node of program.body) {
                                 if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
@@ -212,7 +211,7 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                         node,
                         messageId: 'preferSetMerge',
                         fix(fixer) {
-                            const newText = convertUpdateToSetMerge(node, context.getSourceCode());
+                            const newText = convertUpdateToSetMerge(node, context.sourceCode);
                             return fixer.replaceText(node, newText);
                         },
                     });

package/lib/rules/enforce-global-constants.d.ts

@@ -1 +1,4 @@
-export declare const enforceGlobalConstants: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"useGlobalConstant", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'useGlobalConstant' | 'extractDefaultToGlobalConstant';
+export declare const enforceGlobalConstants: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
+export {};

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

@@ -3,48 +3,250 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceGlobalConstants = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.enforceGlobalConstants = (0, createRule_1.createRule)({
     name: 'enforce-global-constants',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce using global static constants instead of useMemo with empty dependency arrays for object literals',
+            description: 'Enforce using global static constants instead of useMemo with empty dependency arrays for object literals, and extract inline destructuring defaults in React components/hooks to global constants',
             recommended: 'error',
         },
+        fixable: 'code',
         schema: [],
         messages: {
             useGlobalConstant: 'Use a global static constant instead of useMemo with an empty dependency array for object literals',
+            extractDefaultToGlobalConstant: 'Extract inline default value to a module-level constant for stable reference',
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.sourceCode;
+        function isHookName(name) {
+            return /^use[A-Z]/.test(name);
+        }
+        function isComponentOrHookFunction(fn) {
+            if (fn.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                const n = fn.id?.name ?? '';
+                return /^[A-Z]/.test(n) || isHookName(n);
+            }
+            const parent = fn.parent;
+            if (parent &&
+                parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const n = parent.id.name;
+                return /^[A-Z]/.test(n) || isHookName(n);
+            }
+            return false;
+        }
+        function getEnclosingFunction(node) {
+            let current = node;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    return current;
+                }
+                current = current.parent;
+            }
+            return null;
+        }
+        function toUpperSnakeCase(name) {
+            return name
+                .replace(/([A-Z])/g, '_$1')
+                .toUpperCase()
+                .replace(/^_/, '');
+        }
+        function collectAssignmentDefaultsFromPattern(pattern) {
+            const results = [];
+            const visitPattern = (p) => {
+                if (p.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    for (const prop of p.properties) {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            const value = prop.value;
+                            if (value &&
+                                value.type ===
+                                    utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                                const assign = value;
+                                const left = assign.left;
+                                if (left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    results.push({ assignment: assign, localName: left.name });
+                                }
+                                if (left.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                                    left.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                                    // Nested pattern on the left of an assignment; uncommon, ignore naming
+                                }
+                            }
+                            else if (value &&
+                                value
+                                    .type &&
+                                (value
+                                    .type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                                    value
+                                        .type === utils_1.AST_NODE_TYPES.ArrayPattern)) {
+                                visitPattern(value);
+                            }
+                        }
+                    }
+                }
+                else if (p.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                    for (const elem of p.elements) {
+                        if (!elem)
+                            continue;
+                        if (elem.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                            const left = elem.left;
+                            if (left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                results.push({ assignment: elem, localName: left.name });
+                            }
+                        }
+                        else if (elem.type === utils_1.AST_NODE_TYPES.ArrayPattern ||
+                            elem.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                            visitPattern(elem);
+                        }
+                    }
+                }
+                else if (p.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                    const left = p.left;
+                    if (left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        results.push({ assignment: p, localName: left.name });
+                    }
+                }
+            };
+            visitPattern(pattern);
+            return results;
+        }
+        function hasIdentifiers(node) {
+            return !!node && ASTHelpers_1.ASTHelpers.declarationIncludesIdentifier(node);
+        }
+        function alreadyHasConst(program, constName) {
+            for (const stmt of program.body) {
+                if (stmt.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+                    stmt.kind === 'const') {
+                    for (const d of stmt.declarations) {
+                        if (d.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            d.id.name === constName) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        function buildConstDeclarationLine(constName, initText) {
+            const needsAsConst = /^(?:true|false|-?\d|\[|\{|[`'"])/.test(initText) &&
+                !/\bas const\b/.test(initText);
+            const initializer = needsAsConst ? `${initText} as const` : initText;
+            return `const ${constName} = ${initializer};`;
+        }
+        function reportStaticDefaults(patterns, enclosingFn, nodeForReport) {
+            if (!enclosingFn || !isComponentOrHookFunction(enclosingFn))
+                return;
+            const defaults = [];
+            for (const pattern of patterns) {
+                defaults.push(...collectAssignmentDefaultsFromPattern(pattern));
+            }
+            if (defaults.length === 0)
+                return;
+            const staticDefaults = defaults.filter((def) => {
+                const right = def.assignment.right;
+                return right && !hasIdentifiers(right);
+            });
+            if (staticDefaults.length === 0)
+                return;
+            context.report({
+                node: nodeForReport,
+                messageId: 'extractDefaultToGlobalConstant',
+                fix(fixer) {
+                    const fixes = [];
+                    const programNode = sourceCode.ast;
+                    const declLines = [];
+                    for (const def of staticDefaults) {
+                        const { assignment, localName } = def;
+                        const right = assignment.right;
+                        const rightText = sourceCode.getText(right);
+                        const constName = `DEFAULT_${toUpperSnakeCase(localName)}`;
+                        if (!alreadyHasConst(programNode, constName)) {
+                            declLines.push(buildConstDeclarationLine(constName, rightText));
+                        }
+                        fixes.push(fixer.replaceText(right, constName));
+                    }
+                    if (declLines.length > 0) {
+                        const program = sourceCode.ast;
+                        const constSection = declLines.length === 1
+                            ? declLines[0]
+                            : `${declLines[0]}\n\n${declLines.slice(1).join('\n')}`;
+                        const text = sourceCode.text;
+                        const findNextNonWhitespace = (start) => {
+                            let idx = start;
+                            while (idx < text.length && /\s/.test(text[idx])) {
+                                idx += 1;
+                            }
+                            return idx;
+                        };
+                        const buildBlock = (extraSpacing, insertPos, nextPos) => {
+                            const whitespace = text.slice(insertPos, nextPos);
+                            const lastNewline = whitespace.lastIndexOf('\n');
+                            const nextIndentRaw = lastNewline === -1
+                                ? ''
+                                : whitespace.slice(lastNewline + 1).replace(/[^\t ]/g, '');
+                            const separator = extraSpacing ? '\n\n\n' : '\n\n';
+                            const nextIndent = extraSpacing ? nextIndentRaw : '';
+                            return `\n${constSection}${separator}${nextIndent}`;
+                        };
+                        const imports = program.body.filter((s) => s.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+                        if (imports.length > 0) {
+                            const lastImport = imports[imports.length - 1];
+                            const insertPos = lastImport.range[1];
+                            const nextPos = findNextNonWhitespace(insertPos);
+                            fixes.push(fixer.replaceTextRange([insertPos, nextPos], buildBlock(false, insertPos, nextPos)));
+                        }
+                        else {
+                            const body = program.body;
+                            let insertPos = 0;
+                            let afterDirectiveIdx = -1;
+                            for (let i = 0; i < body.length; i++) {
+                                const stmt = body[i];
+                                if (stmt.type === utils_1.AST_NODE_TYPES.ExpressionStatement &&
+                                    stmt.expression.type === utils_1.AST_NODE_TYPES.Literal &&
+                                    typeof stmt.expression.value === 'string') {
+                                    afterDirectiveIdx = i;
+                                }
+                                else {
+                                    break;
+                                }
+                            }
+                            if (afterDirectiveIdx >= 0) {
+                                insertPos = body[afterDirectiveIdx].range[1];
+                            }
+                            const nextPos = findNextNonWhitespace(insertPos);
+                            fixes.push(fixer.replaceTextRange([insertPos, nextPos], buildBlock(afterDirectiveIdx < 0, insertPos, nextPos)));
+                        }
+                    }
+                    return fixes;
+                },
+            });
+        }
         return {
             CallExpression(node) {
-                // Check if it's a useMemo call
                 if (node.callee.type !== utils_1.AST_NODE_TYPES.Identifier ||
                     node.callee.name !== 'useMemo') {
                     return;
                 }
-                // Check if it has exactly two arguments
                 if (node.arguments.length !== 2) {
                     return;
                 }
-                // Check if the second argument is an empty array
                 const depsArray = node.arguments[1];
                 if (depsArray.type !== utils_1.AST_NODE_TYPES.ArrayExpression ||
                     depsArray.elements.length !== 0) {
                     return;
                 }
-                // Check if the first argument is an arrow function
                 const callback = node.arguments[0];
-                if (callback.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                if (callback.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                    callback.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
                     return;
                 }
-                // Check if the arrow function body is a block statement with a return statement
-                // or a direct expression (implicit return)
                 let returnValue = null;
                 if (callback.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                    // If it's a block, find the return statement
                     const returnStatement = callback.body.body.find((stmt) => stmt.type === utils_1.AST_NODE_TYPES.ReturnStatement);
                     if (!returnStatement || !returnStatement.argument) {
                         return;
@@ -52,15 +254,12 @@ exports.enforceGlobalConstants = (0, createRule_1.createRule)({
                     returnValue = returnStatement.argument;
                 }
                 else {
-                    // If it's an expression (implicit return)
                     returnValue = callback.body;
                 }
-                // Handle 'as const' type assertions
                 let actualReturnValue = returnValue;
                 if (returnValue.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
                     actualReturnValue = returnValue.expression;
                 }
-                // Check if the return value is an object literal or an array of object literals
                 if (actualReturnValue.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
                     (actualReturnValue.type === utils_1.AST_NODE_TYPES.ArrayExpression &&
                         actualReturnValue.elements.some((element) => element !== null &&
@@ -71,6 +270,35 @@ exports.enforceGlobalConstants = (0, createRule_1.createRule)({
                     });
                 }
             },
+            VariableDeclaration(node) {
+                const relevantDeclarators = node.declarations.filter((d) => d.id.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    d.id.type === utils_1.AST_NODE_TYPES.ArrayPattern);
+                if (relevantDeclarators.length === 0)
+                    return;
+                const enclosingFn = getEnclosingFunction(node);
+                reportStaticDefaults(relevantDeclarators.map((d) => d.id), enclosingFn, node);
+            },
+            FunctionDeclaration(node) {
+                const patterns = node.params.filter((p) => p.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    p.type === utils_1.AST_NODE_TYPES.ArrayPattern);
+                if (patterns.length === 0)
+                    return;
+                reportStaticDefaults(patterns, node, node);
+            },
+            FunctionExpression(node) {
+                const patterns = node.params.filter((p) => p.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    p.type === utils_1.AST_NODE_TYPES.ArrayPattern);
+                if (patterns.length === 0)
+                    return;
+                reportStaticDefaults(patterns, node, node);
+            },
+            ArrowFunctionExpression(node) {
+                const patterns = node.params.filter((p) => p.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    p.type === utils_1.AST_NODE_TYPES.ArrayPattern);
+                if (patterns.length === 0)
+                    return;
+                reportStaticDefaults(patterns, node, node);
+            },
         };
     },
 });

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

@@ -5,8 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceIdentifiableFirestoreType = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-const createRule_1 = require("../utils/createRule");
 const path_1 = __importDefault(require("path"));
+const createRule_1 = require("../utils/createRule");
+const TRANSPARENT_TYPE_NAMES = new Set(['Readonly', 'Resolve']);
 exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
     name: 'enforce-identifiable-firestore-type',
     meta: {
@@ -63,94 +64,143 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
             TSTypeAliasDeclaration(node) {
                 if (node.id.name === folderName) {
                     hasExpectedType = true;
-                    // Find Identifiable in type's dependencies
+                    const findTypeAliasAnnotation = (typeName) => {
+                        let scope = context.getScope();
+                        while (scope) {
+                            const variable = scope.variables.find((variableNode) => variableNode.name === typeName);
+                            if (variable) {
+                                const definition = variable.defs.find((definition) => definition.node.type ===
+                                    utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration);
+                                if (definition &&
+                                    definition.node.type ===
+                                        utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration &&
+                                    definition.node.typeAnnotation) {
+                                    return definition.node.typeAnnotation;
+                                }
+                            }
+                            scope = scope.upper;
+                        }
+                        return null;
+                    };
+                    const isParenthesizedType = (node) => node?.type === 'TSParenthesizedType';
+                    const isReadonlyTypeOperator = (node) => node?.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                        node.operator === 'readonly';
+                    const unwrapTransparentType = (typeNode) => {
+                        let current = typeNode;
+                        while (current) {
+                            if (isParenthesizedType(current)) {
+                                const parenthesized = current;
+                                current = parenthesized.typeAnnotation ?? null;
+                                continue;
+                            }
+                            if (isReadonlyTypeOperator(current)) {
+                                current = current.typeAnnotation ?? null;
+                                continue;
+                            }
+                            break;
+                        }
+                        return current ?? null;
+                    };
                     const findIdentifiable = (type, checkedTypes = new Set()) => {
-                        if (!type)
+                        const resolvedType = unwrapTransparentType(type);
+                        if (!resolvedType) {
                             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 (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            resolvedType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const typeName = resolvedType.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);
-                                        }
-                                    }
-                                }
+                            if (TRANSPARENT_TYPE_NAMES.has(typeName) &&
+                                resolvedType.typeParameters?.params?.some((param) => findIdentifiable(param, checkedTypes))) {
+                                return true;
+                            }
+                            if (checkedTypes.has(typeName)) {
+                                return false;
                             }
+                            checkedTypes.add(typeName);
+                            const aliasAnnotation = findTypeAliasAnnotation(typeName);
+                            return findIdentifiable(aliasAnnotation, checkedTypes);
                         }
-                        else if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            // For intersection types, check each part
-                            return type.types.some((part) => findIdentifiable(part, checkedTypes));
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return resolvedType.types.some((part) => findIdentifiable(part, new Set(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
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
-                            return type.members.some((member) => member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                    const checkIdField = (type, visitedTypes = new Set()) => {
+                        const resolvedType = unwrapTransparentType(type);
+                        if (!resolvedType) {
+                            return false;
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                            return resolvedType.members.some((member) => member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
                                 member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                                 member.key.name === 'id' &&
                                 member.typeAnnotation?.typeAnnotation.type ===
                                     utils_1.AST_NODE_TYPES.TSStringKeyword);
                         }
-                        // Check intersection types
-                        if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            return type.types.some(checkIdField);
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return resolvedType.types.some((part) => checkIdField(part, new Set(visitedTypes)));
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                            if (resolvedType.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                                return false;
+                            }
+                            const typeName = resolvedType.typeName.name;
+                            if (typeName === 'Identifiable') {
+                                return true;
+                            }
+                            if (TRANSPARENT_TYPE_NAMES.has(typeName) &&
+                                resolvedType.typeParameters?.params?.some((param) => checkIdField(param, visitedTypes))) {
+                                return true;
+                            }
+                            if (visitedTypes.has(typeName)) {
+                                return false;
+                            }
+                            visitedTypes.add(typeName);
+                            const referencedType = findTypeAliasAnnotation(typeName);
+                            return checkIdField(referencedType, visitedTypes);
                         }
                         return false;
                     };
                     // Check if type is wrapped in a utility type
                     const isUtilityType = (type) => {
+                        if (!type) {
+                            return false;
+                        }
                         return (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                             type.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
                             type.typeName.name === 'Resolve');
                     };
                     // Recursively check the type and its parameters
-                    const checkType = (type) => {
-                        // Check if type extends Identifiable
-                        if (checkIdentifiableExtension(type)) {
+                    const checkType = (type, visitedTypes = new Set()) => {
+                        const resolvedType = unwrapTransparentType(type);
+                        if (!resolvedType) {
+                            return false;
+                        }
+                        if (findIdentifiable(resolvedType)) {
                             return true;
                         }
-                        // Check if type has id: string field (only for utility types)
-                        if (isUtilityType(type) &&
-                            checkIdField(type.typeParameters.params[0])) {
+                        if (isUtilityType(resolvedType) &&
+                            resolvedType.typeParameters?.params?.[0] &&
+                            checkIdField(resolvedType.typeParameters.params[0])) {
                             return true;
                         }
-                        // Check if type is wrapped in a utility type
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                            type.typeParameters?.params?.[0]) {
-                            return checkType(type.typeParameters.params[0]);
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            resolvedType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const typeName = resolvedType.typeName.name;
+                            if (visitedTypes.has(typeName)) {
+                                return false;
+                            }
+                            visitedTypes.add(typeName);
+                            const aliasAnnotation = findTypeAliasAnnotation(typeName);
+                            return checkType(aliasAnnotation, visitedTypes);
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return resolvedType.types.some((part) => checkType(part, new Set(visitedTypes)));
                         }
-                        // For direct type definitions, require extending Identifiable
                         return false;
                     };
                     typeHasIdentifiable = checkType(node.typeAnnotation);

package/lib/rules/enforce-memoize-async.d.ts

@@ -1 +1,2 @@
-export declare const enforceMemoizeAsync: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireMemoize", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const enforceMemoizeAsync: TSESLint.RuleModule<"requireMemoize", [], TSESLint.RuleListener>;