@blumintinc/eslint-plugin-blumint 1.20.164 → 1.20.166

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.164',
+        version: '1.20.166',
     },
     parseOptions: {
         ecmaVersion: 2020,

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

@@ -16,6 +16,11 @@ const IMPORT_BINDING_NODE_TYPES = new Set([
     utils_1.AST_NODE_TYPES.ImportDefaultSpecifier,
     utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier,
 ]);
+const membersDeclareIdString = (members) => 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);
 exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
     name: 'enforce-identifiable-firestore-type',
     meta: {
@@ -26,8 +31,10 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            missingType: 'Expected exported type "{{ typeName }}" in index.ts under folder "{{ folderName }}". Create a type that matches the folder name: `export type {{ typeName }} = { /* fields */ }`.',
-            notExtendingIdentifiable: 'Type "{{ typeName }}" must extend "Identifiable" to ensure all Firestore documents have an ID field. Add `extends Identifiable` or include `id: string`: `export type {{ typeName }} = { id: string; /* other fields */ }`.',
+            // Every spelling named here must clear the rule; a message that
+            // prescribes a remedy the rule then reports on is unfollowable (#2035).
+            missingType: 'Expected exported type "{{ typeName }}" in index.ts under folder "{{ folderName }}". Create a type that matches the folder name: `export type {{ typeName }} = { id: string; /* other fields */ }`.',
+            notExtendingIdentifiable: 'Type "{{ typeName }}" must carry an `id` field so every Firestore document is identifiable. Intersect Identifiable (`export type {{ typeName }} = Identifiable & { /* other fields */ }`), extend it (`export interface {{ typeName }} extends Identifiable { /* other fields */ }`), or declare the field inline (`export type {{ typeName }} = { id: string; /* other fields */ }`).',
         },
     },
     defaultOptions: [],
@@ -46,32 +53,259 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
         }
         // Get the expected type name from the parent folder
         const folderName = path_1.default.basename(path_1.default.dirname(filename));
-        // The folder-matching alias only satisfies the rule if it is reachable by
-        // consumers. An alias can be exported inline (`export type X = ...`) or
-        // separately (`export { X }` / `export type { X }`), and the separate form
-        // can appear either before or after the declaration, so exportedness can't
-        // be decided inside the TSTypeAliasDeclaration visitor alone — it's
-        // resolved once the whole module has been scanned, in Program:exit.
-        let matchingAliasNode = null;
-        let matchingAliasInlineExported = false;
-        let matchingAliasHasIdentifiable = false;
-        // Set when resolving the matching alias runs into a type that is declared
-        // in another module. Such a type is opaque to this single-file walk, so the
-        // absence of `Identifiable` is unproven rather than disproven.
-        let matchingAliasLeavesModule = false;
+        // The folder-matching declaration only satisfies the rule if it is
+        // reachable by consumers. It can be exported inline (`export type X = ...`)
+        // or separately (`export { X }` / `export type { X }`), and the separate
+        // form can appear either before or after the declaration, so exportedness
+        // can't be decided inside the declaration visitor alone — it's resolved once
+        // the whole module has been scanned, in Program:exit.
+        let matchingDeclarationNode = null;
+        let matchingDeclarationInlineExported = false;
+        let matchingDeclarationProvidesId = false;
+        // Set when resolving the matching declaration runs into a type that is
+        // declared in another module. Such a type is opaque to this single-file
+        // walk, so the absence of an id is unproven rather than disproven.
+        let matchingDeclarationLeavesModule = false;
         const locallyExportedNames = new Set();
