@blumintinc/eslint-plugin-blumint 1.20.181 → 1.20.182

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.181',
+        version: '1.20.182',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-assert-throws.js

@@ -48,6 +48,30 @@ function resolveMemberName(key) {
 function memberDisplayName(member) {
     return member.isEcmaPrivate ? `#${member.name}` : member.name;
 }
+/**
+ * The member name a class field contributes, when the function under inspection is
+ * that field's own initializer. A field-declared helper is the same class member as
+ * its prototype-method spelling, so the assert- contract has to read the same name
+ * from both: deriving nothing here would let `assertFoo() {}` be rewritten to
+ * `assertFoo = () => {}` and escape the check without changing anything the check
+ * judges. The `value` identity test keeps a function nested somewhere inside a
+ * field's initializer — a callback, a wrapped factory — from borrowing the field's
+ * name.
+ *
+ * A computed key evaluates an expression at class-definition time instead of
+ * spelling a member name (`[assertKey] = ...` names a variable, not the member), so
+ * it contributes no name to a naming convention. A `declare` field states a type
+ * with no implementation, so it has no control flow that could throw.
+ */
+function propertyDefinitionMemberName(parent, node) {
+    if (parent.type !== utils_1.AST_NODE_TYPES.PropertyDefinition) {
+        return null;
+    }
+    if (parent.value !== node || parent.computed || parent.declare) {
+        return null;
+    }
+    return resolveMemberName(parent.key);
+}
 /**
  * Whether a member expression's property names an assert helper. The `#` sigil is a
  * privacy marker rather than part of the identifier the naming convention governs,
@@ -607,6 +631,9 @@ exports.enforceAssertThrows = (0, createRule_1.createRule)({
                     parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
                     member = { name: parent.id.name, isEcmaPrivate: false };
                 }
+                else if (parent) {
+                    member = propertyDefinitionMemberName(parent, node);
+                }
             }
             // The bare name drives the assert- convention; the report quotes the name as
             // written so a `#assertFoo` finding is not read as its public namesake.

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

@@ -1505,6 +1505,29 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 });
             }
         }
+        /**
+         * Whether a class field's value is a function whose DECLARED return type is
+         * `boolean`.
+         *
+         * Booleanness is read from the return annotation alone, which is exactly
+         * what the method arm requires. Routing the value through
+         * `returnsBooleanValue` instead would additionally accept an un-annotated
+         * arrow whose expression body merely looks boolean (`valid = () => x > 0`),
+         * whose method counterpart (`valid() { return x > 0; }`) stays silent — so
+         * the two spellings would disagree in the opposite direction. A type
+         * predicate (`(v): v is Foo => …`) is excluded by the same keying, matching
+         * the method arm's explicit predicate carve-out.
+         */
+        function declaresBooleanReturningFunction(node) {
+            const value = node.value;
+            if (value?.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                value?.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+                return false;
+            }
+            const returnAnnotation = value.returnType?.typeAnnotation;
+            return (!!returnAnnotation &&
+                returnAnnotation.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword);
+        }
         /**
          * Check class property declarations for boolean values.
          *
@@ -1518,6 +1541,38 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             if (!key)
                 return;
             const propertyName = key.name;
+            // A field holding a boolean-returning function declares a member that is a
+            // method in every respect its NAME is judged on: callers write
+            // `instance.member()` and read a true/false answer from it, so writing `=`
+            // in front of the member cannot discharge the naming obligation the method
+            // spelling carries. The three real differences between the spellings —
+            // lexical `this`, own-instance placement and initialization order — are all
+            // orthogonal to the name, so the rename remedy is identical.
+            //
+            // Reported before the data-field paths and returned from, so a field that
+            // somehow satisfies both cannot draw two reports on one key.
+            //
+            // Two fields declare a name this site cannot rename: a computed key's
+            // static name belongs to the expression holding it, so renaming `k` in
+            // `[k] = …` renames nothing on the class, and an ambient (`declare`) field
+            // describes a shape provided elsewhere — a base class, a mixin, a
+            // framework — which owns the name.
+            const declaresRenameableName = !node.computed && !node.declare;
+            if (declaresRenameableName &&
+                declaresBooleanReturningFunction(node) &&
+                !hasApprovedPrefix(propertyName)) {
+                context.report({
+                    node: node.key,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'method',
+                        name: key.written,
+                        capitalizedName: capitalizeFirst(propertyName),
+                        prefixes: formatPrefixes(),
+                    },
+                });
+                return;
+            }
             // Check if it's a boolean property
             let isBooleanProperty = false;
             // Check if it has a boolean type annotation

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

@@ -1122,6 +1122,11 @@ function classifyFunctionReturn(fn) {
             ? 'boolean'
             : 'nonBoolean';
     }
+    // A body-less function (`abstract isNotBlank(value?: string);`) with no
+    // return annotation offers no syntactic verdict at all.
+    if (!fn.body) {
+        return 'indeterminate';
+    }
     if (fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
         return classifyExpression(fn.body);
     }
@@ -1148,9 +1153,25 @@ function isExemptFromBooleanNaming(fn) {
 function isExemptFunctionValue(node) {
     return (!!node &&
         (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-            node.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+            node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+            // `abstract isNotBlank(value?: string): string | true;` declares the
+            // validator without a body, and must be exempt on the same grounds as
+            // the implementation that satisfies it.
+            node.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) &&
         isExemptFromBooleanNaming(node));
 }
+/**
+ * A member declared with a function type but no initializer
+ * (`isNotBlank!: (value?: string) => string | true`) carries its return shape
+ * only in the annotation. Reading it keeps the #1692 validator carve-out from
+ * depending on whether the predicate is declared or implemented in place.
+ */
+function isExemptFunctionTypeAnnotation(annotation) {
+    const typeNode = annotation?.typeAnnotation;
+    return (typeNode?.type === utils_1.AST_NODE_TYPES.TSFunctionType &&
+        !!typeNode.returnType &&
+        !isBooleanOnlyType(typeNode.returnType.typeAnnotation));
+}
 exports.enforcePositiveNaming = (0, createRule_1.createRule)({
     name: 'enforce-positive-naming',
     meta: {
@@ -1446,25 +1467,45 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             }
         }
         /**
-         * Check method definitions for negative naming
+         * Check class members — methods, fields and their `abstract` forms — for
+         * negative naming. The docs' subject is "class members", and a field is one:
+         * `isNotReady = () => ...` and `isNotReady() { ... }` force a reader through
+         * the same mental inversion, so writing `=` must not silence the rule.
          */
-        function checkMethodDefinition(node) {
+        function checkClassMember(node) {
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
-            // Only check boolean-returning methods
+            // A computed key references a name bound elsewhere, where the rule
+            // already judges it; reporting here would blame the wrong declaration.
+            if (node.computed)
+                return;
+            // A `declare` field restates the type of a member owned by a base class
+            // or an ambient declaration, so its name is not this class's to choose.
+            if ((node.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+                node.type === utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition) &&
+                node.declare) {
+                return;
+            }
+            // Only check boolean-returning members
             if (!isBooleanLike(node.key))
                 return;
-            // Skip validator predicates returning a non-boolean value.
+            // Skip validator predicates returning a non-boolean value, whether the
+            // shape comes from the value or from a declaration-only annotation.
             if (isExemptFunctionValue(node.value))
                 return;
-            const methodName = node.key.name;
-            const { isNegative, alternatives } = hasBooleanNegativeNaming(methodName);
+            if ((node.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+                node.type === utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition) &&
+                isExemptFunctionTypeAnnotation(node.typeAnnotation)) {
+                return;
+            }
+            const memberName = node.key.name;
+            const { isNegative, alternatives } = hasBooleanNegativeNaming(memberName);
             if (isNegative) {
                 context.report({
                     node: node.key,
                     messageId: 'avoidNegativeNaming',
                     data: {
-                        name: methodName,
+                        name: memberName,
                         alternatives: formatAlternatives(alternatives),
                     },
                 });
@@ -1562,7 +1603,13 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                     checkFunctionDeclaration(node);
                 }
             },
-            MethodDefinition: checkMethodDefinition,
+            MethodDefinition: checkClassMember,
+            // A class field is a class member: the property spelling of a method
+            // (`isNotReady = () => ...`) and a plain boolean field
+            // (`isNotReady = false`) are both what the docs promise to cover.
+            PropertyDefinition: checkClassMember,
+            TSAbstractMethodDefinition: checkClassMember,
+            TSAbstractPropertyDefinition: checkClassMember,
             Property: checkProperty,
             TSPropertySignature: checkPropertySignature,
             Identifier(node) {

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

@@ -4081,6 +4081,14 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                     parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
                     return parent.id.name;
                 }
+                // A class field holds its name on the member key, so the component
+                // evidence keyed on the name has to reach `Foo = () => <div />` the
+                // same way it reaches `const Foo = () => <div />`.
+                if (parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+                    !parent.computed &&
+                    parent.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return parent.key.name;
+                }
             }
             return '';
         }
@@ -4100,6 +4108,18 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                     }
                 }
             }
