@blumintinc/eslint-plugin-blumint 1.20.6 → 1.20.8

package/lib/index.js

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

package/lib/rules/enforce-props-argument-name.d.ts

@@ -1,3 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'usePropsParameterName' | 'usePropsParameterNameWithPrefix';
-export declare const enforcePropsArgumentName: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const enforcePropsArgumentName: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
 export {};

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

@@ -4,6 +4,97 @@ exports.enforcePropsArgumentName = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+/**
+ * A body-less signature (an interface method signature, or an abstract /
+ * `declare` / overload class method) has no statements, so its parameter name
+ * is documentation-only and can never be referenced in-file. A
+ * declaration-only rename is therefore complete rather than partial, and stays
+ * safe even if the scope analyzer declines to model the parameter.
+ */
+const isBodylessSignature = (owner) => owner.type === utils_1.AST_NODE_TYPES.TSMethodSignature ||
+    owner.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
+/**
+ * Rewrites only the identifier's first token. A TSESTree `Identifier` range
+ * spans its type annotation and optional marker (`props?: RunnerProps`), so
+ * `fixer.replaceText(id, newName)` would delete the annotation along with the
+ * name (Issue #1351).
+ */
+const renameIdentifierToken = (fixer, sourceCode, identifier, text) => {
+    const token = sourceCode.getFirstToken(identifier);
+    if (!token) {
+        return null;
+    }
+    return fixer.replaceTextRange([token.range[0], token.range[1]], text);
+};
+/**
+ * Walks the 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.
+ */
+const 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;
+};
+/**
+ * Reports whether `targetName` is used as an identifier anywhere inside
+ * `scope` or its nested scopes. Such a use currently resolves to some other
+ * binding (an outer constant, a nested declaration); giving the parameter that
+ * same name would capture it, silently rebinding working code.
+ */
+const scopeSubtreeReferencesName = (scope, targetName) => {
+    const pending = [scope];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current.references.some((reference) => reference.identifier.name === targetName)) {
+            return true;
+        }
+        pending.push(...current.childScopes);
+    }
+    return false;
+};
+/**
+ * Returns true when renaming `variable` to `newName` would collide with an
+ * existing binding in any scope the rename touches, making the autofix
+ * semantics-changing (and thus unsafe). The fixer rewrites the declaration
+ * plus every in-file reference; if `newName` already resolves to a different
+ * binding, the rewrite would redeclare a name already bound in the declaration
+ * scope, capture a reference onto an intervening binding, or swallow a use of
+ * an outer binding that shares the name. In every such case the fix is
+ * suppressed (report-only).
+ */
+const renameWouldCollide = (variable, newName) => {
+    const declarationScope = variable.scope;
+    // (1) Declaration site: `newName` already bound in the scope that holds the
+    //     parameter would make the rename a redeclaration/shadow.
+    if (declarationScope.set.has(newName)) {
+        return true;
+    }
+    // (2) Reference sites: a binding of `newName` sitting between a reference and
+    //     the declaration scope would swallow the rewritten identifier — the
+    //     reference would resolve to that binding instead of the parameter.
+    for (const reference of variable.references) {
+        const referenceScope = reference.from ?? declarationScope;
+        if (isNameBoundInChain(referenceScope, declarationScope, newName)) {
+            return true;
+        }
+    }
+    // (3) Capture: the parameter's own scope (or a nested one) already uses
+    //     `newName` for something else, so introducing the parameter under that
+    //     name would shadow whatever those uses resolve to.
+    return scopeSubtreeReferencesName(declarationScope, newName);
+};
 exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
     name: 'enforce-props-argument-name',
     meta: {
@@ -153,6 +244,65 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
             }
             return null;
         }