+        // Interfaces merge, so a second declaration of the same name adds to the
+        // first rather than replacing it; accumulating with OR keeps every arm that
+        // any declaration of the name satisfies.
+        const analyzeMatchingDeclaration = (node) => {
+            // Raised by the resolution walks below whenever a referenced type name
+            // resolves to an imported binding, i.e. the chain ran out of this file.
+            // Scoped to this declaration so an import that no chain ever reaches — an
+            // unrelated `Timestamp`, or a type argument the walk never descends into
+            // — grants no amnesty.
+            let leavesModule = false;
+            const isImportedBinding = (name) => {
+                let scope = context.getScope();
+                while (scope) {
+                    const variable = scope.variables.find((variableNode) => variableNode.name === name);
+                    if (variable) {
+                        return variable.defs.some((definition) => IMPORT_BINDING_NODE_TYPES.has(definition.node.type));
+                    }
+                    scope = scope.upper;
+                }
+                return false;
+            };
+            const findLocalDeclaration = (typeName) => {
+                let scope = context.getScope();
+                while (scope) {
+                    const variable = scope.variables.find((variableNode) => variableNode.name === typeName);
+                    if (variable) {
+                        const definition = variable.defs.find((candidate) => candidate.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+                            candidate.node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration);
+                        if (definition) {
+                            return definition.node;
+                        }
+                        // The name is bound, but only to something this file cannot see
+                        // through: an import. Record that the chain crossed the module
+                        // boundary so the caller distinguishes "proved no id" from "could
+                        // not look". A name with no binding at all (a lib global such as
+                        // `Readonly` or `Map`) is left alone: those are known not to be
+                        // Identifiable-bearing declarations, and treating them as unknown
+                        // would silence the rule almost everywhere.
+                        if (variable.defs.some((candidate) => IMPORT_BINDING_NODE_TYPES.has(candidate.node.type))) {
+                            leavesModule = true;
+                        }
+                    }
+                    scope = scope.upper;
+                }
+                return null;
+            };
+            // `Types.Team` from `import * as Types from '../Team'` names a type in
+            // another module just as `Team` from a named import does, but it carries a
+            // TSQualifiedName (in a type position) or a MemberExpression (in an
+            // interface heritage clause) that the walks below never resolve. The
+            // leftmost identifier is the namespace binding, so it answers the same
+            // question: did the chain leave this file?
+            // ESTree wraps `Types?.Team` in a ChainExpression, so the walk has to see
+            // through that wrapper as well or the optional spelling loses the amnesty
+            // the plain one gets.
+            const noteImportedNamespace = (root) => {
+                let leftmost = root;
+                while (leftmost.type === utils_1.AST_NODE_TYPES.TSQualifiedName ||
+                    leftmost.type === utils_1.AST_NODE_TYPES.MemberExpression ||
+                    leftmost.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                    if (leftmost.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                        leftmost = leftmost.expression;
+                        continue;
+                    }
+                    leftmost =
+                        leftmost.type === utils_1.AST_NODE_TYPES.TSQualifiedName
+                            ? leftmost.left
+                            : leftmost.object;
+                }
+                if (leftmost.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    isImportedBinding(leftmost.name)) {
+                    leavesModule = true;
+                }
+            };
+            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()) => {
+                const resolvedType = unwrapTransparentType(type);
+                if (!resolvedType) {
+                    return false;
+                }
+                // A resolved name lands on the declaration itself, so both declaration
+                // kinds are walked here rather than at every call site.
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                    return findIdentifiable(resolvedType.typeAnnotation, checkedTypes);
+                }
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                    return (resolvedType.extends ?? []).some((heritage) => findIdentifiable(heritage, new Set(checkedTypes)));
+                }
+                const referencedName = resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                    resolvedType.typeName.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? resolvedType.typeName.name
+                    : resolvedType.type === utils_1.AST_NODE_TYPES.TSInterfaceHeritage &&
+                        resolvedType.expression.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? resolvedType.expression.name
+                        : null;
+                if (referencedName !== null) {
+                    if (referencedName === 'Identifiable') {
+                        return true;
+                    }
+                    if (TRANSPARENT_TYPE_NAMES.has(referencedName) &&
+                        resolvedType.typeParameters?.params?.some((param) => findIdentifiable(param, checkedTypes))) {
+                        return true;
+                    }
+                    if (checkedTypes.has(referencedName)) {
+                        return false;
+                    }
+                    checkedTypes.add(referencedName);
+                    return findIdentifiable(findLocalDeclaration(referencedName), checkedTypes);
+                }
+                // A heritage clause that is not a bare name is a namespace-qualified
+                // one (`Types.Team`, or its optional-chained spelling), which names a
+                // type this file cannot see through.
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSInterfaceHeritage) {
+                    noteImportedNamespace(resolvedType.expression);
+                    return false;
+                }
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                    return resolvedType.types.some((part) => findIdentifiable(part, new Set(checkedTypes)));
+                }
+                return false;
+            };
+            // Whether the type declares `id: string` itself. The
+            // notExtendingIdentifiable message offers this as an alternative to
+            // Identifiable, and it delivers exactly what the rule exists to
+            // guarantee — the document's ID field — so it satisfies the rule wherever
+            // it appears, not only under a `Resolve<>` wrapper.
+            const declaresIdField = (type, visitedTypes = new Set()) => {
+                const resolvedType = unwrapTransparentType(type);
+                if (!resolvedType) {
+                    return false;
+                }
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                    return membersDeclareIdString(resolvedType.members);
+                }
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                    return declaresIdField(resolvedType.typeAnnotation, visitedTypes);
+                }
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                    return (membersDeclareIdString(resolvedType.body.body) ||
+                        (resolvedType.extends ?? []).some((heritage) => declaresIdField(heritage, new Set(visitedTypes))));
+                }
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                    return resolvedType.types.some((part) => declaresIdField(part, new Set(visitedTypes)));
+                }
+                const referencedName = resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                    resolvedType.typeName.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? resolvedType.typeName.name
+                    : resolvedType.type === utils_1.AST_NODE_TYPES.TSInterfaceHeritage &&
+                        resolvedType.expression.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? resolvedType.expression.name
+                        : null;
+                if (referencedName === null) {
+                    return false;
+                }
+                if (referencedName === 'Identifiable') {
+                    return true;
+                }
+                if (TRANSPARENT_TYPE_NAMES.has(referencedName) &&
+                    resolvedType.typeParameters?.params?.some((param) => declaresIdField(param, visitedTypes))) {
+                    return true;
+                }
+                if (visitedTypes.has(referencedName)) {
+                    return false;
+                }
+                visitedTypes.add(referencedName);
+                return declaresIdField(findLocalDeclaration(referencedName), visitedTypes);
+            };
+            // Recursively check the declaration, its alias chain and its parameters
+            const providesId = (type, visitedTypes = new Set()) => {
+                const resolvedType = unwrapTransparentType(type);
+                if (!resolvedType) {
+                    return false;
+                }
+                if (findIdentifiable(resolvedType) || declaresIdField(resolvedType)) {
+                    return true;
+                }
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                    return providesId(resolvedType.typeAnnotation, visitedTypes);
+                }
+                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);
+                    return providesId(findLocalDeclaration(typeName), visitedTypes);
+                }
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                    resolvedType.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                    noteImportedNamespace(resolvedType.typeName);
+                    return false;
+                }
+                if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                    return resolvedType.types.some((part) => providesId(part, new Set(visitedTypes)));
+                }
+                return false;
+            };
+            matchingDeclarationNode = node;
+            matchingDeclarationInlineExported =
+                matchingDeclarationInlineExported ||
+                    node.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+                    node.parent?.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration;
+            matchingDeclarationProvidesId =
+                matchingDeclarationProvidesId || providesId(node);
+            matchingDeclarationLeavesModule =
+                matchingDeclarationLeavesModule || leavesModule;
+        };
         return {
             Program() {
                 // Reset flags for each file
-                matchingAliasNode = null;
-                matchingAliasInlineExported = false;
-                matchingAliasHasIdentifiable = false;
-                matchingAliasLeavesModule = false;
+                matchingDeclarationNode = null;
+                matchingDeclarationInlineExported = false;
+                matchingDeclarationProvidesId = false;
+                matchingDeclarationLeavesModule = false;
                 locallyExportedNames.clear();
             },
             'Program:exit'(node) {
-                const hasExpectedType = matchingAliasNode !== null &&
-                    (matchingAliasInlineExported || locallyExportedNames.has(folderName));
+                const hasExpectedType = matchingDeclarationNode !== null &&
+                    (matchingDeclarationInlineExported ||
+                        locallyExportedNames.has(folderName));
                 if (!hasExpectedType) {
                     context.report({
                         node,
@@ -82,8 +316,8 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                         },
                     });
                 }
-                else if (!matchingAliasHasIdentifiable &&
-                    !matchingAliasLeavesModule) {
+                else if (!matchingDeclarationProvidesId &&
+                    !matchingDeclarationLeavesModule) {
                     // A chain that leaves the module is unknowable here: the imported
                     // type may well intersect `Identifiable`, and reporting would demand
                     // a type-theoretically redundant `Identifiable &` to silence a claim
@@ -100,8 +334,8 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
             },
             ExportNamedDeclaration(node) {
                 // A re-export (`export { X } from './elsewhere'`) exports a binding
-                // from another module, not the local alias declared in this file, so
-                // it must never satisfy the gate.
+                // from another module, not the local declaration in this file, so it
+                // must never satisfy the gate.
                 if (node.source != null) {
                     return;
                 }
@@ -111,198 +345,12 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
             },
             TSTypeAliasDeclaration(node) {
                 if (node.id.name === folderName) {
-                    matchingAliasNode = node;
-                    matchingAliasInlineExported =
-                        node.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration;
-                    // Raised by the resolution walk below whenever a referenced type name
-                    // resolves to an imported binding, i.e. the alias chain ran out of
-                    // this file. Scoped to this alias so an import that no chain ever
-                    // reaches — an unrelated `Timestamp`, or a type argument the walk
-                    // never descends into — grants no amnesty.
-                    let leavesModule = false;
-                    const isImportedBinding = (name) => {
-                        let scope = context.getScope();
-                        while (scope) {
-                            const variable = scope.variables.find((variableNode) => variableNode.name === name);
-                            if (variable) {
-                                return variable.defs.some((definition) => IMPORT_BINDING_NODE_TYPES.has(definition.node.type));
-                            }
-                            scope = scope.upper;
-                        }
-                        return false;
-                    };
-                    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;
-                                }
-                                // The name is bound, but only to something this file cannot
-                                // see through: an import. Record that the chain crossed the
-                                // module boundary so the caller distinguishes "proved no
-                                // Identifiable" from "could not look". A name with no binding
-                                // at all (a lib global such as `Readonly` or `Map`) is left
-                                // alone: those are known not to be Identifiable-bearing
-                                // aliases, and treating them as unknown would silence the
-                                // rule almost everywhere.
-                                if (variable.defs.some((definition) => IMPORT_BINDING_NODE_TYPES.has(definition.node.type))) {
-                                    leavesModule = true;
-                                }
-                            }
-                            scope = scope.upper;
-                        }
-                        return null;
-                    };
-                    // `Types.Team` from `import * as Types from '../Team'` names a type
-                    // in another module just as `Team` from a named import does, but it
-                    // carries a TSQualifiedName that the walks below never resolve. The
-                    // leftmost identifier is the namespace binding, so it answers the
-                    // same question: did the chain leave this file?
-                    const noteQualifiedNamespaceImport = (qualifiedName) => {
-                        let left = qualifiedName.left;
-                        while (left.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
-                            left = left.left;
-                        }
-                        if (left.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            isImportedBinding(left.name)) {
-                            leavesModule = true;
-                        }
-                    };
-                    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()) => {
-                        const resolvedType = unwrapTransparentType(type);
-                        if (!resolvedType) {
-                            return false;
-                        }
-                        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 (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);
-                        }
-                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            return resolvedType.types.some((part) => findIdentifiable(part, new Set(checkedTypes)));
-                        }
-                        return false;
-                    };
-                    // Check if type has id: string field
-                    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);
-                        }
-                        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, visitedTypes = new Set()) => {
-                        const resolvedType = unwrapTransparentType(type);
-                        if (!resolvedType) {
-                            return false;
-                        }
-                        if (findIdentifiable(resolvedType)) {
-                            return true;
-                        }
-                        if (isUtilityType(resolvedType) &&
-                            resolvedType.typeParameters?.params?.[0] &&
-                            checkIdField(resolvedType.typeParameters.params[0])) {
-                            return true;
-                        }
-                        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.TSTypeReference &&
-                            resolvedType.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
-                            noteQualifiedNamespaceImport(resolvedType.typeName);
-                            return false;
-                        }
-                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            return resolvedType.types.some((part) => checkType(part, new Set(visitedTypes)));
-                        }
-                        return false;
-                    };
-                    matchingAliasHasIdentifiable = checkType(node.typeAnnotation);
-                    matchingAliasLeavesModule = leavesModule;
+                    analyzeMatchingDeclaration(node);
+                }
+            },
+            TSInterfaceDeclaration(node) {
+                if (node.id.name === folderName) {
+                    analyzeMatchingDeclaration(node);
                 }
             },
         };

