@blumintinc/eslint-plugin-blumint 1.7.3 → 1.8.0

package/lib/rules/enforce-render-hits-memoization.js

@@ -21,63 +21,182 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const isReactComponent = (node) => {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            return /^[A-Z]/.test(node.name);
+        };
         const isMemoizedCall = (node) => {
             if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
                 return false;
-            const callee = node.callee;
-            if (callee.type !== utils_1.AST_NODE_TYPES.Identifier)
-                return false;
-            return callee.name === 'useCallback' || callee.name === 'useMemo';
-        };
-        const isReactComponent = (node) => {
-            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+            if (!node.callee || node.callee.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return false;
-            const name = node.name;
-            return /^[A-Z]/.test(name);
+            return (node.callee.name === 'useCallback' || node.callee.name === 'useMemo');
         };
         const isMemoizedVariable = (node) => {
             if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return false;
             // Get the variable declaration for this identifier
-            const variable = context.getScope().variables.find(v => v.name === node.name);
+            const variable = context
+                .getScope()
+                .variables.find((v) => v.name === node.name);
             if (!variable)
                 return false;
             // Check if the variable is initialized with a memoized call
-            const def = variable.defs[0];
-            if (!def || !def.node)
-                return false;
-            if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator && def.node.init) {
-                return isMemoizedCall(def.node.init);
+            for (const def of variable.defs) {
+                if (!def || !def.node)
+                    continue;
+                if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    def.node.init) {
+                    if (isMemoizedCall(def.node.init)) {
+                        return true;
+                    }
+                }
             }
             return false;
         };
         const isInsideMemoizedCall = (node) => {
+            // Handle the case when node is already a memoized call
+            if (isMemoizedCall(node))
+                return true;
             // Check if the node is a reference to a memoized variable
             if (isMemoizedVariable(node))
                 return true;
             // Check if the node is inside a memoization hook call
             let current = node;
             while (current?.parent) {
-                if (isMemoizedCall(current.parent))
-                    return true;
+                if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const callee = current.parent.callee;
+                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        (callee.name === 'useCallback' || callee.name === 'useMemo')) {
+                        return true;
+                    }
+                }
                 current = current.parent;
             }
+            // Check if the node is a reference to a memoized value
+            const scope = context.getScope();
+            // Make sure node is an Identifier before accessing name property
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            const variable = scope.variables.find((v) => v.name === node.name);
+            if (!variable) {
+                return false;
+            }
+            // Check if any definition is a memoized value
+            for (const def of variable.defs) {
+                const parent = def.node.parent;
+                if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.init?.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const callee = parent.init.callee;
+                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        (callee.name === 'useCallback' || callee.name === 'useMemo')) {
+                        return true;
+                    }
+                }
+            }
+            // Check if any reference is inside a memoized call
+            for (const ref of variable.references) {
+                let current = ref.identifier;
+                while (current?.parent) {
+                    if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                        const callee = current.parent.callee;
+                        if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            (callee.name === 'useCallback' || callee.name === 'useMemo')) {
+                            return true;
+                        }
+                    }
+                    current = current.parent;
+                }
+            }
+            // Check if the node is a property of an object that is memoized
+            const parent = node.parent;
+            if (parent?.type === utils_1.AST_NODE_TYPES.Property &&
+                parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                const objectExpression = parent.parent;
+                let current = objectExpression;
+                while (current?.parent) {
+                    if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                        const callee = current.parent.callee;
+                        if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            (callee.name === 'useCallback' || callee.name === 'useMemo')) {
+                            return true;
+                        }
+                    }
+                    current = current.parent;
+                }
+            }
             return false;
         };
