@blumintinc/eslint-plugin-blumint 1.12.1 → 1.12.3

package/lib/index.js

@@ -103,10 +103,12 @@ const enforce_dynamic_file_naming_1 = __importDefault(require("./rules/enforce-d
 const prefer_usecallback_over_usememo_for_functions_1 = __importDefault(require("./rules/prefer-usecallback-over-usememo-for-functions"));
 const no_margin_properties_1 = require("./rules/no-margin-properties");
 const enforce_boolean_naming_prefixes_1 = require("./rules/enforce-boolean-naming-prefixes");
+const prefer_block_comments_for_declarations_1 = require("./rules/prefer-block-comments-for-declarations");
+const no_undefined_null_passthrough_1 = require("./rules/no-undefined-null-passthrough");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.12.1',
+        version: '1.12.3',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -115,6 +117,7 @@ module.exports = {
         recommended: {
             plugins: ['@blumintinc/blumint'],
             rules: {
+                '@blumintinc/blumint/prefer-block-comments-for-declarations': 'error',
                 '@blumintinc/blumint/key-only-outermost-element': 'error',
                 '@blumintinc/blumint/avoid-utils-directory': 'error',
                 '@blumintinc/blumint/enforce-firestore-path-utils': 'error',
@@ -221,10 +224,12 @@ module.exports = {
                 '@blumintinc/blumint/prefer-usecallback-over-usememo-for-functions': 'error',
                 '@blumintinc/blumint/no-margin-properties': 'error',
                 '@blumintinc/blumint/enforce-boolean-naming-prefixes': 'error',
+                '@blumintinc/blumint/no-undefined-null-passthrough': 'error',
             },
         },
     },
     rules: {
+        'prefer-block-comments-for-declarations': prefer_block_comments_for_declarations_1.preferBlockCommentsForDeclarations,
         'key-only-outermost-element': key_only_outermost_element_1.keyOnlyOutermostElement,
         'array-methods-this-context': array_methods_this_context_1.arrayMethodsThisContext,
         'class-methods-read-top-to-bottom': class_methods_read_top_to_bottom_1.classMethodsReadTopToBottom,
@@ -325,6 +330,7 @@ module.exports = {
         'prefer-usecallback-over-usememo-for-functions': prefer_usecallback_over_usememo_for_functions_1.default,
         'no-margin-properties': no_margin_properties_1.noMarginProperties,
         'enforce-boolean-naming-prefixes': enforce_boolean_naming_prefixes_1.enforceBooleanNamingPrefixes,
+        'no-undefined-null-passthrough': no_undefined_null_passthrough_1.noUndefinedNullPassthrough,
     },
 };
 //# sourceMappingURL=index.js.map

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -20,6 +20,7 @@ const DEFAULT_BOOLEAN_PREFIXES = [
     'supports',
     'needs',
     'asserts',
+    'includes',
 ];
 exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
     name: 'enforce-boolean-naming-prefixes',
@@ -119,9 +120,48 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     ['===', '!==', '==', '!=', '>', '<', '>=', '<='].includes(node.init.operator)) {
                     return true;
                 }
-                // Check for logical expressions (&&, ||)
+                // Check for logical expressions (&&)
                 if (node.init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
                     node.init.operator === '&&') {
+                    // Check if the right side is a method call that might return a non-boolean value
+                    const rightSide = node.init.right;
+                    if (rightSide.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                        // If the method name doesn't suggest it returns a boolean, don't flag it
+                        if (rightSide.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                            rightSide.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const methodName = rightSide.callee.property.name;
+                            // Check if the method name suggests it returns a boolean
+                            const isBooleanMethod = approvedPrefixes.some((prefix) => methodName.toLowerCase().startsWith(prefix.toLowerCase()));
+                            // If the method name suggests it returns a boolean (starts with a boolean prefix or contains 'boolean' or 'enabled'),
+                            // then the variable should be treated as a boolean
+                            if (isBooleanMethod ||
+                                methodName.toLowerCase().includes('boolean') ||
+                                methodName.toLowerCase().includes('enabled') ||
+                                methodName.toLowerCase().includes('auth') ||
+                                methodName.toLowerCase().includes('valid') ||
+                                methodName.toLowerCase().includes('check')) {
+                                return true;
+                            }
+                            // For methods like getVolume(), getData(), etc., assume they return non-boolean values
+                            if (methodName.toLowerCase().startsWith('get') ||
+                                methodName.toLowerCase().startsWith('fetch') ||
+                                methodName.toLowerCase().startsWith('retrieve') ||
+                                methodName.toLowerCase().startsWith('load') ||
+                                methodName.toLowerCase().startsWith('read')) {
+                                return false;
+                            }
+                        }
+                    }
+                    // For property access like user.isAuthenticated, treat as boolean
+                    if (rightSide.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        rightSide.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const propertyName = rightSide.property.name;
+                        const isBooleanProperty = approvedPrefixes.some((prefix) => propertyName.toLowerCase().startsWith(prefix.toLowerCase()));
+                        if (isBooleanProperty) {
+                            return true;
+                        }
+                    }
+                    // Default to true for other cases with && to avoid false negatives
                     return true;
                 }
                 // Special case for logical OR (||) - only consider it boolean if:

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

@@ -7,6 +7,68 @@ const FIRESTORE_METHODS = new Set(['get', 'set', 'update', 'delete']);
 const isMemberExpression = (node) => {
     return node.type === utils_1.AST_NODE_TYPES.MemberExpression;
 };
+// Track variables that are assigned realtimeDb references
+const realtimeDbRefVariables = new Set();
+const realtimeDbChildVariables = new Set();
+const isRealtimeDbRefAssignment = (node) => {
+    if (node.type !== utils_1.AST_NODE_TYPES.VariableDeclarator)
+        return false;
+    const init = node.init;
+    if (!init)
+        return false;
+    // Check for direct realtimeDb.ref() assignments
+    // e.g., const ref = realtimeDb.ref(path);
+    if (init.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        isMemberExpression(init.callee) &&
+        isIdentifier(init.callee.property) &&
+        init.callee.property.name === 'ref' &&
+        isIdentifier(init.callee.object) &&
+        (init.callee.object.name === 'realtimeDb' || init.callee.object.name.includes('realtimeDb'))) {
+        if (isIdentifier(node.id)) {
+            realtimeDbRefVariables.add(node.id.name);
+            return true;
+        }
+    }
+    // Check for child() method calls on realtimeDb refs
+    // e.g., const childRef = parentRef.child('path');
+    if (init.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        isMemberExpression(init.callee) &&
+        isIdentifier(init.callee.property) &&
+        init.callee.property.name === 'child' &&
+        isIdentifier(init.callee.object) &&
+        realtimeDbRefVariables.has(init.callee.object.name)) {
+        if (isIdentifier(node.id)) {
+            realtimeDbChildVariables.add(node.id.name);
+            return true;
+        }
+    }
+    return false;
+};
+const isRealtimeDbReference = (node) => {
+    // Check if it's a direct realtimeDb.ref() call
+    if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        isMemberExpression(node.callee) &&
+        isIdentifier(node.callee.property) &&
+        node.callee.property.name === 'ref' &&
+        isIdentifier(node.callee.object) &&
+        (node.callee.object.name === 'realtimeDb' || node.callee.object.name.includes('realtimeDb'))) {
+        return true;
+    }
+    // Check if it's a variable that holds a realtimeDb reference
+    if (isIdentifier(node)) {
+        return realtimeDbRefVariables.has(node.name) || realtimeDbChildVariables.has(node.name);
+    }
+    // Check if it's a child() call on a realtimeDb reference
+    if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        isMemberExpression(node.callee) &&
+        isIdentifier(node.callee.property) &&
+        node.callee.property.name === 'child' &&
+        isIdentifier(node.callee.object) &&
+        (realtimeDbRefVariables.has(node.callee.object.name) || realtimeDbChildVariables.has(node.callee.object.name))) {
+        return true;
+    }
+    return false;
+};
 const isFirestoreMethodCall = (node) => {
     if (!isMemberExpression(node.callee))
         return false;
@@ -24,11 +86,19 @@ const isFirestoreMethodCall = (node) => {
             name.includes('Tx')) {
             return false;
         }
+        // Skip if it's a realtimeDb reference variable
+        if (realtimeDbRefVariables.has(name) || realtimeDbChildVariables.has(name)) {
+            return false;
+        }
         // Check for batch or transaction
         if (/batch|transaction/i.test(name)) {
             return true;
         }
     }
