@blumintinc/eslint-plugin-blumint 1.7.3 → 1.8.1

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/enforce-verb-noun-naming.js

@@ -4651,10 +4651,13 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                         }
                     }
                     return false;
-                })()
+                })(),
+                // 5. Component name ends with "Unmemoized" (common React pattern)
+                functionName && functionName.endsWith('Unmemoized')
             ];
             // Consider it a React component if it matches at least 2 indicators
-            return indicators.filter(Boolean).length >= 2;
+            // OR if it has the Unmemoized suffix (strong indicator of a React component)
+            return indicators.filter(Boolean).length >= 2 || (!!functionName && functionName.endsWith('Unmemoized'));
         }
         return {
             FunctionDeclaration(node) {

package/lib/rules/ensure-pointer-events-none.d.ts

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

package/lib/rules/ensure-pointer-events-none.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePointerEventsNone = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * Checks if a string contains a pseudo-element selector (::before or ::after)
+ */
+function hasPseudoElementSelector(selector) {
+    return /::?(before|after)\b/i.test(selector);
+}
+/**
+ * Checks if a property name is position with absolute or fixed value
+ */
+function isAbsoluteOrFixedPosition(propertyName, propertyValue) {
+    if (propertyName !== 'position')
+        return false;
+    return propertyValue === 'absolute' || propertyValue === 'fixed';
+}
+/**
+ * Checks if a property is pointer-events with a value
+ */
+function isPointerEventsProperty(propertyName) {
+    return propertyName === 'pointerEvents' || propertyName === 'pointer-events';
+}
+exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
+    name: 'ensure-pointer-events-none',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensure pointer-events: none is added to non-interactive pseudo-elements',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            missingPointerEventsNone: 'Pseudo-elements (::before, ::after) with position: absolute or fixed should have pointer-events: none to prevent blocking interactions with underlying elements',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track style objects that have position: absolute or fixed
+        const absolutePositionedStyles = new Map();
+        // Track style objects that already have pointer-events defined
+        const stylesWithPointerEvents = new Map();
+        /**
+         * Process a CSS-in-JS style object to check for position: absolute/fixed and pointer-events
+         */
+        function processStyleObject(node) {
+            let hasAbsolutePosition = false;
+            let pointerEventsValue;
+            // Check each property in the style object
+            for (const property of node.properties) {
+                if (property.type !== utils_1.AST_NODE_TYPES.Property)
+                    continue;
+                let propertyName = '';
+                let propertyValue;
+                // Get property name
+                if (property.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    propertyName = property.key.name;
+                }
+                else if (property.key.type === utils_1.AST_NODE_TYPES.Literal && typeof property.key.value === 'string') {
+                    propertyName = property.key.value;
+                }
+                // Get property value if it's a string literal
+                if (property.value.type === utils_1.AST_NODE_TYPES.Literal) {
+                    propertyValue = String(property.value.value);
+                }
+                else if (property.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    propertyValue = property.value.name;
+                }
+                // Check if this is position: absolute/fixed
+                if (isAbsoluteOrFixedPosition(propertyName, propertyValue)) {
+                    hasAbsolutePosition = true;
+                }
+                // Check if this is pointer-events property
+                if (isPointerEventsProperty(propertyName)) {
+                    if (property.value.type === utils_1.AST_NODE_TYPES.Literal) {
+                        pointerEventsValue = String(property.value.value);
+                    }
+                    else if (property.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        pointerEventsValue = property.value.name;
+                    }
+                }
+            }
+            // Store the results for this style object
+            absolutePositionedStyles.set(node, hasAbsolutePosition);
+            if (pointerEventsValue !== undefined) {
+                stylesWithPointerEvents.set(node, pointerEventsValue);
+            }
+        }
+        /**
+         * Check if a style object needs pointer-events: none
+         */
+        function checkStyleObject(node, selector) {
+            const isPseudoElement = selector && hasPseudoElementSelector(selector);
+            const isAbsolutePositioned = absolutePositionedStyles.get(node) || false;
+            const pointerEventsValue = stylesWithPointerEvents.get(node);
+            // If this is a pseudo-element with absolute positioning but no pointer-events
+            if (isPseudoElement && isAbsolutePositioned && pointerEventsValue === undefined) {
+                context.report({
+                    node,
+                    messageId: 'missingPointerEventsNone',
+                    fix(fixer) {
+                        // Find the last property in the object
+                        const sourceCode = context.getSourceCode();
+                        const properties = node.properties;
+                        if (properties.length === 0)
+                            return null;
+                        const lastProperty = properties[properties.length - 1];
+                        const lastPropertyToken = sourceCode.getLastToken(lastProperty);
+                        if (lastPropertyToken) {
+                            return fixer.insertTextAfter(lastPropertyToken, `, pointerEvents: 'none'`);
+                        }
+                        return null;
+                    }
+                });
+            }
+            // If this is a pseudo-element with absolute positioning and pointer-events: auto
+            if (isPseudoElement && isAbsolutePositioned && pointerEventsValue === 'auto') {
+                // Don't report an error if pointer-events is explicitly set to 'auto'
+                // This is an intentional choice by the developer
+            }
+        }
+        return {
+            // Check for pseudo-element selectors in styled-components and similar libraries
+            TaggedTemplateExpression(node) {
+                // Check if this is a styled-components template
+                const tag = node.tag;
+                let isStyledComponent = false;
+                if (tag.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    tag.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    tag.object.name === 'styled') {
+                    isStyledComponent = true;
+                }
+                else if (tag.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (tag.name === 'styled' || tag.name === 'css')) {
+                    isStyledComponent = true;
+                }
+                if (isStyledComponent) {
+                    // For styled-components, we need to check the template content
+                    const template = node.quasi.quasis.map(q => q.value.raw).join('');
+                    // Check if it contains a pseudo-element with position: absolute/fixed
+                    if (hasPseudoElementSelector(template) &&
+                        (template.includes('position: absolute') || template.includes('position: fixed'))) {
+                        // Check if it's missing pointer-events: none
+                        if (!template.includes('pointer-events: none') && !template.includes('pointer-events:none')) {
+                            context.report({
+                                node,
+                                messageId: 'missingPointerEventsNone'
+                            });
+                        }
+                    }
+                }
+            },
+            // Process style objects in JSX
+            JSXAttribute(node) {
+                if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier || node.name.name !== 'style')
+                    return;
+                if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+                    node.value.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    processStyleObject(node.value.expression);
+                    checkStyleObject(node.value.expression);
+                }
+            },
+            // Process style objects in regular JavaScript/TypeScript
+            ObjectExpression(node) {
+                // Skip if parent is not a variable declaration or assignment
+                const parent = node.parent;
+                if (!parent)
+                    return;
+                // Check if this might be a style object
+                let isStyleObject = false;
+                let selector;
+                if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    /style/i.test(parent.id.name)) {
+                    isStyleObject = true;
+                }
+                else if (parent.type === utils_1.AST_NODE_TYPES.Property &&
+                    parent.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    /style/i.test(parent.key.name)) {
+                    isStyleObject = true;
+                }
+                else if (parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    // Check for CSS-in-JS libraries like emotion's css() function
+                    const callee = parent.callee;
+                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier && callee.name === 'css') {
+                        isStyleObject = true;
+                    }
+                }
+                if (isStyleObject) {
+                    processStyleObject(node);
+                    checkStyleObject(node, selector);
+                }
+            },
+            // Process CSS-in-JS libraries that use objects with selectors
+            Property(node) {
+                // Check for patterns like { '&::before': { ... } }
+                if (node.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.key.value === 'string' &&
+                    hasPseudoElementSelector(node.key.value) &&
+                    node.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    processStyleObject(node.value);
+                    checkStyleObject(node.value, node.key.value);
+                }
+            }
+        };
+    },
+});
+//# sourceMappingURL=ensure-pointer-events-none.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/key-only-outermost-element.d.ts

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