@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/no-excessive-parent-chain.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noExcessiveParentChain = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+// Maximum number of consecutive .parent calls allowed before warning
+const DEFAULT_MAX_PARENT_CHAIN_LENGTH = 2;
+// Handler types that this rule applies to
+const HANDLER_TYPES = new Set([
+    'DocumentChangeHandler',
+    'DocumentChangeHandlerTransaction',
+    'RealtimeDbChangeHandler',
+    'RealtimeDbChangeHandlerTransaction',
+]);
+exports.noExcessiveParentChain = (0, createRule_1.createRule)({
+    name: 'no-excessive-parent-chain',
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            description: 'Discourage excessive use of the ref.parent property chain in Firestore and RealtimeDB change handlers',
+            recommended: 'error',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    max: {
+                        type: 'integer',
+                        minimum: 1,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            excessiveParentChain: 'Found {{count}} consecutive ref.parent hops in this handler. Long parent chains break when Firestore/RealtimeDB paths change and bypass the typed params the trigger already provides. Read path components from event.params (for example, params.userId) instead of walking ref.parent repeatedly.',
+        },
+    },
+    defaultOptions: [{}],
+    create(context) {
+        const maxParentChainLength = context.options[0]?.max ?? DEFAULT_MAX_PARENT_CHAIN_LENGTH;
+        // Track variables that contain event data
+        const eventDataVariables = new Map();
+        const eventIdentifiers = new Set();
+        const HANDLER_PARAM_SOURCE = '__handler_param__';
+        const recordEventIdentifier = (name) => {
+            eventIdentifiers.add(name);
+        };
+        const getRootIdentifier = (node) => {
+            let current = node;
+            while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                current = current.object;
+            }
+            return current.type === utils_1.AST_NODE_TYPES.Identifier ? current.name : null;
+        };
+        const hasRefProperty = (node) => {
+            let current = node;
+            while (current) {
+                if (current.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    current.property.name === 'ref') {
+                    return true;
+                }
+                current =
+                    current.object.type === utils_1.AST_NODE_TYPES.MemberExpression
+                        ? current.object
+                        : null;
+            }
+            return false;
+        };
+        const registerHandlerParams = (node) => {
+            for (const param of node.params) {
+                if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    recordEventIdentifier(param.name);
+                }
+                if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    for (const prop of param.properties) {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            prop.value.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            prop.key.name === 'data') {
+                            eventDataVariables.set(prop.value.name, HANDLER_PARAM_SOURCE);
+                            recordEventIdentifier(HANDLER_PARAM_SOURCE);
+                        }
+                    }
+                }
+            }
+        };
+        // Check if a function is one of our handler types
+        function isHandlerFunction(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                node.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+                return false;
+            }
+            // Check if the function is assigned to a variable with a type annotation
+            const parent = node.parent;
+            if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                // Check for type annotation
+                if (parent.id.typeAnnotation?.typeAnnotation) {
+                    const typeNode = parent.id.typeAnnotation.typeAnnotation;
+                    // Check if it's a reference to one of our handler types
+                    if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                        typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        HANDLER_TYPES.has(typeNode.typeName.name)) {
+                        return true;
+                    }
+                    // Check for generic types that might be handlers
+                    if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                        typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        // Try to resolve the type name to see if it's one of our handler types
+                        const scope = context.getScope();
+                        const typeName = typeNode.typeName.name;
+                        const variable = scope.variables.find((v) => v.name === typeName);
+                        if (variable && variable.defs.length > 0) {
+                            const def = variable.defs[0];
+                            if (def.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration &&
+                                def.node.typeAnnotation.type ===
+                                    utils_1.AST_NODE_TYPES.TSTypeReference &&
+                                def.node.typeAnnotation.typeName.type ===
+                                    utils_1.AST_NODE_TYPES.Identifier &&
+                                HANDLER_TYPES.has(def.node.typeAnnotation.typeName.name)) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+            // Check if the function is exported with a type annotation
+            if (parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
+                parent.declaration?.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+                parent.declaration.declarations[0]?.id.type ===
+                    utils_1.AST_NODE_TYPES.Identifier &&
+                parent.declaration.declarations[0].id.typeAnnotation?.typeAnnotation) {
+                const typeNode = parent.declaration.declarations[0].id.typeAnnotation.typeAnnotation;
+                if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                    typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    HANDLER_TYPES.has(typeNode.typeName.name)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        // Count consecutive .parent calls in a member expression chain
+        function countParentChain(node) {
+            let count = 1; // Start with 1 for the current .parent
+            let current = node.object;
+            // Traverse the chain of member expressions
+            while (current.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                current.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                current.property.name === 'parent') {
+                count++;
+                current = current.object;
+            }
+            return count;
+        }
+        // This function has been removed as it's no longer needed
+        return {
+            // Register handler parameters to capture destructured event data
+            'ArrowFunctionExpression, FunctionExpression'(node) {
+                if (isHandlerFunction(node)) {
+                    registerHandlerParams(node);
+                }
+            },
+            // Track variable assignments that contain event data
+            VariableDeclarator(node) {
+                if (node.id.type === utils_1.AST_NODE_TYPES.Identifier && node.init) {
+                    // Track direct event.data assignments
+                    if (node.init.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        node.init.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.init.property.name === 'data' &&
+                        node.init.object.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        // Store the variable name and the source object (event)
+                        eventDataVariables.set(node.id.name, node.init.object.name);
+                        recordEventIdentifier(node.init.object.name);
+                    }
+                    // Track assignments from other tracked variables
+                    if (node.init.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        eventDataVariables.has(node.init.name)) {
+                        // Store the variable name with the same source as the original variable
+                        eventDataVariables.set(node.id.name, eventDataVariables.get(node.init.name) || '');
+                        const source = eventDataVariables.get(node.init.name);
+                        if (source) {
+                            recordEventIdentifier(source);
+                        }
+                    }
+                    // Track assignments from event data properties
+                    if (node.init.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        node.init.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        eventDataVariables.has(node.init.object.name)) {
+                        // Store the variable name with the same source as the original variable
+                        eventDataVariables.set(node.id.name, eventDataVariables.get(node.init.object.name) || '');
+                        const source = eventDataVariables.get(node.init.object.name);
+                        if (source) {
+                            recordEventIdentifier(source);
+                        }
+                    }
+                }
+                // Also track destructuring assignments
+                if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+                    node.init?.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const eventSource = eventDataVariables.get(node.init.name) ||
+                        (eventIdentifiers.has(node.init.name) ? node.init.name : null);
+                    for (const property of node.id.properties) {
+                        if (property.type === utils_1.AST_NODE_TYPES.Property &&
+                            property.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            property.value.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            eventSource) {
+                            const targetName = property.value.name;
+                            eventDataVariables.set(targetName, eventSource);
+                            recordEventIdentifier(eventSource);
+                        }
+                    }
+                }
+            },
+            // Check for excessive parent chains in member expressions
+            MemberExpression(node) {
+                // Only check for .parent chains
+                if (node.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    node.property.name !== 'parent') {
+                    return;
+                }
+                // Count the number of consecutive .parent calls
+                const parentCount = countParentChain(node);
+                if (parentCount <= maxParentChainLength) {
+                    return;
+                }
+                // Check if we're in a handler function
+                let current = node;
+                let inHandler = false;
+                while (current) {
+                    if (current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        current.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                        if (isHandlerFunction(current)) {
+                            inHandler = true;
+                            break;
+                        }
+                    }
+                    current = current.parent;
+                }
+                if (!inHandler) {
+                    return;
+                }
+                // Only report when the chain originates from tracked event data and contains a ref segment
+                const rootIdentifier = getRootIdentifier(node);
+                if (!rootIdentifier) {
+                    return;
+                }
+                if (!hasRefProperty(node) ||
+                    (!eventDataVariables.has(rootIdentifier) &&
+                        !eventIdentifiers.has(rootIdentifier))) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'excessiveParentChain',
+                    data: {
+                        count: parentCount,
+                    },
+                    suggest: [
+                        {
+                            messageId: 'excessiveParentChain',
+                            fix(fixer) {
+                                return fixer.replaceText(node, 'event.params');
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-excessive-parent-chain.js.map

package/lib/rules/no-explicit-return-type.d.ts

@@ -1,4 +1,5 @@
 import { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'noExplicitReturnTypeInferable' | 'noExplicitReturnTypeNonInferable';
 type Options = [
     {
         allowRecursiveFunctions?: boolean;
@@ -9,5 +10,5 @@ type Options = [
         allowFirestoreFunctionFiles?: boolean;
     }
 ];
-export declare const noExplicitReturnType: TSESLint.RuleModule<'noExplicitReturnType', Options>;
+export declare const noExplicitReturnType: TSESLint.RuleModule<MessageIds, Options>;
 export {};

package/lib/rules/no-explicit-return-type.js

@@ -11,6 +11,98 @@ const defaultOptions = {
     allowDtsFiles: true,
     allowFirestoreFunctionFiles: true,
 };
+function getNameFromIdentifierOrLiteral(key) {
+    if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    if (typeof key.value === 'string') {
+        return key.value;
+    }
+    return undefined;
+}
+function describeClassMethod(node) {
+    if (!node.computed &&
+        (node.key.type === utils_1.AST_NODE_TYPES.Identifier ||
+            (node.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.key.value === 'string'))) {
+        const name = getNameFromIdentifierOrLiteral(node.key);
+        if (name) {
+            return `class method "${name}"`;
+        }
+    }
+    return 'class method';
+}
+function describeMethodSignature(node) {
+    if (!node.computed &&
+        (node.key.type === utils_1.AST_NODE_TYPES.Identifier ||
+            (node.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.key.value === 'string'))) {
+        const name = getNameFromIdentifierOrLiteral(node.key);
+        if (name) {
+            return `interface method "${name}"`;
+        }
+    }
+    return 'interface method';
+}
+function describeFunctionDeclaration(node) {
+    if (node.id?.name) {
+        return `function "${node.id.name}"`;
+    }
+    return 'function';
+}
+function describeTSDeclareFunction(node) {
+    if (node.id?.name) {
+        return `function "${node.id.name}"`;
+    }
+    return 'function';
+}
+function describeFunctionExpression(node) {
+    if (node.id?.name) {
+        return `function "${node.id.name}"`;
+    }
+    if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+        node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return `function "${node.parent.id.name}"`;
+    }
+    if (node.parent?.type === utils_1.AST_NODE_TYPES.Property &&
+        !node.parent.computed &&
+        (node.parent.key.type === utils_1.AST_NODE_TYPES.Identifier ||
+            (node.parent.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.parent.key.value === 'string'))) {
+        const name = getNameFromIdentifierOrLiteral(node.parent.key);
+        if (name) {
+            return `object method "${name}"`;
+        }
+    }
+    return 'function expression';
+}
+function describeArrowFunction(node) {
+    if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+        node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return `arrow function "${node.parent.id.name}"`;
+    }
+    return 'arrow function';
+}
+function describeFunctionKind(node) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.MethodDefinition:
+            return describeClassMethod(node);
+        case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition:
+            return describeClassMethod(node);
+        case utils_1.AST_NODE_TYPES.TSMethodSignature:
+            return describeMethodSignature(node);
+        case utils_1.AST_NODE_TYPES.TSDeclareFunction:
+            return describeTSDeclareFunction(node);
+        case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+            return describeFunctionDeclaration(node);
+        case utils_1.AST_NODE_TYPES.FunctionExpression:
+            return describeFunctionExpression(node);
+        case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+            return describeArrowFunction(node);
+        default:
+            return 'function';
+    }
+}
 function isRecursiveFunction(node) {
     const functionName = node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration
         ? node.id?.name
@@ -63,16 +155,52 @@ function isOverloadedFunction(node) {
         const interfaceBody = node.parent;
         if (interfaceBody.type !== utils_1.AST_NODE_TYPES.TSInterfaceBody)
             return false;
-        const methodName = node.key.type === utils_1.AST_NODE_TYPES.Identifier ? node.key.name : undefined;
+        if (node.computed)
+            return false;
+        const methodName = node.key.type === utils_1.AST_NODE_TYPES.Identifier ||
+            node.key.type === utils_1.AST_NODE_TYPES.Literal
+            ? getNameFromIdentifierOrLiteral(node.key)
+            : undefined;
         if (!methodName)
             return false;
         return (interfaceBody.body.filter((member) => member.type === utils_1.AST_NODE_TYPES.TSMethodSignature &&
-            member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-            member.key.name === methodName).length > 1);
+            !member.computed &&
+            (member.key.type === utils_1.AST_NODE_TYPES.Identifier ||
+                member.key.type === utils_1.AST_NODE_TYPES.Literal) &&
+            getNameFromIdentifierOrLiteral(member.key) === methodName).length > 1);
+    }
+    return false;
+}
+function isOverloadedTsDeclareFunction(node) {
+    const functionName = node.id?.name;
+    if (!functionName)
+        return false;
+    let container = node.parent;
+    while (container) {
+        if (container.type === utils_1.AST_NODE_TYPES.Program ||
+            container.type === utils_1.AST_NODE_TYPES.TSModuleBlock) {
+            const declarations = container.body
+                .map((statement) => {
+                if (statement.type === utils_1.AST_NODE_TYPES.TSDeclareFunction) {
+                    return statement;
+                }
+                if (statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
+                    statement.declaration?.type === utils_1.AST_NODE_TYPES.TSDeclareFunction) {
+                    return statement.declaration;
+                }
+                return undefined;
+            })
+                .filter((value) => Boolean(value?.id?.name))
+                .filter((decl) => decl.id.name === functionName);
+            return declarations.length > 1;
+        }
+        container = container.parent;
     }
     return false;
 }
 function isInterfaceOrAbstractMethodSignature(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition)
+        return true;
     if (node.type === utils_1.AST_NODE_TYPES.TSMethodSignature)
         return true;
     if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
@@ -133,7 +261,8 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            noExplicitReturnType: 'Explicit return type is not allowed. Let TypeScript infer it.',
+            noExplicitReturnTypeInferable: "What's wrong: {{functionKind}} has an explicit return type annotation. \u2192 Why it matters: it must be updated manually and can drift from what the implementation actually returns, hiding bugs behind a stale type. \u2192 How to fix: remove the return type annotation so TypeScript infers it from the implementation.",
+            noExplicitReturnTypeNonInferable: "What's wrong: {{functionKind}} has an explicit return type annotation but no implementation body. \u2192 Why it matters: TypeScript cannot infer the return type here; removing it widens the return type to `any`. \u2192 How to fix: keep the annotation, or provide an implementation body where inference can succeed.",
         },
     },
     defaultOptions: [defaultOptions],
