@blumintinc/eslint-plugin-blumint 1.13.0 → 1.14.0

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

@@ -104,7 +104,7 @@ exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            preferDestructuring: 'Use destructuring instead of accessing the property directly.',
+            preferDestructuring: 'Property "{{property}}" from "{{object}}" is assigned via dot access{{targetNote}}. Destructure the property so the dependency is declared once and stays aligned with the source object. Use destructuring{{renamingHint}} (e.g., {{example}}).',
         },
     },
     defaultOptions,
@@ -114,6 +114,7 @@ exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
             enforceForRenamedProperties: defaultOptions[0].enforceForRenamedProperties,
             ...context.options[0],
         };
+        const sourceCode = context.getSourceCode();
         /**
          * Check if we're inside a class method
          */
@@ -128,32 +129,228 @@ exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
             }
             return false;
         }
+        function isIdentifierTarget(node) {
+            return node.type === utils_1.AST_NODE_TYPES.Identifier;
+        }
+        function isSkippedClassMemberAccess(memberExpression) {
+            return (isClassInstance(memberExpression, context) ||
+                isStaticClassMember(memberExpression, context));
+        }
+        function isThisMemberInClassMethod(memberExpression) {
+            return (memberExpression.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+                isInsideClassMethod(memberExpression));
+        }
+        function findEnclosingMethodDefinition(node) {
+            let current = node;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+                    return current;
+                }
+                current = current.parent ?? undefined;
+            }
+            return null;
+        }
+        function isInsideConstructorBody(node) {
+            let current = node;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    const enclosingMethod = findEnclosingMethodDefinition(current);
+                    return (!!enclosingMethod &&
+                        enclosingMethod.kind === 'constructor' &&
+                        enclosingMethod.value === current);
+                }
+                current = current.parent ?? undefined;
+            }
+            return false;
+        }
+        function isPrivateIdentifierProperty(property) {
+            return property.type === utils_1.AST_NODE_TYPES.PrivateIdentifier;
+        }
+        function canDestructureObjectProperty(memberExpression, identifier) {
+            if (isPrivateIdentifierProperty(memberExpression.property)) {
+                return false;
+            }
+            if (!options.object) {
+                return false;
+            }
+            if (options.enforceForRenamedProperties) {
+                return true;
+            }
+            return isMatchingPropertyName(memberExpression.property, identifier.name);
+        }
+        function getPatternKeyText(memberExpression, propertyText) {
+            if (memberExpression.computed) {
+                return `[${sourceCode.getText(memberExpression.property)}]`;
+            }
+            return propertyText;
+        }
+        function getDestructuringBindingText(memberExpression, propertyText, targetName) {
+            if (isPrivateIdentifierProperty(memberExpression.property)) {
+                return null;
+            }
+            const patternKeyText = getPatternKeyText(memberExpression, propertyText);
+            if (memberExpression.computed ||
+                (options.enforceForRenamedProperties &&
+                    !isMatchingPropertyName(memberExpression.property, targetName))) {
+                return `${patternKeyText}: ${targetName}`;
+            }
+            return patternKeyText;
+        }
         /**
          * Check if destructuring should be used for this node
          */
         function shouldUseDestructuring(node, leftNode) {
-            // Skip if this is a class instance or static class member
-            if (isClassInstance(node, context) ||
-                isStaticClassMember(node, context)) {
+            if (!isIdentifierTarget(leftNode)) {
                 return false;
             }
-            // Skip if the object is 'this' and we're inside a class method
-            if (node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
-                isInsideClassMethod(node)) {
-                return false;
+            return (!isSkippedClassMemberAccess(node) &&
+                !isThisMemberInClassMethod(node) &&
+                canDestructureObjectProperty(node, leftNode));
+        }
+        /**
+         * Extracts the property name from a MemberExpression when it can be safely compared.
+         */
+        function getMemberExpressionPropertyName(memberExpression) {
+            if (isPrivateIdentifierProperty(memberExpression.property)) {
+                return null;
             }
-            // Check object destructuring
-            if (options.object) {
-                if (options.enforceForRenamedProperties) {
-                    return true;
+            if (!memberExpression.computed) {
+                if (memberExpression.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return memberExpression.property.name;
                 }
-                // Only suggest destructuring when property name matches variable name
-                if (leftNode.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    return isMatchingPropertyName(node.property, leftNode.name);
+                return null;
+            }
+            if (memberExpression.property.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof memberExpression.property.value === 'string') {
+                return memberExpression.property.value;
+            }
+            return null;
+        }
+        /**
+         * Look up a variable by name within a scope.
+         */
+        function findVariableInScope(scope, name) {
+            return scope?.variables.find((variable) => variable.name === name);
+        }
+        /**
+         * Check whether a variable definition originates from a parameter.
+         */
+        function isParameterDefinition(variable) {
+            if (!variable || !Array.isArray(variable.defs)) {
+                return false;
+            }
+            return variable.defs.some((definition) => definition.type === 'Parameter');
+        }
+        /**
+         * Determine whether an identifier refers to a function or method parameter.
+         */
+        function isFunctionParameter(identifier) {
+            let scope = context.getScope();
+            while (scope) {
+                const variable = findVariableInScope(scope, identifier.name);
+                if (variable) {
+                    return isParameterDefinition(variable);
                 }
+                scope = scope.upper;
             }
             return false;
         }
+        function buildReportDetails(memberExpr, targetName, examplePrefix, exampleSuffix) {
+            const objectText = sourceCode.getText(memberExpr.object);
+            const propertyText = getPropertyText(memberExpr.property, memberExpr.computed, sourceCode);
+            const usesRenaming = options.enforceForRenamedProperties &&
+                !!targetName &&
+                !isMatchingPropertyName(memberExpr.property, targetName);
+            const aliasName = targetName ?? propertyText;
+            const patternKeyText = getPatternKeyText(memberExpr, propertyText);
+            const destructuringBinding = getDestructuringBindingText(memberExpr, propertyText, aliasName) ??
+                patternKeyText;
+            return {
+                propertyText,
+                objectText,
+                destructuringBinding,
+                data: {
+                    property: propertyText,
+                    object: objectText,
+                    targetNote: usesRenaming && targetName ? ` to "${targetName}"` : '',
+                    renamingHint: usesRenaming ? ' with renaming' : '',
+                    example: usesRenaming
+                        ? `${examplePrefix}{ ${destructuringBinding} } = ${objectText}${exampleSuffix}`
+                        : `${examplePrefix}{ ${destructuringBinding} } = ${objectText}${exampleSuffix}`,
+                },
+            };
+        }
+        function generateVariableDeclaratorFix(fixer, node, propertyText, objectText, memberExpr) {
+            const parentNode = node.parent;
+            if (!parentNode ||
+                parentNode.type !== utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                return null;
+            }
+            if (parentNode.declarations.length > 1) {
+                return null;
+            }
+            const kind = parentNode.kind;
+            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return null;
+            }
+            const destructuringBinding = getDestructuringBindingText(memberExpr, propertyText, node.id.name);
+            if (!destructuringBinding) {
+                return null;
+            }
+            return fixer.replaceText(parentNode, `${kind} { ${destructuringBinding} } = ${objectText};`);
+        }
+        function generateAssignmentExpressionFix(fixer, node, propertyText, objectText, memberExpr) {
+            if (node.left.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return null;
+            }
+            const destructuringBinding = getDestructuringBindingText(memberExpr, propertyText, node.left.name);
+            if (!destructuringBinding) {
+                return null;
+            }
+            return fixer.replaceText(node, `({ ${destructuringBinding} } = ${objectText})`);
+        }
+        /**
+         * Report assignments that copy properties from parameter objects to class fields.
+         * These are reported without a fixer to avoid changing function signatures.
+         */
+        function handleClassPropertyAssignment(node) {
+            // Caller ensures node.right is a MemberExpression.
+            if (!options.object ||
+                node.left.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                node.left.object.type !== utils_1.AST_NODE_TYPES.ThisExpression) {
+                return;
+            }
+            if (!isInsideConstructorBody(node)) {
+                return;
+            }
+            const rightObject = node.right.object;
+            if (rightObject.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                !isFunctionParameter(rightObject)) {
+                return;
+            }
+            const leftPropertyName = getMemberExpressionPropertyName(node.left);
+            const rightPropertyName = getMemberExpressionPropertyName(node.right);
+            if (!leftPropertyName || !rightPropertyName) {
+                return;
+            }
+            if (!options.enforceForRenamedProperties &&
+                leftPropertyName !== rightPropertyName) {
+                return;
+            }
+            if (isClassInstance(node.right, context) ||
+                isStaticClassMember(node.right, context)) {
+                return;
+            }
+            const { data } = buildReportDetails(node.right, leftPropertyName, '(', ')');
+            // No fixer here because destructuring parameters changes the function signature and must stay manual.
+            context.report({
+                node,
+                messageId: 'preferDestructuring',
+                data,
+            });
+        }
         return {
             VariableDeclarator(node) {
                 // Skip if variable is declared without assignment or if init is not a MemberExpression
@@ -161,57 +358,45 @@ exports.preferDestructuringNoClass = (0, createRule_1.createRule)({
                     return;
                 if (node.init.type !== utils_1.AST_NODE_TYPES.MemberExpression)
                     return;
-                if (shouldUseDestructuring(node.init, node.id)) {
-                    const sourceCode = context.getSourceCode();
-                    const objectText = sourceCode.getText(node.init.object);
-                    const propertyText = getPropertyText(node.init.property, node.init.computed, sourceCode);
+                const memberInit = node.init;
+                if (!shouldUseDestructuring(memberInit, node.id)) {
+                    return;
+                }
+                const targetName = node.id.type === utils_1.AST_NODE_TYPES.Identifier ? node.id.name : null;
+                const { propertyText, objectText, data } = buildReportDetails(memberInit, targetName, `${node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclaration
+                    ? node.parent.kind
+                    : 'const'} `, ';');
+                context.report({
+                    node,
+                    messageId: 'preferDestructuring',
+                    data,
+                    fix(fixer) {
+                        return generateVariableDeclaratorFix(fixer, node, propertyText, objectText, memberInit);
+                    },
+                });
+            },
+            AssignmentExpression(node) {
+                if (node.operator !== '=' ||
+                    node.right.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                    return;
+                }
+                const memberRight = node.right;
+                if (shouldUseDestructuring(memberRight, node.left)) {
+                    const targetName = node.left.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? node.left.name
+                        : null;
+                    const { propertyText, objectText, data } = buildReportDetails(memberRight, targetName, '(', ')');
                     context.report({
                         node,
                         messageId: 'preferDestructuring',
+                        data,
                         fix(fixer) {
-                            // Get the variable declaration kind (const, let, var)
-                            const parentNode = node.parent;
-                            if (!parentNode ||
-                                parentNode.type !== utils_1.AST_NODE_TYPES.VariableDeclaration) {
-                                return null;
-                            }
-                            const kind = parentNode.kind;
-                            // Handle renamed properties
-                            if (options.enforceForRenamedProperties &&
-                                node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                node.init &&
-                                node.init.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                                !isMatchingPropertyName(node.init.property, node.id.name)) {
-                                return fixer.replaceText(parentNode, `${kind} { ${propertyText}: ${node.id.name} } = ${objectText};`);
-                            }
-                            return fixer.replaceText(parentNode, `${kind} { ${propertyText} } = ${objectText};`);
+                            return generateAssignmentExpressionFix(fixer, node, propertyText, objectText, memberRight);
                         },
                     });
+                    return;
                 }
-            },
-            AssignmentExpression(node) {
-                if (node.operator === '=' &&
-                    node.right.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                    if (shouldUseDestructuring(node.right, node.left)) {
-                        const sourceCode = context.getSourceCode();
-                        const objectText = sourceCode.getText(node.right.object);
-                        const propertyText = getPropertyText(node.right.property, node.right.computed, sourceCode);
-                        context.report({
-                            node,
-                            messageId: 'preferDestructuring',
-                            fix(fixer) {
-                                // Handle renamed properties
-                                if (options.enforceForRenamedProperties &&
-                                    node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                    node.right.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                                    !isMatchingPropertyName(node.right.property, node.left.name)) {
-                                    return fixer.replaceText(node, `({ ${propertyText}: ${node.left.name} } = ${objectText})`);
-                                }
-                                return fixer.replaceText(node, `({ ${propertyText} } = ${objectText})`);
-                            },
-                        });
-                    }
-                }
+                handleClassPropertyAssignment(node);
             },
         };
     },

package/lib/rules/prefer-docsetter-setall.d.ts

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

package/lib/rules/prefer-docsetter-setall.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferDocSetterSetAll = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const ITERATING_METHODS = new Set(['map', 'forEach']);
+const DOC_SETTER_NAMES = new Set([
+    'DocSetter',
+    'DocSetterTransaction',
+]);
+function unwrapCallee(callee) {
+    return callee.type === utils_1.AST_NODE_TYPES.ChainExpression
+        ? callee.expression
+        : callee;
+}
+function getEntityIdentifier(entity) {
+    if (entity.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return entity.name;
+    }
+    return getEntityIdentifier(entity.right);
+}
+function getTypeName(typeNode) {
+    if (!typeNode || typeNode.type !== utils_1.AST_NODE_TYPES.TSTypeReference) {
+        return null;
+    }
+    return getEntityIdentifier(typeNode.typeName);
+}
+function isDocSetterName(name) {
+    return Boolean(name && DOC_SETTER_NAMES.has(name));
+}
+function getNewExpressionKind(expression) {
+    if (expression?.type !== utils_1.AST_NODE_TYPES.NewExpression) {
+        return null;
+    }
+    if (expression.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        isDocSetterName(expression.callee.name)) {
+        return expression.callee.name;
+    }
+    return null;
+}
+function getTypeAnnotationKind(identifier) {
+    const typeName = getTypeName(identifier.typeAnnotation?.typeAnnotation);
+    if (isDocSetterName(typeName)) {
+        return typeName;
+    }
+    return null;
+}
+function extractKindFromDefinition(definition) {
+    const nameNode = definition.name;
+    if (!nameNode || nameNode.type !== utils_1.AST_NODE_TYPES.Identifier)
+        return null;
+    const parent = nameNode.parent;
+    if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+        const ctorKind = getNewExpressionKind(parent.init);
+        if (ctorKind)
+            return ctorKind;
+    }
+    const annotationKind = getTypeAnnotationKind(nameNode);
+    if (annotationKind)
+        return annotationKind;
+    return null;
+}
+function resolveDocSetterFromScope(identifier, context) {
+    let scope = context.getScope();
+    while (scope) {
+        const variable = scope.set.get(identifier.name);
+        if (variable) {
+            for (const def of variable.defs) {
+                const kind = extractKindFromDefinition(def);
+                if (kind) {
+                    return { setterName: identifier.name, setterKind: kind };
+                }
+            }
+        }
+        scope = scope.upper;
+    }
+    return null;
+}
+function resolveDocSetterFromClassProperty(propertyName, startNode) {
+    let current = startNode;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.ClassBody) {
+            for (const element of current.body) {
+                if (element.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+                    element.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    element.key.name === propertyName) {
+                    const ctorKind = getNewExpressionKind(element.value);
+                    if (ctorKind)
+                        return ctorKind;
+                    const annotationKind = getTypeName(element.typeAnnotation?.typeAnnotation);
+                    if (isDocSetterName(annotationKind)) {
+                        return annotationKind;
+                    }
+                }
+            }
+            const classNode = current.parent;
+            if (classNode &&
+                (classNode.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+                    classNode.type === utils_1.AST_NODE_TYPES.ClassExpression)) {
+                const constructor = classNode.body.body.find((member) => member.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+                    member.kind === 'constructor');
+                if (constructor) {
+                    for (const param of constructor.value.params) {
+                        if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+                            const parameter = param.parameter;
+                            if (parameter.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                parameter.name === propertyName) {
+                                const annotationKind = getTypeAnnotationKind(parameter);
+                                if (annotationKind)
+                                    return annotationKind;
+                            }
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function isAncestor(ancestor, node) {
+    let current = node;
+    while (current) {
+        if (current === ancestor)
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+function findIterationContext(node) {
+    let current = node.parent;
+    while (current) {
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.ForStatement:
+            case utils_1.AST_NODE_TYPES.ForInStatement:
+            case utils_1.AST_NODE_TYPES.ForOfStatement:
+            case utils_1.AST_NODE_TYPES.WhileStatement:
+            case utils_1.AST_NODE_TYPES.DoWhileStatement:
+                return { kind: 'loop', loopType: current.type };
+            case utils_1.AST_NODE_TYPES.CallExpression: {
+                const callee = unwrapCallee(current.callee);
+                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    ITERATING_METHODS.has(callee.property.name)) {
+                    const callback = current.arguments[0];
+                    if (callback &&
+                        (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                            callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                        isAncestor(callback, node)) {
+                        return { kind: 'array-callback', methodName: callee.property.name };
+                    }
+                }
+                break;
+            }
+            case utils_1.AST_NODE_TYPES.Program:
+                return null;
+            default:
+                break;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function formatContext(iteration) {
+    if (iteration.kind === 'array-callback') {
+        return `${iteration.methodName} callback`;
+    }
+    switch (iteration.loopType) {
+        case utils_1.AST_NODE_TYPES.ForOfStatement:
+            return 'for...of loop';
+        case utils_1.AST_NODE_TYPES.ForInStatement:
+            return 'for...in loop';
+        case utils_1.AST_NODE_TYPES.ForStatement:
+            return 'for loop';
+        case utils_1.AST_NODE_TYPES.WhileStatement:
+            return 'while loop';
+        case utils_1.AST_NODE_TYPES.DoWhileStatement:
+            return 'do...while loop';
+        default:
+            return 'loop';
+    }
+}
+function resolveDocSetterInfo(callee, context) {
+    if (callee.property.type !== utils_1.AST_NODE_TYPES.Identifier)
+        return null;
+    const object = callee.object;
+    if (object.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return resolveDocSetterFromScope(object, context);
+    }
+    if (object.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        object.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+        object.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        const setterKind = resolveDocSetterFromClassProperty(object.property.name, callee);
+        if (setterKind) {
+            return { setterName: object.property.name, setterKind };
+        }
+    }
+    return null;
+}
+exports.preferDocSetterSetAll = (0, createRule_1.createRule)({
+    name: 'prefer-docsetter-setall',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce batching DocSetter and DocSetterTransaction writes by using setAll instead of set inside loops or array callbacks.',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            preferSetAll: '{{setterName}}.set() runs inside a {{context}}, which sends one Firestore write per iteration. Collect the document payloads and call setAll() once to batch writes, cut round-trips, and keep payload types narrow (build an updates array and mark entries as const when needed).',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                const callee = unwrapCallee(node.callee);
+                if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                    callee.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    callee.property.name !== 'set') {
+                    return;
+                }
+                const setterInfo = resolveDocSetterInfo(callee, context);
+                if (!setterInfo)
+                    return;
+                const iterationContext = findIterationContext(node);
+                if (!iterationContext)
+                    return;
+                const contextLabel = formatContext(iterationContext);
+                context.report({
+                    node: callee.property,
+                    messageId: 'preferSetAll',
+                    data: {
+                        setterName: setterInfo.setterName,
+                        context: contextLabel,
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-docsetter-setall.js.map

package/lib/rules/prefer-field-paths-in-transforms.js

@@ -74,8 +74,9 @@ function isBoundToName(fn, name) {
     if (parent.type === utils_1.AST_NODE_TYPES.Property ||
         parent.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
         parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
-        const key = parent.key;
-        if (parent.computed) {
+        const narrowedParent = parent;
+        const key = narrowedParent.key;
+        if (narrowedParent.computed) {
             return key.type === utils_1.AST_NODE_TYPES.Literal && key.value === name;
         }
         if (key.type === utils_1.AST_NODE_TYPES.Identifier)
@@ -84,7 +85,7 @@ function isBoundToName(fn, name) {
             return key.value === name;
     }
     if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
-        return parent.id.type === utils_1.AST_NODE_TYPES.Identifier && parent.id.name === name;
+        return (parent.id.type === utils_1.AST_NODE_TYPES.Identifier && parent.id.name === name);
     }
     if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression) {
         const left = parent.left;

package/lib/rules/prefer-fragment-component.js

@@ -20,7 +20,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         let hasFragmentImport = false;
         let reactImportNode = null;
         let defaultReactImportNode = null;

package/lib/rules/prefer-fragment-shorthand.js

@@ -14,6 +14,7 @@ exports.preferFragmentShorthand = {
                     context.report({
                         node,
                         messageId: 'preferShorthand',
+                        data: { fragmentName: 'React.Fragment' },
                         fix: (fixer) => [
                             fixer.replaceTextRange(openingElement.range, '<>'),
                             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -31,7 +32,7 @@ exports.preferFragmentShorthand = {
             recommended: 'error',
         },
         messages: {
-            preferShorthand: 'Use <> shorthand for <React.Fragment>, unless a key is required for an iterator',
+            preferShorthand: 'Fragment "{{fragmentName}}" is written with the long <React.Fragment> syntax. That form adds React namespace noise and is only necessary when you need a key or other attributes on the fragment. Prefer the <>...</> shorthand to keep JSX concise, and keep the long form only when fragment attributes are required.',
         },
         schema: [],
         fixable: 'code',

package/lib/rules/prefer-getter-over-parameterless-method.d.ts

@@ -0,0 +1,13 @@
+type OptionShape = {
+    stripPrefixes?: string[];
+    ignoredMethods?: string[];
+    ignoreAsync?: boolean;
+    ignoreVoidReturn?: boolean;
+    ignoreAbstract?: boolean;
+    respectJsDocSideEffects?: boolean;
+    minBodyLines?: number;
+};
+type Options = [OptionShape];
+type MessageIds = 'preferGetter' | 'preferGetterSideEffect';
+export declare const preferGetterOverParameterlessMethod: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default preferGetterOverParameterlessMethod;