@blumintinc/eslint-plugin-blumint 1.3.2 → 1.5.0

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

@@ -8,24 +8,58 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce using set() with { merge: true } instead of update() for Firestore operations',
+            description: 'Enforce using set() with { merge: true } instead of update() for Firestore operations to ensure consistent behavior. The update() method fails if the document does not exist, while set() with { merge: true } creates the document if needed and safely merges fields, making it more reliable and predictable.',
             recommended: 'error',
+            requiresTypeChecking: false,
+            extendsBaseRule: false,
         },
         fixable: 'code',
         schema: [],
         messages: {
-            preferSetMerge: 'Use set() with { merge: true } instead of update() for more predictable Firestore operations',
+            preferSetMerge: 'Use set() with { merge: true } instead of update() for more predictable Firestore operations. Instead of `docRef.update({ field: value })`, use `docRef.set({ field: value }, { merge: true })`. This ensures consistent behavior when the document does not exist.',
         },
     },
     defaultOptions: [],
     create(context) {
         const updateAliases = new Set();
         function isFirestoreUpdateCall(node) {
+            // Check if it's a set() call with merge: true
             if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
                 const property = node.callee.property;
-                return property.type === utils_1.AST_NODE_TYPES.Identifier && property.name === 'update';
+                if (property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    // If it's a set() call, check if it has merge: true
+                    if (property.name === 'set') {
+                        const lastArg = node.arguments[node.arguments.length - 1];
+                        if (lastArg?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                            const hasMergeTrue = lastArg.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                                prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                prop.key.name === 'merge' &&
+                                prop.value.type === utils_1.AST_NODE_TYPES.Literal &&
+                                prop.value.value === true);
+                            if (hasMergeTrue) {
+                                return false; // Already using set with merge: true
+                            }
+                        }
+                    }
+                    // Only flag update() calls
+                    return property.name === 'update';
+                }
             }
             if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                // Check if it's a setDoc() call with merge: true
+                if (node.callee.name === 'setDoc') {
+                    const lastArg = node.arguments[node.arguments.length - 1];
+                    if (lastArg?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        const hasMergeTrue = lastArg.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            prop.key.name === 'merge' &&
+                            prop.value.type === utils_1.AST_NODE_TYPES.Literal &&
+                            prop.value.value === true);
+                        if (hasMergeTrue) {
+                            return false; // Already using setDoc with merge: true
+                        }
+                    }
+                }
                 return updateAliases.has(node.callee.name);
             }
             return false;