package/lib/rules/memo-compare-deeply-complex-props.js

@@ -822,12 +822,55 @@ function isPropertyComplex(prop, checker, tsNode, ts, treatAnyAsComplex, parentT
     }
     return shouldTreatAnyAsComplex(prop, propType, ts, treatAnyAsComplex, parentTypeFlags, checker);
 }
+/**
+ * Returns true when `declaration` was written by a dependency rather than by the
+ * component's author: a declaration file, or any file under `node_modules`.
+ * Keys on the same `getSourceFile().fileName` inspection the React and DOM
+ * origin gates use.
+ */
+function isExternalDeclaration(declaration) {
+    const sourceFile = declaration.getSourceFile?.();
+    if (!sourceFile)
+        return false;
+    const fileName = sourceFile.fileName ?? '';
+    return (sourceFile.isDeclarationFile === true ||
+        /\.d\.[cm]?ts$/.test(fileName) ||
+        /[/\\]node_modules[/\\]/.test(fileName));
+}
+/**
+ * Returns true when every declaration site of `prop` lives in a dependency.
+ *
+ * `checker.getPropertiesOfType` returns INHERITED members, so a props type that
+ * extends or intersects a library interface (MUI's `TypographyProps`, React's
+ * `HTMLAttributes`, …) surfaces that library's entire surface. Demanding the
+ * author name those in `compareDeeply` prescribes a remedy nobody can act on —
+ * the component neither declares nor receives them, and the lists run past a
+ * hundred names — so the only available exit is a blanket rule disable.
+ *
+ * The gate is `every` rather than "first declaration", so a prop the author
+ * redeclares alongside the library's (the intersection of two same-named
+ * members yields one symbol carrying BOTH declarations) still counts as
+ * authored and is still reported.
+ *
+ * A prop with no declarations at all is treated as authored. Synthesized
+ * symbols reach here from mapped and generic types over the component's own
+ * props, and reporting them preserves the rule's core behaviour; a missing
+ * declaration is not evidence of a dependency.
+ */
+function isExternallyDeclaredProperty(prop) {
+    const declarations = prop.declarations;
+    if (!declarations || declarations.length === 0)
+        return false;
+    return declarations.every(isExternalDeclaration);
+}
 function getComplexPropertiesFromType(type, checker, tsNode, ts, treatAnyAsComplex = false, parentTypeFlags = 0) {
     const properties = checker.getPropertiesOfType(type);
     const complexProps = [];
     for (const prop of properties) {
         if (isReservedReactPropName(prop.name))
             continue;
+        if (isExternallyDeclaredProperty(prop))
+            continue;
         if (isPropertyComplex(prop, checker, tsNode, ts, treatAnyAsComplex, parentTypeFlags)) {
             complexProps.push(prop.name);
         }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.166",
+    "date": "2026-08-18T03:18:38.188Z",
+    "rules": [
+      {
+        "name": "memo-compare-deeply-complex-props",
+        "changeType": "fix",
+        "issues": [
+          2037
+        ],
+        "summary": "exempt props declared by a dependency (closes #2037)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.165",
+    "date": "2026-08-18T00:07:35.027Z",
+    "rules": [
+      {
+        "name": "enforce-identifiable-firestore-type",
+        "changeType": "fix",
+        "issues": [
+          2035
+        ],
+        "summary": "accept every remedy its message prescribes (closes #2035)"
+      }
+    ]
+  },
   {
     "version": "1.20.164",
     "date": "2026-08-17T22:26:37.717Z",