@blumintinc/eslint-plugin-blumint 1.20.53 → 1.20.55

package/lib/index.js

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

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

@@ -1219,40 +1219,12 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             }
         }
         /**
-         * Check class property definitions for boolean values
-         */
-        function checkClassProperty(node) {
-            if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
-                return;
-            const propertyName = node.key.name;
-            // Check if it's a boolean property
-            let isBooleanProperty = false;
-            // Check if it has a boolean type annotation
-            if (node.typeAnnotation?.typeAnnotation &&
-                node.typeAnnotation.typeAnnotation.type ===
-                    utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
-                isBooleanProperty = true;
-            }
-            // Check if it's initialized with a boolean value
-            if (node.value?.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof node.value.value === 'boolean') {
-                isBooleanProperty = true;
-            }
-            if (isBooleanProperty && !hasApprovedPrefix(propertyName)) {
-                context.report({
-                    node: node.key,
-                    messageId: 'missingBooleanPrefix',
-                    data: {
-                        type: 'property',
-                        name: propertyName,
-                        capitalizedName: capitalizeFirst(propertyName),
-                        prefixes: formatPrefixes(),
-                    },
-                });
-            }
-        }
-        /**
-         * Check class property declarations for boolean values
+         * Check class property declarations for boolean values.
+         *
+         * Handles both concrete (`PropertyDefinition`) and abstract
+         * (`TSAbstractPropertyDefinition`) fields: an abstract field is a
+         * declaration the author owns and every implementer inherits the name from,
+         * so it carries the same naming obligation as a concrete one.
          */
         function checkClassPropertyDeclaration(node) {
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
@@ -1383,6 +1355,43 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 }
             }
         }
+        /**
+         * Check constructor parameter properties (`constructor(private enabled: boolean) {}`)
+         * for boolean values.
+         *
+         * An access modifier turns a constructor parameter into a declared class
+         * field, so it is reported as a `property` rather than a `parameter`. The
+         * generic parameter visitor never sees these names — `TSParameterProperty`
+         * wraps the identifier — so this is the single report site for them.
+         */
+        function checkParameterProperty(node) {
+            // A default value wraps the identifier again: `private enabled = true`
+            // parses as an AssignmentPattern whose left holds the name and annotation.
+            const { parameter } = node;
+            const isDefaulted = parameter.type === utils_1.AST_NODE_TYPES.AssignmentPattern;
+            const target = isDefaulted ? parameter.left : parameter;
+            if (target.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return;
+            const propertyName = target.name;
+            const hasBooleanAnnotation = target.typeAnnotation?.typeAnnotation.type ===
+                utils_1.AST_NODE_TYPES.TSBooleanKeyword;
+            const initializer = isDefaulted ? parameter.right : undefined;
+            const hasBooleanInitializer = initializer?.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof initializer.value === 'boolean';
+            if ((hasBooleanAnnotation || hasBooleanInitializer) &&
+                !hasApprovedPrefix(propertyName)) {
+                context.report({
+                    node: target,
+                    messageId: 'missingBooleanPrefix',
+                    data: {
+                        type: 'property',
+                        name: propertyName,
+                        capitalizedName: capitalizeFirst(propertyName),
+                        prefixes: formatPrefixes(),
+                    },
+                });
+            }
+        }
         return {
             VariableDeclarator: checkVariableDeclaration,
             FunctionDeclaration: checkFunctionDeclaration,
@@ -1398,8 +1407,9 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             },
             MethodDefinition: checkMethodDefinition,
             TSAbstractMethodDefinition: checkMethodDefinition,
-            ClassProperty: checkClassProperty,
             PropertyDefinition: checkClassPropertyDeclaration,
+            TSAbstractPropertyDefinition: checkClassPropertyDeclaration,
+            TSParameterProperty: checkParameterProperty,
             TSPropertySignature: checkPropertySignature,
             Identifier(node) {
                 // Check parameter names in function declarations

package/lib/rules/export-if-in-doubt.js

@@ -78,11 +78,16 @@ exports.exportIfInDoubt = (0, createRule_1.createRule)({
                         !exportedIdentifiers.includes(node.id.name)) {
                         const name = node.id.name;
                         const kind = getDeclarationKind(node);
+                        // The only remedy is prepending `export` to the declaration that
+                        // is already there, so everything past the name is elided with
+                        // `…`. A concrete-looking stand-in (`= undefined`, `() {}`,
+                        // `= unknown`) reads as code to paste over the declaration and
+                        // silently destroys its initializer, parameters, body, or type.
                         const exportExample = node.type === 'VariableDeclarator'
-                            ? `export ${kind} ${name} = undefined;`
+                            ? `export ${kind} ${name} = …;`
                             : node.type === 'FunctionDeclaration'
-                                ? `export function ${name}() {}`
-                                : `export type ${name} = unknown;`;
+                                ? `export function ${name}(…) { … }`
+                                : `export type ${name} = …;`;
                         context.report({
                             node,
                             messageId: 'exportIfInDoubt',

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.55",
+    "date": "2026-08-01T02:47:13.295Z",
+    "rules": [
+      {
+        "name": "enforce-boolean-naming-prefixes",
+        "changeType": "fix",
+        "issues": [
+          1545
+        ],
+        "summary": "check abstract properties and constructor parameter properties (closes #1545)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.54",
+    "date": "2026-08-01T01:37:34.774Z",
+    "rules": [
+      {
+        "name": "export-if-in-doubt",
+        "changeType": "fix",
+        "issues": [
+          1543
+        ],
+        "summary": "elide the remedy example instead of fabricating a destructive value (closes #1543)"
+      }
+    ]
+  },
   {
     "version": "1.20.53",
     "date": "2026-08-01T00:55:57.763Z",