@@ -51,8 +85,9 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
         }
         return {
             ImportDeclaration(node) {
-                if (node.source.value === 'firebase/firestore' || node.source.value === 'firebase-admin') {
-                    node.specifiers.forEach(specifier => {
+                if (node.source.value === 'firebase/firestore' ||
+                    node.source.value === 'firebase-admin') {
+                    node.specifiers.forEach((specifier) => {
                         if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
                             if (specifier.imported.name === 'updateDoc') {
                                 updateAliases.add(specifier.local.name);
@@ -63,7 +98,8 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
             },
             ImportExpression(node) {
                 if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
-                    (node.source.value === 'firebase/firestore' || node.source.value === 'firebase-admin')) {
+                    (node.source.value === 'firebase/firestore' ||
+                        node.source.value === 'firebase-admin')) {
                     // Dynamic imports are handled in VariableDeclarator
                 }
             },
@@ -72,10 +108,11 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                     node.init.argument.type === utils_1.AST_NODE_TYPES.ImportExpression) {
                     const importSource = node.init.argument.source;
                     if (importSource.type === utils_1.AST_NODE_TYPES.Literal &&
-                        (importSource.value === 'firebase/firestore' || importSource.value === 'firebase-admin')) {
+                        (importSource.value === 'firebase/firestore' ||
+                            importSource.value === 'firebase-admin')) {
                         // Handle destructured imports
                         if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
-                            node.id.properties.forEach(prop => {
+                            node.id.properties.forEach((prop) => {
                                 if (prop.type === utils_1.AST_NODE_TYPES.Property &&
                                     prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                                     prop.key.name === 'updateDoc') {

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

@@ -17,8 +17,8 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            missingType: 'Expected exported type "{{ typeName }}" in index.ts under folder "{{ folderName }}"',
-            notExtendingIdentifiable: 'Type "{{ typeName }}" must extend "Identifiable", including an "id: string" field',
+            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 */ }`.',
         },
     },
     defaultOptions: [],

package/lib/rules/enforce-memoize-async.js

@@ -8,13 +8,13 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce @Memoize() decorator on async methods with 0-1 parameters',
+            description: 'Enforce @Memoize() decorator on async methods with 0-1 parameters to cache results and prevent redundant API calls or expensive computations. This improves performance by reusing previous results when the same parameters are provided, particularly useful for data fetching methods.',
             recommended: 'error',
         },
         fixable: 'code',
         schema: [],
         messages: {
-            requireMemoize: 'Async methods with 0-1 parameters should be decorated with @Memoize()',
+            requireMemoize: 'Async methods with 0-1 parameters should be decorated with @Memoize() to cache results and improve performance. Instead of `async getData(id?: string)`, use `@Memoize()\nasync getData(id?: string)`. Import Memoize from "typescript-memoize".',
         },
     },
     defaultOptions: [],

package/lib/rules/enforce-mock-firestore.js

@@ -13,13 +13,13 @@ exports.enforceFirestoreMock = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce using mockFirestore over manual Firestore mocking',
+            description: 'Enforce using the standardized mockFirestore utility instead of manual Firestore mocking or third-party mocks. This ensures consistent test behavior across the codebase, reduces boilerplate, and provides type-safe mocking of Firestore operations.',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            noManualFirestoreMock: 'Use mockFirestore from __mocks__/functions/src/config/mockFirestore instead of manually mocking Firestore',
-            noMockFirebase: 'Use mockFirestore from __mocks__/functions/src/config/mockFirestore instead of mockFirebase',
+            noManualFirestoreMock: 'Use mockFirestore from __mocks__/functions/src/config/mockFirestore instead of manually mocking Firestore. Replace `jest.mock("firebase-admin", () => ({ firestore: () => ({ /* mock */ }) }))` with `import { mockFirestore } from "__mocks__/functions/src/config/mockFirestore"; jest.mock("firebase-admin", () => mockFirestore)`.',
+            noMockFirebase: 'Use mockFirestore from __mocks__/functions/src/config/mockFirestore instead of mockFirebase. Replace `import { mockFirebase } from "firestore-jest-mock"` with `import { mockFirestore } from "__mocks__/functions/src/config/mockFirestore"`.',
         },
     },
     defaultOptions: [],

package/lib/rules/enforce-realtimedb-path-utils.js

@@ -14,7 +14,7 @@ exports.enforceRealtimedbPathUtils = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            requirePathUtil: 'Use a utility function (e.g., toUserPath, toItemPath) for Realtime Database paths instead of string literals',
+            requirePathUtil: 'Use a utility function for Realtime Database paths to ensure type safety and maintainability. Instead of `ref("users/" + userId)`, create and use a utility function: `const toUserPath = (id: string) => `users/${id}`; ref(toUserPath(userId))`.',
         },
     },
     defaultOptions: [],

package/lib/rules/enforce-safe-stringify.js

@@ -8,13 +8,13 @@ exports.enforceStableStringify = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce using safe-stable-stringify instead of JSON.stringify',
+            description: 'Enforce using safe-stable-stringify instead of JSON.stringify to handle circular references and ensure deterministic output. JSON.stringify can throw errors on circular references and produce inconsistent output for objects with the same properties in different orders. safe-stable-stringify handles these cases safely.',
             recommended: 'error',
         },
         fixable: 'code',
         schema: [],
         messages: {
-            useStableStringify: 'Use safe-stable-stringify instead of JSON.stringify for safer serialization',
+            useStableStringify: 'Use safe-stable-stringify instead of JSON.stringify for safer serialization. Replace `JSON.stringify(obj)` with `stringify(obj)`. First import it: `import stringify from "safe-stable-stringify"`. This handles circular references and provides deterministic output.',
         },
     },
     defaultOptions: [],

package/lib/rules/enforce-serializable-params.js

@@ -17,7 +17,7 @@ exports.default = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce serializable parameters in Firebase Callable/HTTPS Cloud Functions',
+            description: 'Enforce serializable parameters in Firebase Callable/HTTPS Cloud Functions to prevent runtime errors. Firebase Functions can only pass JSON-serializable data, so using non-serializable types like Date, DocumentReference, or Map will cause failures. Use primitive types, plain objects, and arrays instead, converting complex types to their serializable representations (e.g., Date to ISO string).',
             recommended: 'error',
         },
         schema: [
@@ -38,8 +38,8 @@ exports.default = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            nonSerializableParam: 'Parameter type "{{ type }}" is not serializable',
-            nonSerializableProperty: 'Property "{{ prop }}" has non-serializable type "{{ type }}"',
+            nonSerializableParam: 'Parameter type "{{ type }}" is not serializable in Firebase Cloud Functions. Use JSON-serializable types like string, number, boolean, arrays, or plain objects. Instead of `Date`, use ISO strings: `new Date().toISOString()`.',
+            nonSerializableProperty: 'Property "{{ prop }}" has non-serializable type "{{ type }}". Use JSON-serializable types. For example, instead of `{ timestamp: Date }`, use `{ timestamp: string }` with ISO format.',
         },
     },
     defaultOptions: [

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

@@ -8,6 +8,22 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const compromise_1 = __importDefault(require("compromise"));
 const PREPOSITIONS = ['to', 'from', 'with', 'by', 'at', 'of'];
+// Common short verbs that should be allowed
+const COMMON_VERBS = new Set([
+    'sync',
+    'fix',
+    'set',
+    'log',
+    'get',
+    'put',
+    'add',
+    'map',
+    'run',
+    'use',
+    'has',
+    'is',
+    'do',
+]);
 exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
     name: 'enforce-verb-noun-naming',
     meta: {
@@ -15,6 +31,8 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
         docs: {
             description: 'Enforce verb phrases for functions and methods',
             recommended: 'error',
+            requiresTypeChecking: false,
+            extendsBaseRule: false,
         },
         schema: [],
         messages: {
@@ -30,7 +48,8 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
             return firstChar + words[0];
         }
         function toSentence(name) {
-            return name.split(/(?=[A-Z])/).join(' ');
+            // Add "I" prefix to create a proper sentence for better verb detection
+            return 'I ' + name.split(/(?=[A-Z])/).join(' ');
         }
         function getPossibleTags(sentence) {
             const doc = (0, compromise_1.default)(sentence);
@@ -43,14 +62,23 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
         function isVerbPhrase(name) {
             const firstWord = extractFirstWord(name);
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (PREPOSITIONS.includes(firstWord.toLowerCase())) {
+            const firstWordLower = firstWord.toLowerCase();
+            // Check for prepositions and common verbs first
+            if (PREPOSITIONS.includes(firstWordLower) || COMMON_VERBS.has(firstWordLower)) {
                 return true;
             }
-            const tags = getPossibleTags(toSentence(name));
-            const isVerb = tags.includes('Verb');
-            const isPreposition = tags.includes('Preposition');
-            const isConjunction = tags.includes('Conjunction');
-            return isVerb || isPreposition || isConjunction;
+            // Try both with and without "I" prefix to catch more verb forms
+            const withPrefixTags = getPossibleTags(toSentence(name));
+            const withoutPrefixTags = getPossibleTags(firstWord);
+            // Check if either form is recognized as a verb
+            const isVerb = withPrefixTags.includes('Verb') || withoutPrefixTags.includes('Verb');
+            const isPreposition = withPrefixTags.includes('Preposition');
+            const isConjunction = withPrefixTags.includes('Conjunction');
+            // For non-prepositions/conjunctions, require verb form
+            if (isPreposition || isConjunction) {
+                return true;
+            }
+            return isVerb;
         }
         function isJsxReturnFunction(node) {
             if (node.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration &&
@@ -97,6 +125,12 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
             MethodDefinition(node) {
                 if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                     return;
+                // Skip getters since they represent properties and should use noun phrases
+                if (node.kind === 'get')
+                    return;
+                // Skip constructors since they are special class methods
+                if (node.kind === 'constructor')
+                    return;
                 if (!isVerbPhrase(node.key.name)) {
                     context.report({
                         node: node.key,

package/lib/rules/no-async-array-filter.js

@@ -27,12 +27,12 @@ exports.noAsyncArrayFilter = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Disallow async callbacks for Array.filter',
+            description: 'Disallow async callbacks in Array.filter() as they lead to incorrect filtering. Since async functions return Promises which are always truthy, the filter will keep all elements regardless of the async check\'s result. Use Promise.all() with map() first, then filter based on the resolved results.',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            unexpected: 'Async array filter is dangerous as a Promise object will always be truthy. You should move the asynchronous logic elsewhere.',
+            unexpected: 'Async array filter is dangerous as a Promise object will always be truthy. Instead of `array.filter(async x => await someCheck(x))`, first resolve the promises with `Promise.all()` or move the async logic elsewhere: `const results = await Promise.all(array.map(x => someCheck(x))); array.filter((_, i) => results[i])`.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-async-foreach.js

@@ -24,7 +24,7 @@ exports.noAsyncForEach = {
     meta: {
         type: 'problem',
         docs: {
-            description: 'Disallow Array.forEach with an async callback function',
+            description: 'Disallow Array.forEach with an async callback function as it does not wait for promises to resolve. This can lead to race conditions and unexpected behavior. Use a standard for...of loop for sequential execution or Promise.all with map for concurrent execution.',
             recommended: 'error',
         },
         messages: {

package/lib/rules/no-class-instance-destructuring.d.ts

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

package/lib/rules/no-class-instance-destructuring.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noClassInstanceDestructuring = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
+    name: 'no-class-instance-destructuring',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow destructuring of class instances to prevent loss of `this` context',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            noClassInstanceDestructuring: 'Avoid destructuring class instances as it can lead to loss of `this` context. Use direct property access instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function isClassInstance(node) {
+            // Check for new expressions
+            if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                return true;
+            }
+            // Check for identifiers that might be class instances
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const variableDef = context
+                    .getScope()
+                    .variables.find((variableDef) => variableDef.name === node.name);
+                if (variableDef?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    const init = variableDef.defs[0].node
+                        .init;
+                    return init?.type === utils_1.AST_NODE_TYPES.NewExpression;
+                }
+            }
+            return false;
+        }
+        return {
+            VariableDeclarator(node) {
+                if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+                    node.init &&
+                    isClassInstance(node.init)) {
+                    const objectPattern = node.id;
+                    context.report({
+                        node,
+                        messageId: 'noClassInstanceDestructuring',
+                        fix(fixer) {
+                            const sourceCode = context.getSourceCode();
+                            const properties = objectPattern.properties;
+                            // Skip if there's no init expression
+                            if (!node.init)
+                                return null;
+                            // For single property, use simple replacement
+                            if (properties.length === 1) {
+                                const prop = properties[0];
+                                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                                    const key = prop.key.type === utils_1.AST_NODE_TYPES.Identifier
+                                        ? prop.key.name
+                                        : sourceCode.getText(prop.key);
+                                    const value = prop.value.type === utils_1.AST_NODE_TYPES.Identifier
+                                        ? prop.value.name
+                                        : sourceCode.getText(prop.value);
+                                    const initText = sourceCode.getText(node.init);
+                                    return fixer.replaceText(node, `${value} = ${initText}.${key}`);
+                                }
+                                return null;
+                            }
+                            // For multiple properties, create multiple declarations
+                            const declarations = properties
+                                .filter((prop) => prop.type === utils_1.AST_NODE_TYPES.Property)
+                                .map((prop) => {
+                                const key = prop.key.type === utils_1.AST_NODE_TYPES.Identifier
+                                    ? prop.key.name
+                                    : sourceCode.getText(prop.key);
+                                const value = prop.value.type === utils_1.AST_NODE_TYPES.Identifier
+                                    ? prop.value.name
+                                    : sourceCode.getText(prop.value);
+                                const initText = sourceCode.getText(node.init);
+                                return `${value} = ${initText}.${key}`;
+                            })
+                                .join(';\nconst ');
+                            // Only apply the fix if we have valid declarations
+                            if (!declarations)
+                                return null;
+                            return fixer.replaceText(node, declarations);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-class-instance-destructuring.js.map

package/lib/rules/no-compositing-layer-props.js

@@ -37,7 +37,7 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Warn when using CSS properties that trigger compositing layers',
+            description: 'Warn when using CSS properties that trigger compositing layers, which can impact performance. Properties like transform, opacity, filter, and will-change create new GPU layers. While sometimes beneficial for animations, excessive layer creation can increase memory usage and hurt performance. Consider alternatives or explicitly document intentional layer promotion.',
             recommended: 'error',
         },
         schema: [],

package/lib/rules/no-conditional-literals-in-jsx.js

@@ -14,7 +14,7 @@ exports.noConditionalLiteralsInJsx = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unexpected: 'Conditional expression is a sibling of raw text and must be wrapped in <div> or <span>',
+            unexpected: 'Conditional text literals must be wrapped in a container element when next to other text. Instead of `<div>text {condition && "more text"}</div>`, use `<div>text <span>{condition && "more text"}</span></div>` to prevent React hydration issues.',
         },
     },
     defaultOptions: [],

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

@@ -136,7 +136,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Avoid using entire objects in React hook dependency arrays when only specific fields are used. Requires TypeScript and `parserOptions.project` to be configured.',
+            description: 'Avoid using entire objects in React hook dependency arrays when only specific fields are used, as this can cause unnecessary re-renders. When a hook only uses obj.name but obj is in the deps array, any change to obj.age will trigger the hook. Use individual fields (obj.name) instead of the entire object. Requires TypeScript and `parserOptions.project` to be configured.',
             recommended: 'error',
             requiresTypeChecking: true,
         },

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

@@ -1,3 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         allowRecursiveFunctions?: boolean;
@@ -5,7 +6,8 @@ type Options = [
         allowInterfaceMethodSignatures?: boolean;
         allowAbstractMethodSignatures?: boolean;
         allowDtsFiles?: boolean;
+        allowFirestoreFunctionFiles?: boolean;
     }
 ];
-export declare const noExplicitReturnType: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noExplicitReturnType", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const noExplicitReturnType: TSESLint.RuleModule<'noExplicitReturnType', Options>;
 export {};

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

@@ -9,11 +9,14 @@ const defaultOptions = {
     allowInterfaceMethodSignatures: true,
     allowAbstractMethodSignatures: true,
     allowDtsFiles: true,
+    allowFirestoreFunctionFiles: true,
 };
 function isRecursiveFunction(node) {
-    const functionName = node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ? node.id?.name :
-        node.type === utils_1.AST_NODE_TYPES.FunctionExpression && node.id ? node.id.name :
-            undefined;
+    const functionName = node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration
+        ? node.id?.name
+        : node.type === utils_1.AST_NODE_TYPES.FunctionExpression && node.id
+            ? node.id.name
+            : undefined;
     if (!functionName || !node.body)
         return false;
     let hasRecursiveCall = false;
@@ -63,9 +66,9 @@ function isOverloadedFunction(node) {
         const methodName = node.key.type === utils_1.AST_NODE_TYPES.Identifier ? node.key.name : undefined;
         if (!methodName)
             return false;
-        return interfaceBody.body.filter(member => member.type === utils_1.AST_NODE_TYPES.TSMethodSignature &&
+        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.key.name === methodName).length > 1);
     }
     return false;
 }
@@ -75,7 +78,8 @@ function isInterfaceOrAbstractMethodSignature(node) {
     if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
         let current = node;
         while (current) {
-            if (current.type === utils_1.AST_NODE_TYPES.ClassDeclaration && current.abstract) {
+            if (current.type === utils_1.AST_NODE_TYPES.ClassDeclaration &&
+                current.abstract) {
                 return true;
             }
             current = current.parent;
@@ -88,8 +92,10 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Disallow explicit return types on functions',
+            description: 'Disallow explicit return type annotations on functions when TypeScript can infer them. This reduces code verbosity and maintenance burden while leveraging TypeScript\'s powerful type inference. Exceptions are made for recursive functions, overloaded functions, interface methods, and abstract methods where explicit types improve clarity.',
             recommended: 'error',
+            requiresTypeChecking: false,
+            extendsBaseRule: false,
         },
         fixable: 'code',
         schema: [
@@ -101,6 +107,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     allowInterfaceMethodSignatures: { type: 'boolean' },
                     allowAbstractMethodSignatures: { type: 'boolean' },
                     allowDtsFiles: { type: 'boolean' },
+                    allowFirestoreFunctionFiles: { type: 'boolean' },
                 },
                 additionalProperties: false,
             },
@@ -113,9 +120,11 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
     create(context, [options]) {
         const mergedOptions = { ...defaultOptions, ...options };
         const filename = context.getFilename();
-        if (mergedOptions.allowDtsFiles && filename.endsWith('.d.ts')) {
+        if ((mergedOptions.allowDtsFiles && filename.endsWith('.d.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;
             if (!returnType)
@@ -127,25 +136,27 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             FunctionDeclaration(node) {
                 if (!node.returnType)
                     return;
-                if (mergedOptions.allowRecursiveFunctions && isRecursiveFunction(node)) {
+                if (mergedOptions.allowRecursiveFunctions &&
+                    isRecursiveFunction(node)) {
                     return;
                 }
                 context.report({
                     node: node.returnType,
                     messageId: 'noExplicitReturnType',
-                    fix: fixer => fixReturnType(fixer, node),
+                    fix: (fixer) => fixReturnType(fixer, node),
                 });
             },
             FunctionExpression(node) {
                 if (!node.returnType)
                     return;
-                if (mergedOptions.allowRecursiveFunctions && isRecursiveFunction(node)) {
+                if (mergedOptions.allowRecursiveFunctions &&
+                    isRecursiveFunction(node)) {
                     return;
                 }
                 context.report({
                     node: node.returnType,
                     messageId: 'noExplicitReturnType',
-                    fix: fixer => fixReturnType(fixer, node),
+                    fix: (fixer) => fixReturnType(fixer, node),
                 });
             },
             ArrowFunctionExpression(node) {
@@ -154,7 +165,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 context.report({
                     node: node.returnType,
                     messageId: 'noExplicitReturnType',
-                    fix: fixer => fixReturnType(fixer, node),
+                    fix: (fixer) => fixReturnType(fixer, node),
                 });
             },
             TSMethodSignature(node) {
@@ -163,25 +174,27 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 if (mergedOptions.allowInterfaceMethodSignatures) {
                     return;
                 }
-                if (mergedOptions.allowOverloadedFunctions && isOverloadedFunction(node)) {
+                if (mergedOptions.allowOverloadedFunctions &&
+                    isOverloadedFunction(node)) {
                     return;
                 }
                 context.report({
                     node: node.returnType,
                     messageId: 'noExplicitReturnType',
-                    fix: fixer => fixReturnType(fixer, node),
+                    fix: (fixer) => fixReturnType(fixer, node),
                 });
             },
             MethodDefinition(node) {
                 if (!node.value.returnType)
                     return;
-                if (mergedOptions.allowAbstractMethodSignatures && isInterfaceOrAbstractMethodSignature(node)) {
+                if (mergedOptions.allowAbstractMethodSignatures &&
+                    isInterfaceOrAbstractMethodSignature(node)) {
                     return;
                 }
                 context.report({
                     node: node.value.returnType,
                     messageId: 'noExplicitReturnType',
-                    fix: fixer => fixReturnType(fixer, node),
+                    fix: (fixer) => fixReturnType(fixer, node),
                 });
             },
         };

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

@@ -33,7 +33,7 @@ exports.noFilterWithoutReturn = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unexpected: 'An array filter callback with a block statement must contain a return statement',
+            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)`.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-misused-switch-case.js

@@ -7,12 +7,12 @@ exports.noMisusedSwitchCase = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Prevent misuse of logical OR in switch case statements',
+            description: 'Prevent misuse of logical OR (||) in switch case statements, which can lead to confusing and error-prone code. Instead of using OR operators in case expressions, use multiple case statements in sequence to handle multiple values. This improves code readability and follows the standard switch-case pattern.',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            noMisusedSwitchCase: 'Avoid using logical OR  in switch case. Use cascading cases instead.',
+            noMisusedSwitchCase: 'Avoid using logical OR (||) in switch case statements. Instead of `case x || y:`, use cascading cases like `case x: case y:`.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-redundant-param-types.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noRedundantParamTypes: TSESLint.RuleModule<"redundantParamType", [], TSESLint.RuleListener>;