+        let useRenderHitsName = 'useRenderHits';
+        let renderHitsName = 'renderHits';
         return {
+            ImportDeclaration(node) {
+                if (node.source.value.endsWith('useRenderHits')) {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.imported.name === 'useRenderHits') {
+                            useRenderHitsName = specifier.local.name;
+                            break;
+                        }
+                    }
+                }
+                else if (node.source.value.endsWith('renderHits')) {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.imported.name === 'renderHits') {
+                            renderHitsName = specifier.local.name;
+                            break;
+                        }
+                    }
+                }
+            },
             CallExpression(node) {
-                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier && node.callee.name === 'useRenderHits') {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === useRenderHitsName) {
                     if (node.arguments.length === 0)
                         return;
                     const options = node.arguments[0];
                     if (options.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
                         return;
+                    // Variable to track if we need to check properties (check both by default)
+                    const checkProps = {
+                        transformBefore: true,
+                        render: true,
+                    };
+                    // First pass: Check if transformBefore or render properties exist as shorthand
                     for (const prop of options.properties) {
                         if (prop.type !== utils_1.AST_NODE_TYPES.Property)
                             continue;
                         if (prop.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                             continue;
-                        if (prop.key.name === 'transformBefore') {
+                        // If it's shorthand property syntax like { transformBefore } and already a memoized variable
+                        if (prop.key.name === 'transformBefore' &&
+                            prop.shorthand &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            checkProps.transformBefore = !isMemoizedVariable(prop.key);
+                        }
+                        else if (prop.key.name === 'render' &&
+                            prop.shorthand &&
+                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            checkProps.render = !isMemoizedVariable(prop.key);
+                        }
+                    }
+                    // Second pass: Check non-shorthand properties
+                    for (const prop of options.properties) {
+                        if (prop.type !== utils_1.AST_NODE_TYPES.Property)
+                            continue;
+                        if (prop.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                            continue;
+                        // Skip shorthand properties that we already checked
+                        if (prop.shorthand)
+                            continue;
+                        if (prop.key.name === 'transformBefore' &&
+                            checkProps.transformBefore) {
+                            // Skip if the value is already a memoized call
+                            if (isMemoizedCall(prop.value))
+                                continue;
                             if (!isInsideMemoizedCall(prop.value)) {
                                 context.report({
                                     node: prop.value,
@@ -85,7 +204,7 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
                                 });
                             }
                         }
-                        if (prop.key.name === 'render') {
+                        else if (prop.key.name === 'render' && checkProps.render) {
                             if (isReactComponent(prop.value)) {
                                 context.report({
                                     node: prop.value,
@@ -101,13 +220,23 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
                         }
                     }
                 }
-                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier && node.callee.name === 'renderHits') {
-                    if (!isInsideMemoizedCall(node)) {
-                        context.report({
-                            node,
-                            messageId: 'requireMemoizedRenderHits',
-                        });
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === renderHitsName) {
+                    let current = node;
+                    while (current?.parent) {
+                        if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                            const callee = current.parent.callee;
+                            if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                (callee.name === 'useCallback' || callee.name === 'useMemo')) {
+                                return;
+                            }
+                        }
+                        current = current.parent;
                     }
+                    context.report({
+                        node,
+                        messageId: 'requireMemoizedRenderHits',
+                    });
                 }
             },
         };

package/lib/rules/enforce-timestamp-now.d.ts

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

package/lib/rules/enforce-timestamp-now.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceTimestampNow = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceTimestampNow = (0, createRule_1.createRule)({
+    name: 'enforce-timestamp-now',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce the use of Timestamp.now() for getting the current timestamp in backend code. This rule prevents using alternatives like Timestamp.fromDate(new Date()) or other date creation patterns that could lead to inconsistency.',
+            recommended: 'error',
+            requiresTypeChecking: false,
+            extendsBaseRule: false,
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferTimestampNow: 'Use Timestamp.now() instead of creating a Date object and converting it. This is more efficient and idiomatic for Firestore.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Only apply this rule to backend code (functions/src/)
+        const filename = context.getFilename();
+        if (!filename.includes('functions/src/')) {
+            return {};
+        }
+        // Skip test files
+        if (filename.includes('.test.') || filename.includes('.spec.')) {
+            return {};
+        }
+        // Track Timestamp imports and aliases
+        const timestampAliases = new Set(['Timestamp']);
+        function isTimestampFromDateWithNewDate(node) {
+            // Check if it's a Timestamp.fromDate(new Date()) call
+            if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                const property = node.callee.property;
+                const object = node.callee.object;
+                if (property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    property.name === 'fromDate' &&
+                    object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    timestampAliases.has(object.name)) {
+                    // Check if the argument is new Date()
+                    const arg = node.arguments[0];
+                    if (arg &&
+                        arg.type === utils_1.AST_NODE_TYPES.NewExpression &&
+                        arg.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        arg.callee.name === 'Date' &&
+                        arg.arguments.length === 0) {
+                        return true;
+                    }
+                    // Check if the argument is a variable reference to a Date object
+                    if (arg &&
+                        arg.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        // If it's a variable, we need to check if it's a Date that's being modified
+                        // If it's modified, we shouldn't flag it
+                        return false;
+                    }
+                }
+            }
+            return false;
+        }
+        function isTimestampFromMillisWithDateNow(node) {
+            // Check if it's a Timestamp.fromMillis(Date.now()) call
+            if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                const property = node.callee.property;
+                const object = node.callee.object;
+                if (property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    property.name === 'fromMillis' &&
+                    object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    timestampAliases.has(object.name)) {
+                    // Check if the argument is Date.now()
+                    const arg = node.arguments[0];
+                    if (arg &&
+                        arg.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        arg.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        arg.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        arg.callee.object.name === 'Date' &&
+                        arg.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        arg.callee.property.name === 'now') {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        function isNewDateDirectUsage(node) {
+            // Check if it's a new Date() with no arguments
+            return (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.name === 'Date' &&
+                node.arguments.length === 0);
+        }
+        // Check if a Date object is being modified (e.g., futureDate.setDate())
+        function isDateBeingModified(dateVar) {
+            // Look through the scope to find if this variable is modified
+            const scope = context.getScope();
+            const variable = scope.variables.find(v => v.name === dateVar);
+            if (!variable)
+                return false;
+            // Check if any references to this variable are followed by property access and modification
+            return variable.references.some(ref => {
+                const id = ref.identifier;
+                const parent = id.parent;
+                // Check for patterns like dateVar.setDate(), dateVar.setHours(), etc.
+                return (parent &&
+                    parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    parent.object === id &&
+                    parent.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (parent.property.name.startsWith('set') ||
+                        parent.property.name === 'toISOString' ||
+                        parent.property.name === 'toLocaleString' ||
+                        parent.property.name === 'toString'));
+            });
+        }
+        return {
+            ImportDeclaration(node) {
+                // Track Timestamp imports from Firebase
+                if (node.source.value === 'firebase-admin/firestore' ||
+                    node.source.value === 'firebase/firestore') {
+                    node.specifiers.forEach((specifier) => {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            specifier.imported.name === 'Timestamp') {
+                            timestampAliases.add(specifier.local.name);
+                        }
+                    });
+                }
+            },
+            VariableDeclarator(node) {
+                // Track dynamic imports of Timestamp
+                if (node.init?.type === utils_1.AST_NODE_TYPES.AwaitExpression &&
+                    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-admin/firestore' ||
+                            importSource.value === 'firebase/firestore')) {
+                        // Handle destructured imports
+                        if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                            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 === 'Timestamp') {
+                                    if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                        timestampAliases.add(prop.value.name);
+                                    }
+                                }
+                            });
+                        }
+                    }
+                }
+            },
+            CallExpression(node) {
+                if (isTimestampFromDateWithNewDate(node)) {
+                    context.report({
+                        node,
+                        messageId: 'preferTimestampNow',
+                        fix(fixer) {
+                            if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                                const timestampObj = context
+                                    .getSourceCode()
+                                    .getText(node.callee.object);
+                                return fixer.replaceText(node, `${timestampObj}.now()`);
+                            }
+                            return null;
+                        },
+                    });
+                }
+                else if (isTimestampFromMillisWithDateNow(node)) {
+                    context.report({
+                        node,
+                        messageId: 'preferTimestampNow',
+                        fix(fixer) {
+                            if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                                const timestampObj = context
+                                    .getSourceCode()
+                                    .getText(node.callee.object);
+                                return fixer.replaceText(node, `${timestampObj}.now()`);
+                            }
+                            return null;
+                        },
+                    });
+                }
+            },
+            NewExpression(node) {
+                // Only flag direct new Date() usage if it's assigned to a variable named timestamp or similar
+                if (isNewDateDirectUsage(node)) {
+                    const parent = node.parent;
+                    if (parent &&
+                        parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const varName = parent.id.name.toLowerCase();
+                        // Check if the variable name suggests it's a timestamp
+                        if (varName.includes('timestamp') ||
+                            varName.includes('time') ||
+                            varName.includes('now') ||
+                            varName.includes('date') ||
+                            varName.includes('created') ||
+                            varName.includes('updated')) {
+                            // Check if the Date object is being modified
+                            if (isDateBeingModified(parent.id.name)) {
+                                // If the Date is being modified, don't flag it
+                                return;
+                            }
+                            // Check if we have a Timestamp import before suggesting
+                            if (timestampAliases.size > 0) {
+                                const timestampName = Array.from(timestampAliases)[0];
+                                context.report({
+                                    node,
+                                    messageId: 'preferTimestampNow',
+                                    fix(fixer) {
+                                        return fixer.replaceText(node, `${timestampName}.now()`);
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-timestamp-now.js.map

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

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

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

@@ -90,6 +90,29 @@ function isMutableValue(node) {
     }
     return false;
 }
+function isNumericLiteral(node) {
+    if (!node)
+        return false;
+    return node.type === 'Literal' && typeof node.value === 'number';
+}
+function isZeroOrOne(node) {
+    if (!isNumericLiteral(node))
+        return false;
+    const value = node.value;
+    return value === 0 || value === 1;
+}
+function isAsConstExpression(node) {
+    if (!node)
+        return false;
+    if (node.type === 'TSAsExpression') {
+        if (node.typeAnnotation.type === 'TSTypeReference' &&
+            node.typeAnnotation.typeName.type === 'Identifier' &&
+            node.typeAnnotation.typeName.name === 'const') {
+            return true;
+        }
+    }
+    return false;
+}
 exports.extractGlobalConstants = (0, createRule_1.createRule)({
     create(context) {
         return {
@@ -104,8 +127,11 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                 const scope = context.getScope();
                 const hasDependencies = node.declarations.some((declaration) => declaration.init &&
                     ASTHelpers_1.ASTHelpers.declarationIncludesIdentifier(declaration.init));
+                // Skip constants with 'as const' type assertions used in loops
+                const hasAsConstAssertion = node.declarations.some((declaration) => declaration.init && isAsConstExpression(declaration.init));
                 // Only check function/block scoped constants without dependencies
                 if (!hasDependencies &&
+                    !hasAsConstAssertion &&
                     (scope.type === 'function' || scope.type === 'block') &&
                     isInsideFunction(node)) {
                     const constName = node.declarations[0].id
@@ -138,18 +164,100 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                     }
                 }
             },
+            ForStatement(node) {
+                // Check initialization
+                if (node.init && node.init.type === 'VariableDeclaration') {
+                    for (const decl of node.init.declarations) {
+                        if (decl.init && isNumericLiteral(decl.init) && !isZeroOrOne(decl.init) && !isAsConstExpression(decl.init)) {
+                            context.report({
+                                node: decl.init,
+                                messageId: 'requireAsConst',
+                                data: {
+                                    value: decl.init.value,
+                                },
+                            });
+                        }
+                    }
+                }
+                // Check test condition
+                if (node.test && node.test.type === 'BinaryExpression') {
+                    if (isNumericLiteral(node.test.right) && !isZeroOrOne(node.test.right) && !isAsConstExpression(node.test.right)) {
+                        context.report({
+                            node: node.test.right,
+                            messageId: 'requireAsConst',
+                            data: {
+                                value: node.test.right.value,
+                            },
+                        });
+                    }
+                }
+                // Check update expression
+                if (node.update) {
+                    if (node.update.type === 'AssignmentExpression') {
+                        if (node.update.right && isNumericLiteral(node.update.right) && !isZeroOrOne(node.update.right) && !isAsConstExpression(node.update.right)) {
+                            context.report({
+                                node: node.update.right,
+                                messageId: 'requireAsConst',
+                                data: {
+                                    value: node.update.right.value,
+                                },
+                            });
+                        }
+                    }
+                    else if (node.update.type === 'BinaryExpression') {
+                        if (isNumericLiteral(node.update.right) && !isZeroOrOne(node.update.right) && !isAsConstExpression(node.update.right)) {
+                            context.report({
+                                node: node.update.right,
+                                messageId: 'requireAsConst',
+                                data: {
+                                    value: node.update.right.value,
+                                },
+                            });
+                        }
+                    }
+                }
+            },
+            WhileStatement(node) {
+                // Check test condition
+                if (node.test.type === 'BinaryExpression') {
+                    if (isNumericLiteral(node.test.right) && !isZeroOrOne(node.test.right) && !isAsConstExpression(node.test.right)) {
+                        context.report({
+                            node: node.test.right,
+                            messageId: 'requireAsConst',
+                            data: {
+                                value: node.test.right.value,
+                            },
+                        });
+                    }
+                }
+            },
+            DoWhileStatement(node) {
+                // Check test condition
+                if (node.test.type === 'BinaryExpression') {
+                    if (isNumericLiteral(node.test.right) && !isZeroOrOne(node.test.right) && !isAsConstExpression(node.test.right)) {
+                        context.report({
+                            node: node.test.right,
+                            messageId: 'requireAsConst',
+                            data: {
+                                value: node.test.right.value,
+                            },
+                        });
+                    }
+                }
+            },
         };
     },
     name: 'extract-global-constants',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Extract static constants and functions to the global scope when possible',
+            description: 'Extract static constants and functions to the global scope when possible, and enforce type narrowing with as const for numeric literals in loops',
             recommended: 'error',
         },
         schema: [],
         messages: {
             extractGlobalConstants: 'Move this declaration {{ declarationName }} to the global scope and rename it to UPPER_SNAKE_CASE if necessary.',
+            requireAsConst: 'Numeric literal {{ value }} in loop expression should be extracted to a constant with "as const" type assertion.',
         },
     },
     defaultOptions: [],

package/lib/rules/global-const-style.js

@@ -29,8 +29,9 @@ exports.default = (0, createRule_1.createRule)({
                 if (node.kind !== 'const') {
                     return;
                 }
-                // Skip if not at program level
-                if (node.parent?.type !== utils_1.AST_NODE_TYPES.Program) {
+                // Skip if not at program level or not an exported declaration
+                if (node.parent?.type !== utils_1.AST_NODE_TYPES.Program &&
+                    node.parent?.type !== utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
                     return;
                 }
                 // Skip if any declaration is a function component, arrow function, forwardRef, or memo

package/lib/rules/no-always-true-false-conditions.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'alwaysTrueCondition' | 'alwaysFalseCondition';
+export declare const noAlwaysTrueFalseConditions: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};