+            // A class field carries its annotation on the member rather than on a
+            // binding: `Foo: React.FC = () => ...` declares a component exactly as
+            // the `const` spelling above does.
+            const memberParent = node.parent;
+            if (memberParent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+                memberParent.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+                const typeText = context.sourceCode.getText(memberParent.typeAnnotation.typeAnnotation);
+                if (/\bReact\.(FC|FunctionComponent)\b/.test(typeText) ||
+                    /\b(FC|FunctionComponent)\b/.test(typeText)) {
+                    return true;
+                }
+            }
             // Handle FunctionDeclaration/FunctionExpression/ArrowFunction return type: function Foo(): React.JSX.Element { ... }
             if (node.returnType?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
                 const typeText = context.sourceCode.getText(node.returnType.typeAnnotation);
@@ -4114,6 +4134,14 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
          * scope analysis, which records JSX element names as references.
          */
         function isUsedAsReactComponent(node, functionName) {
+            // A class field's name is a member, not a lexical binding, so a variable
+            // of the same name found in scope belongs to some other symbol entirely
+            // and says nothing about the field. `<this.Foo />` is a member expression
+            // and records no reference to resolve, so the field relies on the other
+            // component evidence.
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
+                return false;
+            }
             const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
             const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, functionName);
             if (!variable) {
@@ -4205,6 +4233,45 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                     }
                 }
             },