@@ -141,58 +270,77 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
         const mergedOptions = { ...defaultOptions, ...options };
         const filename = context.getFilename();
         if ((mergedOptions.allowDtsFiles && filename.endsWith('.d.ts')) ||
-            (mergedOptions.allowFirestoreFunctionFiles && filename.endsWith('.f.ts'))) {
+            (mergedOptions.allowFirestoreFunctionFiles &&
+                filename.endsWith('.f.ts'))) {
             return {};
         }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         function fixReturnType(fixer, node) {
-            const returnType = node.returnType || node.value?.returnType;
+            // Some nodes expose returnType directly while others nest it under value.
+            const returnType = 'returnType' in node
+                ? node.returnType
+                : 'value' in node
+                    ? node.value.returnType
+                    : null;
             if (!returnType)
                 return null;
-            // Create a fix that removes the return type annotation
             return fixer.remove(returnType);
         }
         return {
             FunctionDeclaration(node) {
-                if (!node.returnType)
+                const returnType = node.returnType;
+                if (!returnType)
                     return;
                 if (isTypeGuardFunction(node) ||
                     (mergedOptions.allowRecursiveFunctions && isRecursiveFunction(node))) {
                     return;
                 }
+                const isInferable = Boolean(node.body);
                 context.report({
-                    node: node.returnType,
-                    messageId: 'noExplicitReturnType',
-                    fix: (fixer) => fixReturnType(fixer, node),
+                    node: returnType,
+                    messageId: isInferable
+                        ? 'noExplicitReturnTypeInferable'
+                        : 'noExplicitReturnTypeNonInferable',
+                    data: { functionKind: describeFunctionKind(node) },
+                    ...(isInferable
+                        ? { fix: (fixer) => fixReturnType(fixer, node) }
+                        : {}),
                 });
             },
             FunctionExpression(node) {
-                if (!node.returnType)
+                const returnType = node.returnType;
+                if (!returnType)
+                    return;
+                if (node.parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
                     return;
+                }
                 if (isTypeGuardFunction(node) ||
                     (mergedOptions.allowRecursiveFunctions && isRecursiveFunction(node))) {
                     return;
                 }
                 context.report({
-                    node: node.returnType,
-                    messageId: 'noExplicitReturnType',
+                    node: returnType,
+                    messageId: 'noExplicitReturnTypeInferable',
+                    data: { functionKind: describeFunctionKind(node) },
                     fix: (fixer) => fixReturnType(fixer, node),
                 });
             },
             ArrowFunctionExpression(node) {
-                if (!node.returnType)
+                const returnType = node.returnType;
+                if (!returnType)
                     return;
                 if (isTypeGuardFunction(node)) {
                     return;
                 }
                 context.report({
-                    node: node.returnType,
-                    messageId: 'noExplicitReturnType',
+                    node: returnType,
+                    messageId: 'noExplicitReturnTypeInferable',
+                    data: { functionKind: describeFunctionKind(node) },
                     fix: (fixer) => fixReturnType(fixer, node),
                 });
             },
             TSMethodSignature(node) {
-                if (!node.returnType)
+                const returnType = node.returnType;
+                if (!returnType)
                     return;
                 if (mergedOptions.allowInterfaceMethodSignatures) {
                     return;
@@ -202,23 +350,64 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     return;
                 }
                 context.report({
-                    node: node.returnType,
-                    messageId: 'noExplicitReturnType',
-                    fix: (fixer) => fixReturnType(fixer, node),
+                    node: returnType,
+                    messageId: 'noExplicitReturnTypeNonInferable',
+                    data: { functionKind: describeFunctionKind(node) },
                 });
             },
             MethodDefinition(node) {
-                if (!node.value.returnType)
+                const returnType = node.value.returnType;
+                if (!returnType)
                     return;
                 if (isTypeGuardFunction(node.value) ||
                     (mergedOptions.allowAbstractMethodSignatures &&
                         isInterfaceOrAbstractMethodSignature(node))) {
                     return;
                 }
+                const isInferable = Boolean(node.value.body);
                 context.report({
-                    node: node.value.returnType,
-                    messageId: 'noExplicitReturnType',
-                    fix: (fixer) => fixReturnType(fixer, node),
+                    node: returnType,
+                    messageId: isInferable
+                        ? 'noExplicitReturnTypeInferable'
+                        : 'noExplicitReturnTypeNonInferable',
+                    data: { functionKind: describeFunctionKind(node) },
+                    ...(isInferable
+                        ? { fix: (fixer) => fixReturnType(fixer, node) }
+                        : {}),
+                });
+            },
+            TSAbstractMethodDefinition(node) {
+                const returnType = node.value.returnType;
+                if (!returnType)
+                    return;
+                if (isTypeGuardFunction(node.value) ||
+                    (mergedOptions.allowAbstractMethodSignatures &&
+                        isInterfaceOrAbstractMethodSignature(node))) {
+                    return;
+                }
+                // Abstract methods never have bodies; they are always non-inferable and
+                // intentionally have no fixer.
+                context.report({
+                    node: returnType,
+                    messageId: 'noExplicitReturnTypeNonInferable',
+                    data: { functionKind: describeFunctionKind(node) },
+                });
+            },
+            TSDeclareFunction(node) {
+                const returnType = node.returnType;
+                if (!returnType)
+                    return;
+                if (isTypeGuardFunction(node)) {
+                    return;
+                }
+                if (mergedOptions.allowOverloadedFunctions &&
+                    isOverloadedTsDeclareFunction(node)) {
+                    return;
+                }
+                context.report({
+                    node: returnType,
+                    messageId: 'noExplicitReturnTypeNonInferable',
+                    data: { functionKind: describeFunctionKind(node) },
                 });
             },
         };

package/lib/rules/no-filter-without-return.js

@@ -15,9 +15,13 @@ exports.noFilterWithoutReturn = (0, createRule_1.createRule)({
                         return;
                     }
                     if (!ASTHelpers_1.ASTHelpers.hasReturnStatement(body)) {
+                        const filterCall = context.getSourceCode().getText(node.callee);
                         context.report({
                             node,
                             messageId: 'unexpected',
+                            data: {
+                                filterCall,
+                            },
                         });
                     }
                 }
@@ -33,7 +37,7 @@ exports.noFilterWithoutReturn = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unexpected: 'Array.filter callbacks with block statements must contain a return statement. Instead of `array.filter(x => { doSomething(x); })`, use `array.filter(x => { doSomething(x); return someCondition; })` or use implicit return `array.filter(x => someCondition)`.',
+            unexpected: 'Callback for {{filterCall}} uses braces but never returns a value, so filter receives undefined for every element and silently drops them all. Return the predicate result from inside the block (e.g., "return matches(item);") or use a concise arrow like {{filterCall}}((item) => matches(item)) to make the keep/remove condition explicit.',
         },
     },
     defaultOptions: [],

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

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