@blumintinc/eslint-plugin-blumint 1.18.4 → 1.18.5

package/lib/index.js

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

package/lib/rules/enforce-props-argument-name.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforcePropsArgumentName = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
     name: 'enforce-props-argument-name',
     meta: {
@@ -195,15 +196,89 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 }
             });
         }
+        // Determine whether renaming a constructor parameter property is unsafe to
+        // autofix. A parameter property (`private readonly foo: T`) creates BOTH a
+        // constructor-local binding and a `this.foo` class field, so a
+        // declaration-only rename would leave dangling references: plain `foo`
+        // usages inside the constructor (e.g. `super(foo)`) and `this.foo` accesses
+        // anywhere in the class. Mirrors #1123 — when a rename cannot be applied
+        // everywhere syntactically, emit no fix rather than corrupt the code.
+        function parameterPropertyRenameIsUnsafe(classNode, name, declarationId) {
+            let unsafe = false;
+            const visit = (node) => {
+                if (unsafe) {
+                    return;
+                }
+                if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+                    node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.property.name === name) {
+                    unsafe = true;
+                    return;
+                }
+                if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.name === name &&
+                    node !== declarationId) {
+                    unsafe = true;
+                    return;
+                }
+                for (const key of Object.keys(node)) {
+                    if (key === 'parent') {
+                        continue;
+                    }
+                    const value = node[key];
+                    if (Array.isArray(value)) {
+                        for (const child of value) {
+                            if (ASTHelpers_1.ASTHelpers.isNode(child)) {
+                                visit(child);
+                            }
+                        }
+                    }
+                    else if (ASTHelpers_1.ASTHelpers.isNode(value)) {
+                        visit(value);
+                    }
+                }
+            };
+            visit(classNode);
+            return unsafe;
+        }
+        // Find the class (declaration or expression) that owns a method definition.
+        function getEnclosingClass(node) {
+            const classBody = node.parent;
+            if (classBody && classBody.type === utils_1.AST_NODE_TYPES.ClassBody) {
+                const classNode = classBody.parent;
+                if (classNode &&
+                    (classNode.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+                        classNode.type === utils_1.AST_NODE_TYPES.ClassExpression)) {
+                    return classNode;
+                }
+            }
+            return null;
+        }
         // Check class method parameters (including constructors)
         function checkClassMethod(node) {
             const method = node.value;
             const sourceCode = context.sourceCode;
             const propsParams = getPropsParams(method.params);
+            // When the enclosing class extends a base class, a constructor parameter
+            // property (e.g. `private readonly fullProps: SubProps`) cannot be safely
+            // renamed to `props`: the base class may already declare a private `props`
+            // field/parameter-property, so the rename would create a TS2415 private-
+            // field collision, and it would also leave `super(fullProps)` / `this.
+            // fullProps` references dangling. The rule is purely syntactic and cannot
+            // inspect the base class, so it defers to TypeScript correctness here and
+            // does not report on parameter properties in subclasses (this repo prefers
+            // false negatives over false positives).
+            const enclosingClass = getEnclosingClass(node);
+            const classExtendsBase = !!enclosingClass?.superClass;
             method.params.forEach((param) => {
                 if (isDestructuredParameter(param)) {
                     return;
                 }
+                if (classExtendsBase &&
+                    param.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+                    return;
+                }
                 const id = getIdFromParam(param);
                 if (id && id.typeAnnotation && id.typeAnnotation.typeAnnotation) {
                     const typeName = getTypeName(id.typeAnnotation.typeAnnotation);
@@ -221,6 +296,15 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                                     suggestedName,
                                 },
                                 fix: (fixer) => {
+                                    // A parameter-property rename touches both the parameter and
+                                    // the `this.<name>` field; refuse to autofix when the name is
+                                    // referenced elsewhere, since a declaration-only rename would
+                                    // leave dangling references.
+                                    if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty &&
+                                        enclosingClass &&
+                                        parameterPropertyRenameIsUnsafe(enclosingClass, id.name, id)) {
+                                        return null;
+                                    }
                                     const token = sourceCode.getFirstToken(id);
                                     if (!token)
                                         return null;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.18.5",
+    "date": "2026-07-09T03:26:45.486Z",
+    "rules": [
+      {
+        "name": "enforce-props-argument-name",
+        "changeType": "fix",
+        "issues": [
+          1276
+        ],
+        "summary": "exempt subclass parameter properties to avoid TS2415/TS2304 (closes #1276)"
+      }
+    ]
+  },
   {
     "version": "1.18.4",
     "date": "2026-07-08T07:14:09.487Z",