@blumintinc/eslint-plugin-blumint 1.20.180 → 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.180',
+        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