+            /**
+             * A callable class field is the same member as a method with one token
+             * changed — `this.data()` reads identically under either spelling — so
+             * the name answers to the same rule. Writing `=` cannot be a way to opt
+             * out of it. The value gate is what separates the two kinds of field:
+             * only a function-valued one names an action, so `data = 42` stays a
+             * noun-phrased datum, exactly as an assigned variable does.
+             */
+            PropertyDefinition(node) {
+                // A computed key is an expression rather than a name, so there is no
+                // identifier to judge or to rename.
+                if (node.computed)
+                    return;
+                if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                // A `declare` field only restates the type of a member initialized
+                // elsewhere; the declaration that carries the value owns the name.
+                if (node.declare)
+                    return;
+                const value = node.value;
+                if (!value ||
+                    (value.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                        value.type !== utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    return;
+                }
+                // A component is a noun by convention, and a field is a routine place
+                // to hold one — the generic-bound render helpers a class exposes are
+                // written this way precisely because they close over `this`.
+                if (isReactComponent(value)) {
+                    return;
+                }
+                if (!isVerbPhrase(node.key.name)) {
+                    context.report({
+                        node: node.key,
+                        messageId: 'functionVerbPhrase',
+                        data: { name: node.key.name },
+                    });
+                }
+            },
             MethodDefinition(node) {
                 if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                     return;

package/lib/rules/no-misleading-boolean-prefixes.js

@@ -302,6 +302,29 @@ exports.noMisleadingBooleanPrefixes = (0, createRule_1.createRule)({
             }
             // If we can't determine it's non-boolean, do not report to avoid false positives
         }
+        /**
+         * Judges a class field only when it holds a function literal.
+         *
+         * Each gate excludes a member that makes no return-value promise, so none of
+         * them is conservatism for its own sake: a data field (`isDone = false`,
+         * `hasItems = compute()`) is a value rather than a callable contract, a
+         * computed key names a variable instead of the member a caller writes, and a
+         * `declare`, definite-assignment or abstract field carries no initializer
+         * whose returns could be read.
+         */
+        function checkClassProperty(node) {
+            if (node.computed || node.declare)
+                return;
+            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const value = node.value;
+            if (!value ||
+                (value.type !== utils_1.AST_NODE_TYPES.FunctionExpression &&
+                    value.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
+                return;
+            }
+            checkFunctionLike(value, node.key.name, node.key);
+        }
         return {
             FunctionDeclaration(node) {
                 if (!node.id)
@@ -320,6 +343,12 @@ exports.noMisleadingBooleanPrefixes = (0, createRule_1.createRule)({
                     return;
                 if (node.parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition)
                     return;
+                // A named function expression assigned to a class field carries two
+                // names — its own `id` and the field's key — and the field key is the
+                // one every call site writes. Without this bail-out the class-member
+                // arm below and the `node.id` fallback both fire on the same site.
+                if (node.parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition)
+                    return;
                 if (node.id) {
                     checkFunctionLike(node, node.id.name, node.id);
                 }
@@ -351,6 +380,20 @@ exports.noMisleadingBooleanPrefixes = (0, createRule_1.createRule)({
                     checkFunctionLike(node.value, node.key.name, node.key);
                 }
             },
+            // A class field holding a function is a function everywhere it matters:
+            // `instance.isReady()` reads the same whether the member was written as a
+            // method or as `isReady = () => ...`, so the boolean prefix makes the same
+            // promise to the same call sites. Keying the class arm on `MethodDefinition`
+            // alone let a single `=` silence the rule (#2155), and the bound-property
+            // spelling is what an interface demanding a bound member forces.
+            //
+            // `TSAbstractPropertyDefinition` is registered beside it so the class arm
+            // subscribes to every key a field declaration can parse as, matching the
+            // inverse boolean-naming rule in the same recommended config. An abstract
+            // field parses with no initializer, so the value gate leaves that arm
+            // silent — the key is here to keep the two spellings from drifting apart.
+            PropertyDefinition: checkClassProperty,
+            TSAbstractPropertyDefinition: checkClassProperty,
         };
     },
 });

package/lib/rules/no-unnecessary-verb-suffix.js

@@ -815,6 +815,43 @@ exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
                     checkFunctionName(node.value, node.key.name, null, null, false);
                 }
             },
+            PropertyDefinition(node) {
+                // A class field holding a function declares the same callable member a
+                // method does — `member = () => {}` and `member() {}` differ by one
+                // token and by nothing this rule judges, since it reads only the
+                // member's name. Without this arm the `=` spelling silences the rule
+                // (#2156), and it is the spelling a class picks whenever a member must
+                // stay bound to its instance.
+                if (node.computed ||
+                    // An ambient member declares a type rather than code; its initializer
+                    // is not valid TypeScript at all (TS1039), so nothing in it is an
+                    // implementation whose name this rule can hold the author to.
+                    node.declare ||
+                    node.key.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                // The value gate is what keeps data fields inert: `cachedFor = new
+                // Map()` names a value, not a function, and only a function member is
+                // this rule's subject. A field annotated with a function type but
+                // holding something else is inert for the same reason.
+                const { value } = node;
+                if (!value ||
+                    (value.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                        value.type !== utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    return;
+                }
+                // A member implementing a contract the class declares conformance to
+                // is named by that contract, so renaming it would break conformance.
+                if (isDictatedByHeritage(node, node.key.name)) {
+                    return;
+                }
+                // Report-only for the reason the method arm gives: a field arrow is
+                // invoked through `this.x()` / `instance.x()`, member accesses the
+                // scope manager does not track as references, so a single-file fixer
+                // cannot rename the call sites and must not rename the declaration
+                // alone (#1256).
+                checkFunctionName(value, node.key.name, null, null, false);
+            },
             TSMethodSignature(node) {
                 // Interface method signatures have their implementations and call sites
                 // elsewhere (member accesses on implementers), unreachable from this

package/lib/rules/prefer-getter-over-parameterless-method.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferGetterOverParameterlessMethod = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+function isPropertyLike(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+        node.type === utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition);
+}
 const DEFAULT_PREFIXES = [
     'build',
     'get',
@@ -143,6 +147,50 @@ function isFunctionLikeNode(value) {
         value.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
         value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression);
 }
+/**
+ * The member function a class member carries, or null when it carries none. A
+ * method's value is always a function; a field's value is one only when it is
+ * written as an arrow or a function expression, which is what makes the field a
+ * member function rather than data.
+ */
+function memberFunctionOf(node) {
+    if (!isPropertyLike(node))
+        return node.value;
+    const value = node.value;
+    if (value &&
+        (value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            value.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+        return value;
+    }
+    return null;
+}
+/**
+ * The return type a FIELD's own annotation declares for the function it holds.
+ * `render: () => void = () => this.draw()` states the member's contract beside
+ * the field name rather than on the arrow, and that contract is what a caller
+ * reads — so it answers the void and promise questions the same way an arrow's
+ * own `(): void` annotation does.
+ */
+function declaredFunctionReturnType(node) {
+    if (!isPropertyLike(node))
+        return null;
+    const annotation = node.typeAnnotation?.typeAnnotation;
+    if (!annotation || annotation.type !== utils_1.AST_NODE_TYPES.TSFunctionType) {
+        return null;
+    }
+    return annotation.returnType?.typeAnnotation ?? null;
+}
+/**
+ * The nodes a top-level body walk starts from. A concise arrow body is a single
+ * expression rather than a statement list, and every walk here is about what
+ * the member's OWN scope does, so the expression is that scope's whole content.
+ */
+function bodyWalkRoots(fn) {
+    const body = fn.body;
+    if (!body)
+        return [];
+    return body.type === utils_1.AST_NODE_TYPES.BlockStatement ? [...body.body] : [body];
+}
 function lowerFirst(text) {
     if (!text)
         return text;
@@ -167,7 +215,15 @@ function memberNameOf(key, computed) {
 function isEcmaPrivateName(name) {
     return name.startsWith('#');
 }
-function computeBodyLineCount(body) {
+function computeBodyLineCount(fn) {
+    const body = fn.body;
+    if (!body)
+        return 0;
+    if (body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        // A concise body has no braces of its own, so its span IS its content: a
+        // one-line body counts 0, exactly as the one-line block spelling does.
+        return Math.max(0, body.loc.end.line - body.loc.start.line);
+    }
     return Math.max(0, body.loc.end.line - body.loc.start.line - 1);
 }
 function hasNameCollision(node, newName) {
@@ -624,8 +680,8 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
             return (matchesAffirmative(/\bside effects?\b/) ||
                 matchesAffirmative(/\bmutat(?:e|es|ing|ion|ions|ed|ive|ively)?\b/));
         }
-        function analyzeMutations(body) {
-            const stack = [...body.body];
+        function analyzeMutations(fn) {
+            const stack = bodyWalkRoots(fn);
             while (stack.length) {
                 const current = stack.pop();
                 if (isFunctionLikeNode(current)) {
@@ -656,17 +712,21 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
             }
             return null;
         }
-        function returnsValue(node) {
-            const returnType = node.value.returnType?.typeAnnotation;
+        function returnsValue(node, fn) {
+            const returnType = fn.returnType?.typeAnnotation ?? declaredFunctionReturnType(node);
             if (returnType) {
                 if (isVoidishType(returnType)) {
                     return false;
                 }
                 return true;
             }
-            const body = node.value.body;
+            const body = fn.body;
             if (!body)
                 return false;
+            // A concise arrow body IS the value handed back; the subject visitor has
+            // already required it to be one that cannot be read as a command.
+            if (body.type !== utils_1.AST_NODE_TYPES.BlockStatement)
+                return true;
             const stack = [...body.body];
             while (stack.length) {
                 const current = stack.pop();
@@ -886,7 +946,18 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
          * mentions promises.
          */
         function returnsThenable(node) {
-            return functionYieldsThenable(node, node.value, new Set([node.value]));
+            const fn = memberFunctionOf(node);
+            if (!fn)
+                return false;
+            // A field states its contract beside the name when the arrow carries no
+            // annotation of its own, and that contract settles the question exactly
+            // as an arrow's own annotation would.
+            if (!fn.returnType) {
+                const declared = declaredFunctionReturnType(node);
+                if (declared)
+                    return isThenableTypeNode(declared);
+            }
+            return functionYieldsThenable(node, fn, new Set([fn]));
         }
         /**
          * Returns true when the method body contains a ThrowStatement that is
@@ -894,8 +965,8 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
          * A method that can throw at the top level is an imperative assertion, not
          * a computed property, so it must not become a getter.
          */
-        function containsTopLevelThrow(body) {
-            const stack = [...body.body];
+        function containsTopLevelThrow(fn) {
+            const stack = bodyWalkRoots(fn);
             while (stack.length) {
                 const current = stack.pop();
                 // Do not descend into nested function-like scopes — a throw there is
@@ -937,8 +1008,8 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
             }
             return false;
         }
-        function bodyReferencesThisProperty(body, propName) {
-            const stack = [...body.body];
+        function bodyReferencesThisProperty(fn, propName) {
+            const stack = bodyWalkRoots(fn);
             while (stack.length) {
                 const current = stack.pop();
                 if (isFunctionLikeNode(current)) {
@@ -1019,7 +1090,7 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
             }
             return true;
         }
-        function trackMemberReference(member, callUsedNamesByClass, callUsedNamesInFile) {
+        function trackMemberReference(member, callUsedNamesByClass, callUsedNamesInFile, detachedNamesByClass, detachedNamesInFile) {
             const propName = memberNameOf(member.property, member.computed);
             if (propName === null) {
                 return;
@@ -1028,22 +1099,29 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                 return;
             }
             addCallUseForMember(member, propName, callUsedNamesByClass, callUsedNamesInFile);
+            addCallUseForMember(member, propName, detachedNamesByClass, detachedNamesInFile);
         }
-        function trackThisDestructuring(pattern, init, callUsedNamesByClass, callUsedNamesInFile) {
+        function trackThisDestructuring(pattern, init, callUsedNamesByClass, callUsedNamesInFile, detachedNamesByClass, detachedNamesInFile) {
             if (!init || init.type !== utils_1.AST_NODE_TYPES.ThisExpression) {
                 return;
             }
+            const record = (name) => {
+                addCallUse(pattern, name, callUsedNamesByClass, callUsedNamesInFile);
+                // Pulling a member off `this` without calling it takes the function
+                // value itself, which is the detachment a getter cannot survive.
+                addCallUse(pattern, name, detachedNamesByClass, detachedNamesInFile);
+            };
             for (const prop of pattern.properties) {
                 if (prop.type === utils_1.AST_NODE_TYPES.Property) {
                     if (prop.computed)
                         continue;
                     const key = prop.key;
                     if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        addCallUse(pattern, key.name, callUsedNamesByClass, callUsedNamesInFile);
+                        record(key.name);
                     }
                     else if (key.type === utils_1.AST_NODE_TYPES.Literal &&
                         typeof key.value === 'string') {
-                        addCallUse(pattern, key.value, callUsedNamesByClass, callUsedNamesInFile);
+                        record(key.value);
                     }
                 }
             }
@@ -1087,7 +1165,82 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
         }
         const callUsedNamesByClass = new WeakMap();
         const callUsedNamesInFile = new Set();
+        /**
+         * Names read WITHOUT being called — the strict subset of the call-use sets
+         * that means "the function value itself was taken". A field arrow exists to
+         * be handed around bound (`store.on('change', this.getSnapshot)`), and a
+         * getter would run on that read instead of yielding the function, so the
+         * field arm withholds its report there rather than prescribe a remedy that
+         * breaks the site.
+         */
+        const detachedNamesByClass = new WeakMap();
+        const detachedNamesInFile = new Set();
         const candidates = [];
+        /**
+         * The gates every member function answers, whichever way it is spelled.
+         */
+        function considerMember(node, fn, isField) {
+            if (fn.params.length > 0)
+                return;
+            if (node.optional)
+                return;
+            if (node.computed)
+                return;
+            if (fn.typeParameters)
+                return;
+            // An ECMA private name (`#foo`) is the same privacy as the TypeScript
+            // `private` modifier — and mutually exclusive with it, since `private
+            // #foo` is TS18010 — so it carries a plain, strippable name that the
+            // rule analyzes exactly like an `Identifier` key. Literal, computed and
+            // template keys stay out: their names are not always statically known
+            // and the emitted getter would need quoting the fixer does not do.
+            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier &&
+                node.key.type !== utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+                return;
+            }
+            // `ignoreAsync` means "ignore asynchronous members", not "ignore members
+            // bearing the async keyword": TypeScript does not require the keyword to
+            // return a promise, so `fetchToken(): Promise<string>` is asynchronous
+            // with no keyword written at all (#2154).
+            if (config.ignoreAsync && returnsThenable(node))
+                return;
+            if (node.override)
+                return;
+            if (!fn.body)
+                return;
+            if (isConstrainedByHeritage(node))
+                return;
+            const name = node.key.name;
+            if (ignoredMethods.has(name))
+                return;
+            // Factory/builder terminal members are imperative actions (issue #990 #4).
+            // Exemption takes precedence over stripPrefixes so names like "build"
+            // are never prefix-stripped into a getter candidate.
+            if (factoryMethods.has(name))
+                return;
+            if (computeBodyLineCount(fn) < config.minBodyLines) {
+                return;
+            }
+            if (!returnsValue(node, fn))
+                return;
+            if (config.respectJsDocSideEffects && hasSideEffectTag(node))
+                return;
+            // A member that throws at the top level is an imperative assertion or
+            // command, not a computed property — getters must be pure/non-throwing.
+            if (containsTopLevelThrow(fn))
+                return;
+            const sideEffectReason = analyzeMutations(fn);
+            const suggestedName = suggestName(name);
+            const sigil = node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier ? '#' : '';
+            candidates.push({
+                node,
+                fn,
+                sideEffectReason,
+                memberName: `${sigil}${name}`,
+                getterName: `${sigil}${suggestedName}`,
+                isField,
+            });
+        }
         return {
             CallExpression(node) {
                 const callee = node.callee;
@@ -1102,21 +1255,31 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                 }
             },
             MemberExpression(node) {
-                trackMemberReference(node, callUsedNamesByClass, callUsedNamesInFile);
+                trackMemberReference(node, callUsedNamesByClass, callUsedNamesInFile, detachedNamesByClass, detachedNamesInFile);
             },
             ChainExpression(node) {
                 if (node.expression.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                    trackMemberReference(node.expression, callUsedNamesByClass, callUsedNamesInFile);
+                    trackMemberReference(node.expression, callUsedNamesByClass, callUsedNamesInFile, detachedNamesByClass, detachedNamesInFile);
                 }
             },
             VariableDeclarator(node) {
                 if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
-                    trackThisDestructuring(node.id, node.init ?? null, callUsedNamesByClass, callUsedNamesInFile);
+                    trackThisDestructuring(node.id, node.init ?? null, callUsedNamesByClass, callUsedNamesInFile, detachedNamesByClass, detachedNamesInFile);
                 }
             },
             AssignmentExpression(node) {
                 if (node.left.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
-                    trackThisDestructuring(node.left, node.right, callUsedNamesByClass, callUsedNamesInFile);
+                    trackThisDestructuring(node.left, node.right, callUsedNamesByClass, callUsedNamesInFile, detachedNamesByClass, detachedNamesInFile);
+                }
+            },
+            JSXMemberExpression(node) {
+                // `<this.Panel />` takes the member's function value — JSX invokes the
+                // component itself — but it is a JSXMemberExpression, which the member
+                // trackers never see. A component declared as a field is exactly the
+                // shape a getter would break, so this counts as detachment.
+                const property = node.property;
+                if (property.type === utils_1.AST_NODE_TYPES.JSXIdentifier) {
+                    addCallUse(node, property.name, detachedNamesByClass, detachedNamesInFile);
                 }
             },
             BinaryExpression(node) {
@@ -1133,73 +1296,37 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
             'MethodDefinition, TSAbstractMethodDefinition'(node) {
                 if (node.kind !== 'method')
                     return;
-                if (node.value.params.length > 0)
-                    return;
                 if (node.value.generator)
                     return;
-                if (node.optional)
-                    return;
-                if (node.computed)
-                    return;
-                if (node.value.typeParameters)
-                    return;
-                // An ECMA private name (`#foo`) is the same privacy as the TypeScript
-                // `private` modifier — and mutually exclusive with it, since `private
-                // #foo` is TS18010 — so it carries a plain, strippable name that the
-                // rule analyzes exactly like an `Identifier` key. Literal, computed and
-                // template keys stay out: their names are not always statically known
-                // and the emitted getter would need quoting the fixer does not do.
-                if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier &&
-                    node.key.type !== utils_1.AST_NODE_TYPES.PrivateIdentifier) {
-                    return;
-                }
-                // `ignoreAsync` means "ignore asynchronous methods", not "ignore
-                // methods bearing the async keyword": TypeScript does not require the
-                // keyword to return a promise, so `fetchToken(): Promise<string>` is
-                // asynchronous with no keyword written at all (#2154).
-                if (config.ignoreAsync && returnsThenable(node))
-                    return;
                 if (config.ignoreAbstract &&
                     node.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition) {
                     return;
                 }
-                if (node.override)
-                    return;
-                if (!node.value.body)
-                    return;
-                if (isConstrainedByHeritage(node))
-                    return;
-                const name = node.key.name;
-                if (ignoredMethods.has(name))
-                    return;
-                // Factory/builder terminal methods are imperative actions (issue #990 #4).
-                // Exemption takes precedence over stripPrefixes so names like "build"
-                // are never prefix-stripped into a getter candidate.
-                if (factoryMethods.has(name))
-                    return;
+                // Getters cannot carry overload declarations, so leaving the signatures
+                // in place would produce invalid TypeScript. Only a method can have
+                // them: a field and an overload signature of the same name is not a
+                // legal class body.
                 if (hasOverloadSignatures(node))
                     return;
-                const body = node.value.body;
-                if (computeBodyLineCount(body) < config.minBodyLines) {
-                    return;
-                }
-                if (!returnsValue(node))
+                considerMember(node, node.value, false);
+            },
+            'PropertyDefinition, TSAbstractPropertyDefinition'(node) {
+                // A field is a member function only when it holds one. Data fields,
+                // `declare` fields and `abstract` declarations hold no function at all,
+                // so they leave here rather than needing a gate of their own.
+                const fn = memberFunctionOf(node);
+                if (!fn)
                     return;
-                if (config.respectJsDocSideEffects && hasSideEffectTag(node))
+                // `foo = function* () {}` hands back an iterator through a protocol a
+                // getter has no way to express.
+                if (fn.type === utils_1.AST_NODE_TYPES.FunctionExpression && fn.generator) {
                     return;
-                // A method that throws at the top level is an imperative assertion or
-                // command, not a computed property — getters must be pure/non-throwing.
-                if (containsTopLevelThrow(body))
+                }
+                if (config.ignoreAbstract &&
+                    node.type === utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition) {
                     return;
-                const sideEffectReason = analyzeMutations(body);
-                const suggestedName = suggestName(name);
-                const sigil = node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier ? '#' : '';
-                candidates.push({
-                    node,
-                    sideEffectReason,
-                    memberName: `${sigil}${name}`,
-                    getterName: `${sigil}${suggestedName}`,
-                });
+                }
+                considerMember(node, fn, true);
             },
             'Program:exit'() {
                 const suggestedNameCounts = new WeakMap();
@@ -1212,7 +1339,28 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                     const side = node.static ?? false;
                     return `${side ? 'static' : 'instance'}:${getterName}`;
                 };
-                for (const { node, getterName } of candidates) {
+                /**
+                 * A field handed around as a function value is the one shape whose
+                 * getter remedy is wrong rather than merely unfixable: the caller that
+                 * wrote `this.getSnapshot` wants the function, and a getter would run
+                 * the body and hand back its result instead. The method arm keeps
+                 * reporting such members — its remedy is to convert the member AND its
+                 * call sites, which stays available — so this withholding is specific
+                 * to the spelling whose purpose is detachment.
+                 */
+                const isDetachedField = (candidate) => {
+                    if (!candidate.isField)
+                        return false;
+                    const classBody = candidate.node.parent;
+                    const withinClass = classBody?.type === utils_1.AST_NODE_TYPES.ClassBody
+                        ? detachedNamesByClass
+                            .get(classBody)
+                            ?.has(candidate.memberName) ?? false
+                        : false;
+                    return withinClass || detachedNamesInFile.has(candidate.memberName);
+                };
+                const reportable = candidates.filter((candidate) => !isDetachedField(candidate));
+                for (const { node, getterName } of reportable) {
                     const classBody = node.parent;
                     if (!classBody || classBody.type !== utils_1.AST_NODE_TYPES.ClassBody) {
                         continue;
@@ -1222,7 +1370,7 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                     existingCounts.set(scopeKey, (existingCounts.get(scopeKey) ?? 0) + 1);
                     suggestedNameCounts.set(classBody, existingCounts);
                 }
-                for (const { node, sideEffectReason, memberName, getterName, } of candidates) {
+                for (const { node, fn, sideEffectReason, memberName, getterName, isField, } of reportable) {
                     const classBody = node.parent;
                     const scopeKey = scopeKeyOf(node, getterName);
                     const leftParen = sourceCode.getTokenAfter(node.key, {
@@ -1233,10 +1381,7 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                             filter: (token) => token.value === ')',
                         })
                         : null;
-                    const body = node.value.body;
-                    const referencesSuggestedName = body && body.type === utils_1.AST_NODE_TYPES.BlockStatement
-                        ? bodyReferencesThisProperty(body, getterName)
-                        : false;
+                    const referencesSuggestedName = bodyReferencesThisProperty(fn, getterName);
                     const hasCollision = hasNameCollision(node, getterName);
                     const isCallUsed = classBody?.type === utils_1.AST_NODE_TYPES.ClassBody
                         ? callUsedNamesByClass.get(classBody)?.has(memberName) ?? false
@@ -1281,7 +1426,16 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                             suggestedName: getterName,
                             reason: sideEffectReason ?? 'it returns a value',
                         },
-                        fix: !isPrivate ||
+                        fix: 
+                        // The field spelling is report-only. Its rewrite must consume the
+                        // `= (`…`) =>` and the terminating `;`, reshape a concise body
+                        // into a block, and drop a `readonly` modifier a getter cannot
+                        // carry — and even done perfectly it turns an own enumerable
+                        // per-instance property into a prototype accessor, which changes
+                        // `Object.keys(instance)` and object spread. No gate here models
+                        // that, so the developer applies it.
+                        isField ||
+                            !isPrivate ||
                             sideEffectReason ||
                             isThenableReturning ||
                             !leftParen ||

package/lib/rules/semantic-function-prefixes.js

@@ -171,6 +171,49 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
                 privateIdentifierPrefix: '#',
             }));
         }
+        /**
+         * A class member written as a function-valued field (`getUser = () => {}`)
+         * declares the same thing as `getUser() {}`: a named, callable member of the
+         * class. The two spellings differ only in binding and `this` semantics, not
+         * in what this rule judges, so a single `=` must not decide whether the name
+         * is read.
+         */
+        function checkPropertyName(node) {
+            const value = node.value;
+            /**
+             * Only a function-valued field names an operation. `updateCount = 0` and
+             * `getters = {}` are data whose names describe a value, not a verb applied
+             * to one, and a field with no initializer (`declare getData: Fn`,
+             * `getData!: Fn`) declares no implementation to name.
+             */
+            if (value?.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                value?.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+                return;
+            }
+            /**
+             * A named function expression carries its own binding, which the function
+             * arm reads and reports on. Deferring to it keeps exactly one report per
+             * site and matches the precedence the rule already applies to the variable
+             * spelling, where `const getUser = function getData() {}` is reported as
+             * `getData`.
+             */
+            if (value.type === utils_1.AST_NODE_TYPES.FunctionExpression && value.id) {
+                return;
+            }
+            const { key } = node;
+            // Same readable-key requirement as the method arm; see checkMethodName.
+            if (node.computed ||
+                (key.type !== utils_1.AST_NODE_TYPES.Identifier &&
+                    key.type !== utils_1.AST_NODE_TYPES.PrivateIdentifier)) {
+                return;
+            }
+            const propertyName = key.name;
+            if (!propertyName)
+                return;
+            reportIfGenericPrefix(key, propertyName, (0, getMethodName_1.getMethodName)(node, context.getSourceCode(), {
+                privateIdentifierPrefix: '#',
+            }));
+        }
         function checkFunctionName(node) {
             // Skip anonymous functions
             if (!node.id && node.parent?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
@@ -194,6 +237,7 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
             FunctionExpression: checkFunctionName,
             ArrowFunctionExpression: checkFunctionName,
             MethodDefinition: checkMethodName,
+            PropertyDefinition: checkPropertyName,
         };
     },
 });

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,74 @@
 [
+  {
+    "version": "1.20.182",
+    "date": "2026-08-27T12:12:45.593Z",
+    "rules": [
+      {
+        "name": "enforce-assert-throws",
+        "changeType": "fix",
+        "issues": [
+          2162
+        ],
+        "summary": "name a function-valued class field (closes #2162)"
+      },
+      {
+        "name": "enforce-boolean-naming-prefixes",
+        "changeType": "fix",
+        "issues": [
+          2159
+        ],
+        "summary": "read a field's boolean-returning function value (closes #2159)"
+      },
+      {
+        "name": "enforce-positive-naming",
+        "changeType": "fix",
+        "issues": [
+          2157
+        ],
+        "summary": "judge class fields and abstract members (closes #2157)"
+      },
+      {
+        "name": "enforce-verb-noun-naming",
+        "changeType": "fix",
+        "issues": [
+          2160
+        ],
+        "summary": "check a callable class field (closes #2160)"
+      },
+      {
+        "name": "no-misleading-boolean-prefixes",
+        "changeType": "fix",
+        "issues": [
+          2155
+        ],
+        "summary": "judge a boolean-prefixed class field holding a function (closes #2155)"
+      },
+      {
+        "name": "no-unnecessary-verb-suffix",
+        "changeType": "fix",
+        "issues": [
+          2156
+        ],
+        "summary": "check a class field holding a function (closes #2156)"
+      },
+      {
+        "name": "prefer-getter-over-parameterless-method",
+        "changeType": "fix",
+        "issues": [
+          2158
+        ],
+        "summary": "consider a function-valued class field (closes #2158)"
+      },
+      {
+        "name": "semantic-function-prefixes",
+        "changeType": "fix",
+        "issues": [
+          2161
+        ],
+        "summary": "judge a function-valued class property (closes #2161)"
+      }
+    ]
+  },
   {
     "version": "1.20.181",
     "date": "2026-08-27T06:29:43.247Z",