+        // Build the complete rename: the parameter declaration AND every in-scope
+        // reference to it. A declaration-only rename leaves every use site bound to
+        // a now-undefined name, so `--fix` exits 0 while producing code that no
+        // longer compiles (Issue #1355, same defect class as #1313 and #1256).
+        // Returns null whenever the rename cannot be applied everywhere, so the
+        // report stands on its own rather than corrupting the source.
+        function buildParameterRenameFixes(fixer, owner, id, newName) {
+            const sourceCode = context.sourceCode;
+            const declarationFix = renameIdentifierToken(fixer, sourceCode, id, newName);
+            if (!declarationFix) {
+                return null;
+            }
+            // `getDeclaredVariables` on a function returns every parameter plus
+            // `arguments` and, for a declaration, the function's own name — and those
+            // can share a name (`function config(config: XProps)`), so the lookup
+            // matches on declaration identity instead of on the name.
+            const variable = context
+                .getDeclaredVariables(owner)
+                .find((candidate) => candidate.defs.some((def) => def.name === id)) ??
+                null;
+            if (!variable) {
+                return isBodylessSignature(owner) ? [declarationFix] : null;
+            }
+            if (renameWouldCollide(variable, newName)) {
+                return null;
+            }
+            const fixes = [declarationFix];
+            for (const reference of variable.references) {
+                const referenceId = reference.identifier;
+                // A parameter with a default value carries a write reference whose
+                // identifier is the declaration itself, already rewritten above.
+                // Skipping it also avoids overlapping fix ranges, which ESLint rejects.
+                if (referenceId === id) {
+                    continue;
+                }
+                const referenceParent = referenceId.parent;
+                // An object-literal shorthand `{ runnerProps }` desugars to
+                // `{ runnerProps: runnerProps }`: the single token is both the property
+                // key and its value. Rewriting it to `{ props }` would rename the KEY
+                // too, silently changing the object's shape. Expand to
+                // `oldKey: newName` so only the value is renamed.
+                if (referenceParent?.type === utils_1.AST_NODE_TYPES.Property &&
+                    referenceParent.shorthand &&
+                    referenceParent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    const shorthandFix = renameIdentifierToken(fixer, sourceCode, referenceId, `${id.name}: ${newName}`);
+                    if (!shorthandFix) {
+                        return null;
+                    }
+                    fixes.push(shorthandFix);
+                    continue;
+                }
+                const referenceFix = renameIdentifierToken(fixer, sourceCode, referenceId, newName);
+                if (!referenceFix) {
+                    return null;
+                }
+                fixes.push(referenceFix);
+            }
+            return fixes;
+        }
         // Check function parameters
         function checkFunctionParams(node) {
             // Skip function expressions that are part of method definitions
@@ -162,7 +312,6 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                 node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
                 return;
             }
-            const sourceCode = context.sourceCode;
             const propsParams = getPropsParams(node.params);
             node.params.forEach((param) => {
                 if (isDestructuredParameter(param)) {
@@ -184,12 +333,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                                     typeName,
                                     suggestedName,
                                 },
-                                fix: (fixer) => {
-                                    const token = sourceCode.getFirstToken(id);
-                                    if (!token)
-                                        return null;
-                                    return fixer.replaceTextRange([token.range[0], token.range[1]], suggestedName);
-                                },
+                                fix: (fixer) => buildParameterRenameFixes(fixer, node, id, suggestedName),
                             });
                         }
                     }
@@ -258,7 +402,6 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
         // 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
@@ -305,10 +448,7 @@ exports.enforcePropsArgumentName = (0, createRule_1.createRule)({
                                         parameterPropertyRenameIsUnsafe(enclosingClass, id.name, id)) {
                                         return null;
                                     }
-                                    const token = sourceCode.getFirstToken(id);
-                                    if (!token)
-                                        return null;
-                                    return fixer.replaceTextRange([token.range[0], token.range[1]], suggestedName);
+                                    return buildParameterRenameFixes(fixer, method, id, suggestedName);
                                 },
                             });
                         }

package/lib/rules/no-redundant-annotation-assertion.js

@@ -35,11 +35,23 @@ const createRule_1 = require("../utils/createRule");
  * - WriteArrayAsGenericType normalizes arrays to `Array<T>` for consistent output.
  * - UseFullyQualifiedType reduces ambiguity from locally-imported type names.
  * - UseStructuralFallback keeps output meaningful when a nominal name is unavailable.
+ *
+ * Resolved on first use rather than at module load: the plugin barrel imports
+ * every rule eagerly, and the compiler package root does not expose this enum on
+ * all installed TypeScript releases (TypeScript 7 exports only a version stub),
+ * so dereferencing it at module scope makes the whole plugin fail to load rather
+ * than merely disabling this type-aware rule. Every call site sits behind a
+ * `parserServices.program` guard, so the enum is present whenever this runs.
  */