+    // Check if the method is called on a realtimeDb reference
+    if (isRealtimeDbReference(object)) {
+        return false;
+    }
     // Handle type assertions (as in the bug report)
     if (object.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
         return true;
@@ -41,10 +111,12 @@ const isFirestoreMethodCall = (node) => {
             const callee = current.callee;
             if (isMemberExpression(callee)) {
                 const property = callee.property;
-                if (isIdentifier(property) &&
-                    (property.name === 'doc' || property.name === 'collection')) {
-                    foundDocOrCollection = true;
-                    break;
+                if (isIdentifier(property)) {
+                    // Check for Firestore methods
+                    if (property.name === 'doc' || property.name === 'collection') {
+                        foundDocOrCollection = true;
+                        break;
+                    }
                 }
             }
         }
@@ -63,8 +135,11 @@ const isFirestoreMethodCall = (node) => {
     if (!foundDocOrCollection && isIdentifier(object)) {
         const name = object.name;
         // If the variable name contains 'doc' or 'ref', it's likely a Firestore reference
-        if (name.toLowerCase().includes('doc') ||
-            name.toLowerCase().includes('ref')) {
+        // But exclude realtimeDb references
+        if ((name.toLowerCase().includes('doc') || name.toLowerCase().includes('ref')) &&
+            !name.includes('realtimeDb') &&
+            !realtimeDbRefVariables.has(name) &&
+            !realtimeDbChildVariables.has(name)) {
             return true;
         }
     }
@@ -94,7 +169,14 @@ exports.enforceFirestoreFacade = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        // Clear the sets at the beginning of each file analysis
+        realtimeDbRefVariables.clear();
+        realtimeDbChildVariables.clear();
         return {
+            // Track variable declarations that are assigned realtimeDb references
+            VariableDeclarator(node) {
+                isRealtimeDbRefAssignment(node);
+            },
             CallExpression(node) {
                 if (!isFirestoreMethodCall(node))
                     return;

package/lib/rules/enforce-microdiff.js

@@ -71,8 +71,8 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                     'fast-diff',
                     'diff',
                     'deep-object-diff',
-                    'fast-deep-equal',
-                    'fast-deep-equal/es6',
+                    // Removed 'fast-deep-equal' and 'fast-deep-equal/es6' from this list
+                    // as they are allowed alternatives to microdiff
                 ].includes(importSource)) {
                     // Track imported function names and their sources
                     node.specifiers.forEach((specifier) => {
@@ -84,13 +84,7 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                             const localName = specifier.local.name;
                             importedFunctions.set(localName, importSource);
                         }
-                        else if (importSource === 'fast-deep-equal' ||
-                            importSource === 'fast-deep-equal/es6') {
-                            // Handle default imports for fast-deep-equal
-                            if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
-                                importedFunctions.set(specifier.local.name, importSource);
-                            }
-                        }
+                        // Removed the fast-deep-equal handling since it's now allowed
                     });
                     // Report all competing diffing libraries right away
                     context.report({
@@ -117,12 +111,22 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                         }
                         return false;
                     });
-                    if (hasDiffImport ||
-                        importSource === 'fast-deep-equal' ||
-                        importSource === 'fast-deep-equal/es6') {
+                    if (hasDiffImport) {
                         importedDiffLibraries.set(importSource, node);
                     }
                 }
+                // Special handling for fast-deep-equal: track it but don't report it
+                if (importSource === 'fast-deep-equal' ||
+                    importSource === 'fast-deep-equal/es6') {
+                    // Track imported function names for later reference
+                    node.specifiers.forEach((specifier) => {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                            importedFunctions.set(specifier.local.name, importSource);
+                        }
+                    });
+                    // Add to importedDiffLibraries for tracking but don't report
+                    importedDiffLibraries.set(importSource, node);
+                }
             },
             // Check for usage of other diffing libraries
             CallExpression(node) {
@@ -137,7 +141,13 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                     // Check if this is a function we specifically imported from a diff library
                     if (importedFunctions.has(name)) {
                         usedImportNames.add(name);
-                        // Always report it if it's from a tracked library
+                        // Get the source of the imported function
+                        const importSource = importedFunctions.get(name);
+                        // Skip reporting if it's from fast-deep-equal
+                        if (importSource === 'fast-deep-equal' || importSource === 'fast-deep-equal/es6') {
+                            return;
+                        }
+                        // Report it if it's from any other tracked library
                         reportedNodes.add(node);
                         context.report({
                             node,
@@ -154,8 +164,7 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                         'fastDiff',
                         'diffArrays',
                         'detailedDiff',
-                        'fastDeepEqual',
-                        'isEqual',
+                        // Removed 'fastDeepEqual' and 'isEqual' as they are allowed alternatives
                     ].includes(name);
                     if (isDiffFunction) {
                         // Track this import name as used

package/lib/rules/enforce-positive-naming.js

@@ -824,6 +824,26 @@ const DIS_EXCEPTIONS = [
     'disaster',
     'disasters',
     'disastrous',
+    // Added common technical terms containing 'dis' that are not negative
+    'display',
+    'displayed',
+    'displaying',
+    'displays',
+    'dispatch',
+    'dispatched',
+    'dispatches',
+    'dispatching',
+    'discover',
+    'discovered',
+    'discovering',
+    'discovers',
+    'discovery',
+    'dismiss',
+    'dismissed',
+    'dismissing',
+    'dismissal',
+    'disk',
+    'disks',
 ];
 // Words that contain negative prefixes but should be treated as valid
 const EXCEPTION_WORDS = [
@@ -920,6 +940,10 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
          * Check if a name has boolean negative naming
          */
         function hasBooleanNegativeNaming(name) {
+            // Safety check: if name is undefined or null, return not negative
+            if (!name) {
+                return { isNegative: false, alternatives: [] };
+            }
             // Check for exact matches in our alternatives map first
             if (BOOLEAN_POSITIVE_ALTERNATIVES[name]) {
                 return {
@@ -930,9 +954,12 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             // Split the name into words
             const words = splitNameIntoWords(name);
             // Check if this follows the pattern IS_NOT_SOMETHING or HAS_NO_SOMETHING
-            const secondWord = words[1].toLowerCase();
-            if (EXCEPTION_WORDS.some((exception) => secondWord === exception.toLowerCase())) {
-                return { isNegative: false, alternatives: [] };
+            // Make sure words[1] exists before trying to access it
+            if (words.length > 1) {
+                const secondWord = words[1].toLowerCase();
+                if (EXCEPTION_WORDS.some((exception) => secondWord === exception.toLowerCase())) {
+                    return { isNegative: false, alternatives: [] };
+                }
             }
             const nameLowercase = name.toLowerCase();
             // Check for negative prefixes in boolean-like variables
@@ -1193,6 +1220,7 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
          * Check TSPropertySignature for negative naming (in interfaces)
          */
         function checkPropertySignature(node) {
+            // Skip non-identifier keys (like computed properties)
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
             // Only check boolean properties
@@ -1200,7 +1228,10 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                 !(node.typeAnnotation?.typeAnnotation.type ===
                     utils_1.AST_NODE_TYPES.TSBooleanKeyword))
                 return;
+            // Ensure we have a valid property name
             const propertyName = node.key.name;
+            if (!propertyName)
+                return;
             const { isNegative, alternatives } = hasBooleanNegativeNaming(propertyName);
             if (isNegative) {
                 context.report({

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

@@ -210,8 +210,9 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             MethodDefinition(node) {
                 if (!node.value.returnType)
                     return;
-                if (mergedOptions.allowAbstractMethodSignatures &&
-                    isInterfaceOrAbstractMethodSignature(node)) {
+                if (isTypeGuardFunction(node.value) ||
+                    (mergedOptions.allowAbstractMethodSignatures &&
+                        isInterfaceOrAbstractMethodSignature(node))) {
                     return;
                 }
                 context.report({

package/lib/rules/no-hungarian.js

@@ -45,6 +45,12 @@ const ALLOWED_SUFFIXES = [
     'Display',
     'Displayed',
 ];
+// Common compound nouns that should not be flagged as Hungarian notation
+const ALLOWED_COMPOUND_NOUNS = [
+    'PhoneNumber',
+    'EmailAddress',
+    'PostalCode',
+];
 // Common built-in JavaScript prototype methods
 const BUILT_IN_METHODS = new Set([
     // String methods
@@ -208,6 +214,25 @@ exports.noHungarian = (0, createRule_1.createRule)({
         const checkedIdentifiers = new Set();
         // Check if a variable name contains a type marker with proper word boundaries
         function hasTypeMarker(variableName) {
+            // Check if the variable name is exactly one of the allowed compound nouns
+            // or if it contains one of the allowed compound nouns but is not a prefix like "strPhoneNumber"
+            for (const compoundNoun of ALLOWED_COMPOUND_NOUNS) {
+                // If the variable name is exactly the compound noun (case-insensitive)
+                if (variableName.toLowerCase() === compoundNoun.toLowerCase()) {
+                    return false;
+                }
+                // If the variable name contains the compound noun
+                if (variableName.includes(compoundNoun)) {
+                    // Check if it's a prefix like "strPhoneNumber" (which should be flagged)
+                    const prefix = variableName.substring(0, variableName.indexOf(compoundNoun));
+                    if (TYPE_MARKERS.some(marker => prefix.toLowerCase() === marker.toLowerCase())) {
+                        // This is a type marker prefix + compound noun, so it should be flagged
+                        return true;
+                    }
+                    // Otherwise, it's a valid use of the compound noun
+                    return false;
+                }
+            }
             // Check if the variable name ends with one of the allowed descriptive suffixes
             if (ALLOWED_SUFFIXES.some((suffix) => variableName.endsWith(suffix) &&
                 variableName.length > suffix.length &&
@@ -216,8 +241,12 @@ exports.noHungarian = (0, createRule_1.createRule)({
             }
             const normalizedVarName = variableName.toLowerCase();
             // Handle SCREAMING_SNAKE_CASE separately
-            if (variableName === variableName.toUpperCase() &&
-                variableName.includes('_')) {
+            if (variableName === variableName.toUpperCase()) {
+                // Special case for all-caps variables without underscores (like BREAKPOINTS)
+                // These should not be flagged as Hungarian notation
+                if (!variableName.includes('_')) {
+                    return false;
+                }
                 return TYPE_MARKERS.some((marker) => {
                     const markerUpper = marker.toUpperCase();
                     // Check if it's a prefix (PREFIX_REST)
@@ -232,6 +261,7 @@ exports.noHungarian = (0, createRule_1.createRule)({
                     }
                     // Check if it's in the middle (PART_MARKER_PART)
                     const parts = variableName.split('_');
+                    // Only consider exact matches for parts, not substrings
                     return parts.some((part) => part === markerUpper);
                 });
             }
@@ -254,6 +284,8 @@ exports.noHungarian = (0, createRule_1.createRule)({
                     /[A-Z0-9]/.test(variableName[variableName.length - normalizedMarker.length - 1])) {
                     return true;
                 }
+                // Check for word boundaries to avoid matching substrings
+                // For example, avoid matching "int" in "points" or "str" in "stream"
                 const markerIndex = normalizedVarName.indexOf(normalizedMarker);
                 if (markerIndex === -1) {
                     return false;
@@ -261,10 +293,15 @@ exports.noHungarian = (0, createRule_1.createRule)({
                 const markerPrefix = variableName.at(markerIndex);
                 const preMarkerPrefix = variableName.at(markerIndex - 1);
                 const suffix = variableName.at(markerIndex + normalizedMarker.length);
-                return ((!markerPrefix ||
-                    preMarkerPrefix === '_' ||
-                    /[A-Z]/.test(markerPrefix)) &&
-                    (!suffix || suffix === '_' || /[A-Z]/.test(suffix)));
+                // Ensure we have proper word boundaries
+                // A word boundary is defined by:
+                // 1. Start of string OR underscore OR capital letter before the marker
+                // 2. End of string OR underscore OR capital letter after the marker
+                const hasStartBoundary = markerIndex === 0 || preMarkerPrefix === '_' || /[A-Z]/.test(markerPrefix || '');
+                const hasEndBoundary = markerIndex + normalizedMarker.length === normalizedVarName.length ||
+                    suffix === '_' ||
+                    /[A-Z]/.test(suffix || '');
+                return hasStartBoundary && hasEndBoundary;
             });
         }
         // Check if the identifier is a built-in method or imported from an external module

package/lib/rules/no-type-assertion-returns.js

@@ -193,12 +193,23 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * Check if the current file is a .f.ts file
+         */
+        function isFunctionFile(context) {
+            const filename = context.getFilename();
+            return filename.endsWith('.f.ts');
+        }
         /**
          * Common function to check function return types
          */
         function checkFunctionReturnType(node) {
             if (!node.returnType)
                 return;
+            // Skip checking return types in .f.ts files
+            if (isFunctionFile(context)) {
+                return;
+            }
             // Allow type predicates if configured
             if (mergedOptions.allowTypePredicates &&
                 isTypePredicate(node.returnType)) {
@@ -283,6 +294,10 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                 if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
                     // Check for explicit return type
                     if (node.returnType) {
+                        // Skip checking return types in .f.ts files
+                        if (isFunctionFile(context)) {
+                            return;
+                        }
                         // Allow type predicates if configured
                         if (mergedOptions.allowTypePredicates &&
                             isTypePredicate(node.returnType)) {

package/lib/rules/no-undefined-null-passthrough.d.ts

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

package/lib/rules/no-undefined-null-passthrough.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUndefinedNullPassthrough = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.noUndefinedNullPassthrough = (0, createRule_1.createRule)({
+    create(context) {
+        return {
+            FunctionDeclaration(node) {
+                // Only apply to functions with exactly one parameter
+                if (node.params.length !== 1) {
+                    return;
+                }
+                // Skip React hooks (functions starting with 'use')
+                if (node.id &&
+                    node.id.type === 'Identifier' &&
+                    node.id.name.startsWith('use')) {
+                    return;
+                }
+                checkFunctionBody(node.body, node.params[0], context);
+            },
+            ArrowFunctionExpression(node) {
+                // Only apply to arrow functions with exactly one parameter
+                if (node.params.length !== 1) {
+                    return;
+                }
+                // Skip if the function is part of a variable declaration that starts with 'use' (React hook)
+                const parent = node.parent;
+                if (parent &&
+                    parent.type === 'VariableDeclarator' &&
+                    parent.id.type === 'Identifier' &&
+                    parent.id.name.startsWith('use')) {
+                    return;
+                }
+                // For arrow functions with block body
+                if (node.body.type === 'BlockStatement') {
+                    checkFunctionBody(node.body, node.params[0], context);
+                }
+                else {
+                    // For arrow functions with expression body (implicit return)
+                    checkImplicitReturn(node, context);
+                }
+            },
+            FunctionExpression(node) {
+                // Only apply to functions with exactly one parameter
+                if (node.params.length !== 1) {
+                    return;
+                }
+                // Skip if the function is part of a variable declaration that starts with 'use' (React hook)
+                const parent = node.parent;
+                if (parent &&
+                    parent.type === 'VariableDeclarator' &&
+                    parent.id.type === 'Identifier' &&
+                    parent.id.name.startsWith('use')) {
+                    return;
+                }
+                checkFunctionBody(node.body, node.params[0], context);
+            },
+        };
+    },
+    name: 'no-undefined-null-passthrough',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Avoid functions that return undefined or null when their single argument is undefined or null',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            unexpected: 'Avoid functions that return undefined or null when their single argument is undefined or null. Move the null/undefined check to the caller instead.',
+        },
+    },
+    defaultOptions: [],
+});
+/**
+ * Check function body for early returns when parameter is null/undefined
+ */
+function checkFunctionBody(body, param, context) {
+    // Get the parameter name
+    let paramName = null;
+    if (param.type === 'Identifier') {
+        paramName = param.name;
+    }
+    else if (param.type === 'AssignmentPattern' &&
+        param.left.type === 'Identifier') {
+        paramName = param.left.name;
+    }
+    if (!paramName)
+        return;
+    // Look for early returns based on parameter being null/undefined
+    for (const statement of body.body) {
+        if (statement.type === 'IfStatement') {
+            const test = statement.test;
+            // Check for patterns like: if (!param) return;
+            // or if (param === null) return;
+            // or if (param === undefined) return;
+            if (isNullUndefinedCheck(test, paramName)) {
+                // Check if the consequent is a block statement with a return
+                if (statement.consequent.type === 'BlockStatement') {
+                    for (const consequentStmt of statement.consequent.body) {
+                        if (consequentStmt.type === 'ReturnStatement' &&
+                            (!consequentStmt.argument ||
+                                isNullOrUndefinedLiteral(consequentStmt.argument))) {
+                            // Check if there's a transformation in the function
+                            const hasTransformation = checkForTransformation(body, paramName);
+                            if (!hasTransformation) {
+                                context.report({
+                                    node: statement,
+                                    messageId: 'unexpected',
+                                });
+                            }
+                            return;
+                        }
+                    }
+                }
+                // Check if the consequent is a direct return statement
+                else if (statement.consequent.type === 'ReturnStatement' &&
+                    (!statement.consequent.argument ||
+                        isNullOrUndefinedLiteral(statement.consequent.argument))) {
+                    // Check if there's a transformation in the function
+                    const hasTransformation = checkForTransformation(body, paramName);
+                    if (!hasTransformation) {
+                        context.report({
+                            node: statement,
+                            messageId: 'unexpected',
+                        });
+                    }
+                    return;
+                }
+            }
+        }
+    }
+}
+/**
+ * Check if the function body contains a transformation of the parameter
+ */
+function checkForTransformation(body, paramName) {
+    if (!paramName)
+        return false;
+    // Look for return statements that call functions with the parameter
+    for (const statement of body.body) {
+        if (statement.type === 'ReturnStatement' && statement.argument) {
+            // Check for return transformData(data) pattern
+            if (statement.argument.type === 'CallExpression' &&
+                statement.argument.arguments.some(arg => arg.type === 'Identifier' && arg.name === paramName)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check arrow functions with expression bodies (implicit returns)
+ */
+function checkImplicitReturn(node, context) {
+    // Get the parameter name
+    let paramName = null;
+    if (node.params[0].type === 'Identifier') {
+        paramName = node.params[0].name;
+    }
+    else if (node.params[0].type === 'AssignmentPattern' &&
+        node.params[0].left.type === 'Identifier') {
+        paramName = node.params[0].left.name;
+    }
+    if (!paramName)
+        return;
+    // Check for patterns like: (param) => param ? param.value : null
+    if (node.body.type === 'ConditionalExpression') {
+        const test = node.body.test;
+        if (isParameterReference(test, paramName) &&
+            isNullOrUndefinedLiteral(node.body.alternate)) {
+            context.report({
+                node,
+                messageId: 'unexpected',
+            });
+        }
+    }
+    else if (node.body.type === 'LogicalExpression') {
+        // Check for (param) => param && doSomething(param)
+        if (node.body.operator === '&&' &&
+            isParameterReference(node.body.left, paramName)) {
+            context.report({
+                node,
+                messageId: 'unexpected',
+            });
+        }
+    }
+    else if (node.body.type === 'Identifier' && node.body.name === paramName) {
+        // Check for (param) => param
+        context.report({
+            node,
+            messageId: 'unexpected',
+        });
+    }
+}
+/**
+ * Check if an expression is testing if a parameter is null or undefined
+ */
+function isNullUndefinedCheck(node, paramName) {
+    // Check for !param
+    if (node.type === 'UnaryExpression' &&
+        node.operator === '!' &&
+        node.argument.type === 'Identifier' &&
+        node.argument.name === paramName) {
+        return true;
+    }
+    // Check for param === null, param === undefined, etc.
+    if (node.type === 'BinaryExpression' &&
+        (node.operator === '===' || node.operator === '==' ||
+            node.operator === '!==' || node.operator === '!=')) {
+        const left = node.left;
+        const right = node.right;
+        // param === null/undefined
+        if (left.type === 'Identifier' &&
+            left.name === paramName &&
+            isNullOrUndefinedLiteral(right)) {
+            return true;
+        }
+        // null/undefined === param
+        if (right.type === 'Identifier' &&
+            right.name === paramName &&
+            left.type !== 'PrivateIdentifier' && // Ensure left is not a PrivateIdentifier
+            isNullOrUndefinedLiteral(left)) {
+            return true;
+        }
+    }
+    // Check for param === null || param === undefined
+    if (node.type === 'LogicalExpression' &&
+        node.operator === '||') {
+        return (isNullUndefinedCheck(node.left, paramName) ||
+            isNullUndefinedCheck(node.right, paramName));
+    }
+    return false;
+}
+/**
+ * Check if a node is a null or undefined literal
+ */
+function isNullOrUndefinedLiteral(node) {
+    if (node.type === 'Literal' && node.value === null) {
+        return true;
+    }
+    if (node.type === 'Identifier' && node.name === 'undefined') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if a node is a reference to the parameter
+ */
+function isParameterReference(node, paramName) {
+    if (!paramName)
+        return false;
+    return node.type === 'Identifier' && node.name === paramName;
+}
+//# sourceMappingURL=no-undefined-null-passthrough.js.map

package/lib/rules/no-unused-props.js

@@ -111,6 +111,14 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                         }
                         else if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
                             if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                // List of TypeScript utility types that transform other types
+                                const utilityTypes = ['Pick', 'Omit', 'Partial', 'Required', 'Record', 'Exclude', 'Extract', 'NonNullable', 'ReturnType', 'InstanceType', 'ThisType'];
+                                // Skip checking for utility type parameters (T, K, etc.) as they're not actual props
+                                if (typeNode.typeName.name.length === 1 && /^[A-Z]$/.test(typeNode.typeName.name)) {
+                                    // This is likely a generic type parameter (T, K, etc.), not a real type
+                                    // Skip it to avoid false positives
+                                    return;
+                                }
                                 if (typeNode.typeName.name === 'Pick' &&
                                     typeNode.typeParameters) {
                                     // Handle Pick utility type
@@ -149,6 +157,23 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                         }
                                     }
                                 }
+                                else if (
+                                // Handle other utility types like Required, Partial, etc.
+                                utilityTypes.includes(typeNode.typeName.name) &&
+                                    typeNode.typeParameters) {
+                                    // For utility types like Required<T, K>, we need to handle the base type
+                                    const baseType = typeNode.typeParameters.params[0];
+                                    if (baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                                        baseType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                        // Mark the base type as used via the utility type
+                                        const baseTypeName = baseType.typeName.name;
+                                        props[`...${baseTypeName}`] = baseType.typeName;
+                                        // For utility types, we need to track individual properties that might be used
+                                        if (!spreadTypeProps[baseTypeName]) {
+                                            spreadTypeProps[baseTypeName] = [];
+                                        }
+                                    }
+                                }
                                 else {
                                     // For referenced types like FormControlLabelProps, we need to track that these props should be forwarded
                                     const spreadTypeName = typeNode.typeName.name;
@@ -234,7 +259,12 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                                 // 2. It's a property from a spread type and any property from that spread type is used, OR
                                 // 3. It's a spread type and any of its properties are used in the component
                                 let shouldReport = true;
-                                if (prop.startsWith('...') && hasRestSpread) {
+                                // Skip reporting for generic type parameters (T, K, etc.)
+                                if (prop.startsWith('...') && prop.length === 4 && /^\.\.\.([A-Z])$/.test(prop)) {
+                                    // This is a generic type parameter like ...T, ...K, etc.
+                                    shouldReport = false;
+                                }
+                                else if (prop.startsWith('...') && hasRestSpread) {
                                     shouldReport = false;
                                 }
                                 else if (prop.startsWith('...')) {

package/lib/rules/prefer-block-comments-for-declarations.d.ts

@@ -0,0 +1,6 @@
+import { TSESLint } from '@typescript-eslint/utils';
+/**
+ * Rule to enforce the use of block comments (/** *\/) instead of single-line comments (//)
+ * for all declarations, including type declarations, variable declarations, and function declarations.
+ */
+export declare const preferBlockCommentsForDeclarations: TSESLint.RuleModule<'preferBlockComment', never[]>;

package/lib/rules/prefer-block-comments-for-declarations.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferBlockCommentsForDeclarations = void 0;
+const createRule_1 = require("../utils/createRule");
+/**
+ * Rule to enforce the use of block comments (/** *\/) instead of single-line comments (//)
+ * for all declarations, including type declarations, variable declarations, and function declarations.
+ */
+exports.preferBlockCommentsForDeclarations = (0, createRule_1.createRule)({
+    create(context) {
+        /**
+         * Check if a comment is a line comment that should be converted to a block comment
+         */
+        const isLineCommentBeforeDeclaration = (comment, node) => {
+            // Only process line comments
+            if (comment.type !== 'Line') {
+                return false;
+            }
+            // Check if the comment is directly before the node
+            const commentLine = comment.loc.end.line;
+            const nodeLine = node.loc.start.line;
+            return commentLine === nodeLine - 1;
+        };
+        /**
+         * Check if a node is inside a function body
+         */
+        const isInsideFunctionBody = (node) => {
+            let parent = node.parent;
+            while (parent) {
+                if (parent.type === 'BlockStatement' &&
+                    (parent.parent?.type === 'FunctionDeclaration' ||
+                        parent.parent?.type === 'FunctionExpression' ||
+                        parent.parent?.type === 'ArrowFunctionExpression' ||
+                        parent.parent?.type === 'MethodDefinition')) {
+                    return true;
+                }
+                parent = parent.parent;
+            }
+            return false;
+        };
+        /**
+         * Process a node that might have a declaration comment
+         */
+        const checkNodeForLineComments = (node) => {
+            // Skip nodes inside function bodies
+            if (isInsideFunctionBody(node)) {
+                return;
+            }
+            const sourceCode = context.getSourceCode();
+            const comments = sourceCode.getCommentsBefore(node);
+            // Find the closest comment to the node
+            const lastComment = comments[comments.length - 1];
+            if (lastComment && isLineCommentBeforeDeclaration(lastComment, node)) {
+                context.report({
+                    loc: lastComment.loc,
+                    messageId: 'preferBlockComment',
+                    fix: (fixer) => {
+                        const commentText = lastComment.value.trim();
+                        return fixer.replaceText(lastComment, `/** ${commentText} */`);
+                    },
+                });
+            }
+        };
+        return {
+            // Check function declarations
+            FunctionDeclaration(node) {
+                checkNodeForLineComments(node);
+            },
+            // Check variable declarations
+            VariableDeclaration(node) {
+                checkNodeForLineComments(node);
+            },
+            // Check type declarations
+            TSTypeAliasDeclaration(node) {
+                checkNodeForLineComments(node);
+            },
+            // Check interface declarations
+            TSInterfaceDeclaration(node) {
+                checkNodeForLineComments(node);
+            },
+            // Check class declarations
+            ClassDeclaration(node) {
+                checkNodeForLineComments(node);
+            },
+            // Check property declarations in interfaces and classes
+            TSPropertySignature(node) {
+                checkNodeForLineComments(node);
+            },
+            // Check class properties
+            PropertyDefinition(node) {
+                checkNodeForLineComments(node);
+            },
+            // Check method declarations
+            MethodDefinition(node) {
+                checkNodeForLineComments(node);
+            },
+            // Check enum declarations
+            TSEnumDeclaration(node) {
+                checkNodeForLineComments(node);
+            },
+        };
+    },
+    name: 'prefer-block-comments-for-declarations',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce the use of block comments for declarations',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferBlockComment: 'Use block comments (/** */) instead of line comments (//) for declarations to improve IDE support.',
+        },
+    },
+    defaultOptions: [],
+});
+//# sourceMappingURL=prefer-block-comments-for-declarations.js.map

package/lib/rules/prefer-settings-object.js

@@ -55,18 +55,36 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 // For destructured parameters, use the type annotation name
                 const typeNode = param.typeAnnotation.typeAnnotation;
                 if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
-                    return typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
+                    // Include type parameters in the type signature to differentiate generic types
+                    const typeName = typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
                         ? typeNode.typeName.name
                         : 'unknown';
+                    // If there are type parameters, include them in the type signature
+                    if (typeNode.typeParameters && typeNode.typeParameters.params.length > 0) {
+                        const typeParams = typeNode.typeParameters.params
+                            .map(param => param.type)
+                            .join('_');
+                        return `${typeName}<${typeParams}>`;
+                    }
+                    return typeName;
                 }
                 return typeNode.type;
             }
             if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
                 const typeNode = param.typeAnnotation.typeAnnotation;
                 if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
-                    return typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
+                    // Include type parameters in the type signature to differentiate generic types
+                    const typeName = typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
                         ? typeNode.typeName.name
                         : 'unknown';
+                    // If there are type parameters, include them in the type signature
+                    if (typeNode.typeParameters && typeNode.typeParameters.params.length > 0) {
+                        const typeParams = typeNode.typeParameters.params
+                            .map(param => param.type)
+                            .join('_');
+                        return `${typeName}<${typeParams}>`;
+                    }
+                    return typeName;
                 }
                 if (typeNode.type === utils_1.AST_NODE_TYPES.TSStringKeyword)
                     return 'string';
@@ -258,6 +276,24 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 if (hasABPattern(node.params))
                     return true;
             }
+            // Check if the function is a handler with transaction parameter
+            // This is a common pattern in Firebase/Firestore handlers
+            if ((node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) &&
+                node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                node.parent.id?.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const functionName = node.parent.id.name;
+                // Check if the function name or its type annotation suggests it's a handler with transaction
+                if (functionName.includes('Transaction') ||
+                    functionName.includes('WithTransaction') ||
+                    (node.parent.id.typeAnnotation?.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                        node.parent.id.typeAnnotation.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        (node.parent.id.typeAnnotation.typeAnnotation.typeName.name.includes('Transaction') ||
+                            node.parent.id.typeAnnotation.typeAnnotation.typeName.name.includes('WithTransaction')))) {
+                    return true;
+                }
+            }
             return false;
         }
         function checkFunction(node) {

package/lib/rules/prefer-usememo-over-useeffect-usestate.js

@@ -73,6 +73,31 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
             // Allow basic expressions and literals
             return true;
         };
+        // Helper to check if a node is a reference to a prop or variable
+        const isIdentifierReference = (node) => {
+            return node.type === 'Identifier';
+        };
+        // Helper to check if this is a state synchronization pattern
+        const isStateSynchronization = (initialValue, setterArgument) => {
+            // If the initial value is a reference to a prop/variable and the setter argument
+            // is the same reference, this is likely state synchronization
+            if (initialValue &&
+                isIdentifierReference(initialValue) &&
+                isIdentifierReference(setterArgument) &&
+                initialValue.name === setterArgument.name) {
+                return true;
+            }
+            // If the initial value is a function that references a prop and the setter argument
+            // is that same prop, this is likely state synchronization
+            if (initialValue &&
+                initialValue.type === 'ArrowFunctionExpression' &&
+                initialValue.body.type === 'Identifier' &&
+                isIdentifierReference(setterArgument) &&
+                initialValue.body.name === setterArgument.name) {
+                return true;
+            }
+            return false;
+        };
         return {
             // Track useState declarations
             VariableDeclarator(node) {
@@ -110,6 +135,10 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
                             const stateInfo = stateSetters.get(setterName);
                             if (stateInfo && statement.expression.arguments.length === 1) {
                                 const computation = statement.expression.arguments[0];
+                                // Skip if this is a state synchronization pattern
+                                if (isStateSynchronization(stateInfo.initialValue, computation)) {
+                                    return;
+                                }
                                 // Check if the computation is pure
                                 if (isPureComputation(computation)) {
                                     // Report the issue but without autofixing

package/package.json

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