@blumintinc/eslint-plugin-blumint 1.18.4 → 1.18.6

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.6',
     },
     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/lib/rules/no-hungarian.js

@@ -67,6 +67,52 @@ const ALLOWED_SUFFIXES = [
 ];
 // Common compound nouns that should not be flagged as Hungarian notation
 const ALLOWED_COMPOUND_NOUNS = ['PhoneNumber', 'EmailAddress', 'PostalCode'];
+// Domain-entity head nouns that legitimately precede a "Number" suffix. In
+// <entity>Number the trailing "Number" is the HEAD NOUN of the domain concept
+// (the number OF an issue/line/round/version — GitHub's REST field is literally
+// `issue_number`), not a type marker bolted onto the name. Removing it yields a
+// wrong name (`issue` denotes the whole issue object, not its number), so these
+// are domain compounds, not Hungarian notation — the same reasoning that
+// motivated PhoneNumber/EmailAddress/PostalCode (#640), generalized to the whole
+// <entity>Number category (#1277). Words that are themselves quantities (count,
+// age, index, size, amount, ...) are intentionally ABSENT: for them "Number" is
+// a redundant type tag, so <quantity>Number stays flagged as Hungarian.
+const DOMAIN_NUMBER_HEAD_NOUNS = new Set([
+    'phone',
+    'issue',
+    'line',
+    'round',
+    'version',
+    'account',
+    'match',
+    'order',
+    'invoice',
+    'ticket',
+    'serial',
+    'model',
+    'page',
+    'reference',
+    'confirmation',
+    'tracking',
+    'license',
+    'part',
+    'revision',
+    'build',
+    'sequence',
+    'port',
+    'card',
+    'contract',
+    'document',
+    'receipt',
+    'registration',
+    'flight',
+    'room',
+    'seat',
+    'block',
+    'route',
+    'channel',
+    'badge',
+]);
 // Common built-in JavaScript prototype methods
 const BUILT_IN_METHODS = new Set([
     // String methods
@@ -234,6 +280,24 @@ function isSemanticTypeConcept(typeName) {
     // concept (e.g. Extract+Number) rather than bare type tags glued together.
     return segments.some((segment) => !FULL_TYPE_WORDS.has(segment.toLowerCase()));
 }
+// Is `name` a domain compound of the form <entity>Number, where the word directly
+// before the trailing "Number" is a known domain-entity noun (issueNumber,
+// lineNumber, roundNumber, versionNumber)? Only the LAST head segment is
+// consulted, so prefixed variants generalize (githubIssueNumber, currentLineNumber
+// pass) while numeric-head compounds still read as Hungarian (maxCountNumber ->
+// head segment "Count", not a domain entity -> still flagged).
+function isDomainNumberCompound(name) {
+    if (!name.endsWith('Number')) {
+        return false;
+    }
+    const head = name.slice(0, -'Number'.length);
+    if (head.length === 0) {
+        return false;
+    }
+    const segments = splitCamelSegments(head);
+    const lastSegment = segments[segments.length - 1];
+    return (!!lastSegment && DOMAIN_NUMBER_HEAD_NOUNS.has(lastSegment.toLowerCase()));
+}
 exports.noHungarian = (0, createRule_1.createRule)({
     name: 'no-hungarian',
     meta: {
@@ -374,6 +438,21 @@ exports.noHungarian = (0, createRule_1.createRule)({
                     normalizedVarName.length > normalizedMarker.length &&
                     (/[A-Z0-9]/.test(variableName[variableName.length - normalizedMarker.length - 1]) ||
                         /[A-Z]/.test(variableName[variableName.length - normalizedMarker.length]))) {
+                    // A trailing "...Number" whose head noun is a domain entity
+                    // (issueNumber, lineNumber, roundNumber, versionNumber) is a domain
+                    // compound, not a Hungarian type tag: the suffix names WHAT the value
+                    // is (the number OF an issue — GitHub's REST field is `issue_number`),
+                    // and stripping it destroys the concept (`issue` = the whole object).
+                    // Generalizes #640's PhoneNumber/EmailAddress/PostalCode carve-out to
+                    // the whole <entity>Number category (#1277). Scoped to the full-word
+                    // `Number` marker only: abbreviation tags (str/num/obj/arr/bool) are
+                    // handled above and still fire, and numeric-quantity heads
+                    // (countNumber, ageNumber, indexNumber) keep firing because such heads
+                    // are deliberately absent from DOMAIN_NUMBER_HEAD_NOUNS.
+                    if (normalizedMarker === 'number' &&
+                        isDomainNumberCompound(variableName)) {
+                        return false;
+                    }
                     return true;
                 }
                 // Full type-word markers (non-abbreviations: String, Number, Function,

package/lib/rules/no-unnecessary-verb-suffix.d.ts

@@ -1 +1,2 @@
-export declare const noUnnecessaryVerbSuffix: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unnecessaryVerbSuffix", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const noUnnecessaryVerbSuffix: TSESLint.RuleModule<"unnecessaryVerbSuffix", [], TSESLint.RuleListener>;

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

@@ -166,6 +166,46 @@ function isExported(node) {
     }
     return false;
 }
+/**
+ * Walks a scope chain upward from `scope` (inclusive) and reports whether
+ * `targetName` is bound anywhere between `scope` and `stopScope` (inclusive).
+ * Mirrors how the engine resolves an identifier at a use site: the first scope
+ * on the chain that declares the name wins. Used to detect whether a rewritten
+ * reference would be captured by a binding sitting between it and the
+ * declaration it currently resolves to.
+ */
+function isNameBoundInChain(scope, stopScope, targetName) {
+    let current = scope;
+    while (current) {
+        if (current.set.has(targetName)) {
+            return true;
+        }
+        if (current === stopScope) {
+            break;
+        }
+        current = current.upper;
+    }
+    return false;
+}
+/**
+ * Walks a scope subtree rooted at `root` and reports whether `targetName` is
+ * declared anywhere within it — the renamed function's own parameters and body
+ * bindings. A `suggestion` binding here would shadow the function's new name
+ * (the self-shadowing trap in #1278).
+ */
+function isNameBoundInSubtree(root, targetName) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const scope = stack.pop();
+        if (scope.set.has(targetName)) {
+            return true;
+        }
+        for (const child of scope.childScopes) {
+            stack.push(child);
+        }
+    }
+    return false;
+}
 exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
     name: 'no-unnecessary-verb-suffix',
     meta: {
@@ -182,6 +222,47 @@ exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        /**
+         * Returns true when renaming the symbol to `suggestion` would collide with
+         * an existing binding in any scope the rename touches, making the autofix
+         * semantics-changing (and thus unsafe). The strip-suffix fix rewrites the
+         * declaration plus every in-file reference to `suggestion`; if `suggestion`
+         * already resolves to a different binding the rewrite would:
+         *   - redeclare a name already bound in the declaration scope,
+         *   - capture a call site onto an intervening binding (e.g. turning
+         *     `const line = lineAt(...)` into the TDZ self-reference
+         *     `const line = line(...)`, #1278), or
+         *   - shadow the function's own new name from inside its body.
+         * In every such case the fix is suppressed (report-only) so the developer
+         * picks a non-colliding name — the safety standard core rename fixers hold.
+         */
+        function renameWouldCollide(functionNode, variable, suggestion) {
+            const scopeManager = context.sourceCode.scopeManager;
+            const functionScope = scopeManager?.acquire(functionNode) ?? null;
+            const declarationScope = variable?.scope ?? functionScope?.upper ?? null;
+            // (1) Declaration site: a `suggestion` already bound in the scope that
+            //     holds the declaration would make the rename a redeclaration/shadow.
+            if (declarationScope?.set.has(suggestion)) {
+                return true;
+            }
+            // (2) Reference sites: a binding sitting between a reference and the
+            //     declaration scope would swallow the rewritten identifier — the
+            //     reference would resolve to that binding instead of the function.
+            if (variable && declarationScope) {
+                for (const ref of variable.references) {
+                    const referenceScope = ref.from ?? declarationScope;
+                    if (isNameBoundInChain(referenceScope, declarationScope, suggestion)) {
+                        return true;
+                    }
+                }
+            }
+            // (3) The function's own parameters/body: a `suggestion` binding there
+            //     would shadow the function's new name.
+            if (functionScope && isNameBoundInSubtree(functionScope, suggestion)) {
+                return true;
+            }
+            return false;
+        }
         function checkFunctionName(node, name, 
         /**
          * The AST node that holds the identifier being renamed.
@@ -251,6 +332,24 @@ exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
                                 if (exported || !scopeNode || !declarationIdNode) {
                                     return null;
                                 }
+                                // Note: context.getDeclaredVariables is the API available in the
+                                // pinned @typescript-eslint version (the SourceCode-based
+                                // replacement is not yet in these type definitions).
+                                // getDeclaredVariables returns ALL variables the node declares
+                                // (e.g. for a FunctionDeclaration it includes the function name
+                                // variable AND its parameter variables). Pick the one whose name
+                                // matches the symbol being renamed so we only follow references
+                                // to the name, not parameters.
+                                const declaredVars = context.getDeclaredVariables(scopeNode);
+                                const targetVariable = declaredVars.find((variable) => variable.name === name) ??
+                                    null;
+                                // Suppress the fix when the suggested name already binds
+                                // something in a scope the rename would touch — a rename fixer
+                                // must never change program semantics or break compilation
+                                // (#1278).
+                                if (renameWouldCollide(node, targetVariable, suggestion)) {
+                                    return null;
+                                }
                                 // Scope-tracked symbols (FunctionDeclaration, VariableDeclarator
                                 // arrows/functions, named FunctionExpression): rename the
                                 // declaration identifier and every in-file reference together so
@@ -258,19 +357,8 @@ exports.noUnnecessaryVerbSuffix = (0, createRule_1.createRule)({
                                 const fixes = [
                                     fixer.replaceText(declarationIdNode, suggestion),
                                 ];
-                                // Note: context.getDeclaredVariables is the API available in the
-                                // pinned @typescript-eslint version (the SourceCode-based
-                                // replacement is not yet in these type definitions).
-                                const declaredVars = context.getDeclaredVariables(scopeNode);
-                                // getDeclaredVariables returns ALL variables the node declares
-                                // (e.g. for a FunctionDeclaration it includes the function name
-                                // variable AND its parameter variables). Filter to the one whose
-                                // name matches the symbol being renamed so we only follow
-                                // references to the name, not parameters.
-                                for (const variable of declaredVars) {
-                                    if (variable.name !== name)
-                                        continue;
-                                    for (const ref of variable.references) {
+                                if (targetVariable) {
+                                    for (const ref of targetVariable.references) {
                                         // Skip the declaration identifier itself — already handled.
                                         if (ref.identifier === declarationIdNode)
                                             continue;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.18.6",
+    "date": "2026-07-09T08:45:37.007Z",
+    "rules": [
+      {
+        "name": "no-hungarian",
+        "changeType": "fix",
+        "issues": [
+          1277
+        ],
+        "summary": "exempt domain-entity <noun>Number compounds (closes #1277)"
+      },
+      {
+        "name": "no-unnecessary-verb-suffix",
+        "changeType": "fix",
+        "issues": [
+          1278
+        ],
+        "summary": "bail autofix on rename collision (closes #1278)"
+      }
+    ]
+  },
+  {
+    "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",