-const TYPE_FORMAT_FLAGS = ts.TypeFormatFlags.NoTruncation |
-    ts.TypeFormatFlags.WriteArrayAsGenericType |
-    ts.TypeFormatFlags.UseFullyQualifiedType |
-    ts.TypeFormatFlags.UseStructuralFallback;
+let typeFormatFlagsCache;
+function typeFormatFlags() {
+    typeFormatFlagsCache ??=
+        ts.TypeFormatFlags.NoTruncation |
+            ts.TypeFormatFlags.WriteArrayAsGenericType |
+            ts.TypeFormatFlags.UseFullyQualifiedType |
+            ts.TypeFormatFlags.UseStructuralFallback;
+    return typeFormatFlagsCache;
+}
 function extractAssertionTypeNode(expression) {
     if (!expression)
         return null;
@@ -137,7 +149,7 @@ function removeTypeAnnotation(fixer, typeAnnotation, sourceCode) {
     return fixer.removeRange([removalStart, end]);
 }
 function typeText(type, checker) {
-    return checker.typeToString(type, undefined, TYPE_FORMAT_FLAGS);
+    return checker.typeToString(type, undefined, typeFormatFlags());
 }
 function unwrapAlias(type, checker) {
     const aliasSymbol = type
@@ -179,7 +191,7 @@ function getFormattedTypeProperties(type, checker) {
 function getFormattedCallSignatures(type, checker) {
     return checker
         .getSignaturesOfType(type, ts.SignatureKind.Call)
-        .map((sig) => checker.signatureToString(sig, undefined, TYPE_FORMAT_FLAGS))
+        .map((sig) => checker.signatureToString(sig, undefined, typeFormatFlags()))
         .sort();
 }
 function structuralKey(type, checker) {
@@ -208,8 +220,8 @@ function getTypeRepresentations(annotationType, assertionType, checker) {
     return {
         annotationText: typeText(annotationType, checker),
         assertionText: typeText(assertionType, checker),
-        annotationCanonical: checker.typeToString(annotationType, undefined, TYPE_FORMAT_FLAGS | ts.TypeFormatFlags.NoTypeReduction),
-        assertionCanonical: checker.typeToString(assertionType, undefined, TYPE_FORMAT_FLAGS | ts.TypeFormatFlags.NoTypeReduction),
+        annotationCanonical: checker.typeToString(annotationType, undefined, typeFormatFlags() | ts.TypeFormatFlags.NoTypeReduction),
+        assertionCanonical: checker.typeToString(assertionType, undefined, typeFormatFlags() | ts.TypeFormatFlags.NoTypeReduction),
         annotationStructural: structuralKey(annotationType, checker),
         assertionStructural: structuralKey(assertionType, checker),
     };

package/lib/rules/no-usememo-for-pass-by-value.js

@@ -16,12 +16,25 @@ const DEFAULT_EXPENSIVE_PATTERNS = [
     'heavy',
     'hash',
 ];
-const PASS_BY_VALUE_FLAGS = typescript_1.default.TypeFlags.StringLike |
-    typescript_1.default.TypeFlags.NumberLike |
-    typescript_1.default.TypeFlags.BigIntLike |
-    typescript_1.default.TypeFlags.BooleanLike |
-    typescript_1.default.TypeFlags.Undefined |
-    typescript_1.default.TypeFlags.Null;
+/**
+ * Resolved on first use rather than at module load: the plugin barrel imports
+ * every rule eagerly, and the compiler package root does not expose this enum on
+ * all installed TypeScript releases (TypeScript 7 exports only a version stub),
+ * so dereferencing it at module scope makes the whole plugin fail to load rather
+ * than merely disabling this type-aware rule. The sole call site sits behind a
+ * `parserServices.program` guard, so the enum is present whenever this runs.
+ */
+let passByValueFlagsCache;
+function passByValueFlags() {
+    passByValueFlagsCache ??=
+        typescript_1.default.TypeFlags.StringLike |
+            typescript_1.default.TypeFlags.NumberLike |
+            typescript_1.default.TypeFlags.BigIntLike |
+            typescript_1.default.TypeFlags.BooleanLike |
+            typescript_1.default.TypeFlags.Undefined |
+            typescript_1.default.TypeFlags.Null;
+    return passByValueFlagsCache;
+}
 function isCustomHookName(name) {
     if (!name)
         return false;
@@ -137,7 +150,7 @@ function isPassByValueType(type, checker) {
         // Conservative: arrays with unresolvable element types are indeterminate.
         return { passByValue: false, indeterminate: true, description };
     }
-    if (type.flags & PASS_BY_VALUE_FLAGS) {
+    if (type.flags & passByValueFlags()) {
         return { passByValue: true, indeterminate: false, description };
     }
     return { passByValue: false, indeterminate: false, description };

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.20.8",
+    "date": "2026-07-28T15:39:20.357Z",
+    "rules": [
+      {
+        "name": "enforce-props-argument-name",
+        "changeType": "fix",
+        "issues": [
+          1355
+        ],
+        "summary": "rename parameter references, not just the declaration (closes #1355)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.7",
+    "date": "2026-07-28T05:35:51.746Z",
+    "rules": [
+      {
+        "name": "no-redundant-annotation-assertion",
+        "changeType": "fix",
+        "issues": [
+          1354
+        ],
+        "summary": "resolve type format flags lazily (closes #1354)"
+      },
+      {
+        "name": "no-usememo-for-pass-by-value",
+        "changeType": "fix",
+        "issues": [
+          1354
+        ],
+        "summary": "resolve compiler type flags lazily (refs #1354)"
+      }
+    ]
+  },
   {
     "version": "1.20.6",
     "date": "2026-07-28T05:19:38.242Z",