@blumintinc/eslint-plugin-blumint 1.21.7 → 1.21.9

package/lib/index.js

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

package/lib/rules/global-const-style.js

@@ -313,8 +313,10 @@ const isWriteTarget = (node) => {
  * Storing a reference does not copy it: the same array stays reachable through
  * the container, so `holder.items.push(3)` writes through to the binding
  * exactly as a direct alias does, and freezing it raises the same TS2339. A
- * `SpreadElement` is excluded because it genuinely builds a fresh value
- * (`const COPY = [...ITEMS]`), and a computed key is excluded because it coerces
+ * `SpreadElement` is excluded because it builds a fresh VALUE
+ * (`const COPY = [...ITEMS]`) — it is not excluded from the walk entirely,
+ * because the copy still carries the constant's frozen TYPE, which
+ * `copyExpressionOf` handles. A computed key is excluded because it coerces
  * the reference to a property name rather than retaining it.
  */
 const storageContainerOf = (node) => {
@@ -370,9 +372,177 @@ const aliasDeclaratorOf = (identifier) => {
     }
 };
 /**
- * Whether the binding is written through anywhere in the file, under its own
- * name or through an alias of it. Answered from the scope manager's reference
- * list rather than a textual search for the name, so a same-named binding in
+ * Whether a callee spells `Object.assign`, in either the dotted or the
+ * bracketed form — read through `accessedPropertyName` so the two spellings
+ * cannot diverge from how the mutation walk already reads a method name.
+ */
+const isObjectAssignCallee = (callee) => {
+    const value = outermostValueOf(callee);
+    return (value.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        value.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+        value.object.name === 'Object' &&
+        accessedPropertyName(value) === 'assign');
+};
+/**
+ * Array methods whose result keeps the receiver's ELEMENT type. `map` is
+ * absent because its result is typed from the CALLBACK, so the constant's type
+ * reaches it only for a callback that returns its argument unchanged — a no-op
+ * `map`. Admitting it would withhold the assertion from every derived array
+ * anything is computed from, to cover a spelling nobody writes.
+ */
+const TYPE_PRESERVING_COPY_METHODS = new Set(['concat', 'slice', 'filter']);
+/**
+ * The expression that builds a COPY carrying this value's type — the literal
+ * around a spread of it, the call of a copying array method on it, or an
+ * `Object.assign` it feeds.
+ *
+ * A copy is a fresh, mutable value, which is why `storageContainerOf` refuses
+ * it: writing to the copy cannot write through to the constant. But `as const`
+ * changes the constant's TYPE as well as its mutability, and a copy inherits
+ * that type — `[...ITEMS]` of a frozen `readonly [1, 2]` is `(1 | 2)[]`, so
+ * `COPY.push(3)` is TS2345 for an input that compiled. The copy is therefore
+ * followed for exactly the same question the alias walk asks: is the derived
+ * binding written?
+ */
+const copyExpressionOf = (node) => {
+    const parent = node.parent;
+    if (!parent) {
+        return null;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.SpreadElement &&
+        parent.argument === node &&
+        (parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+            parent.parent?.type === utils_1.AST_NODE_TYPES.ArrayExpression)) {
+        return parent.parent;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        parent.arguments.includes(node) &&
+        isObjectAssignCallee(parent.callee)) {
+        return parent;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        parent.object === node) {
+        const method = accessedPropertyName(parent);
+        const callee = outermostValueOf(parent);
+        // A method REFERENCE (`const take = ITEMS.concat;`) builds nothing, so the
+        // copy only exists once the method is actually called.
+        if (method !== null &&
+            TYPE_PRESERVING_COPY_METHODS.has(method) &&
+            callee.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            callee.parent.callee === callee) {
+            return callee.parent;
+        }
+    }
+    return null;
+};
+/** Pattern nodes a parameter's binding can be nested inside. */
+const PATTERN_CONTAINERS = new Set([
+    utils_1.AST_NODE_TYPES.AssignmentPattern,
+    utils_1.AST_NODE_TYPES.Property,
+    utils_1.AST_NODE_TYPES.ObjectPattern,
+    utils_1.AST_NODE_TYPES.ArrayPattern,
+    utils_1.AST_NODE_TYPES.RestElement,
+]);
+const FUNCTION_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.FunctionDeclaration,
+    utils_1.AST_NODE_TYPES.FunctionExpression,
+    utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
+    utils_1.AST_NODE_TYPES.TSDeclareFunction,
+]);
+/**
+ * Whether a default value is what a PARAMETER's type is inferred FROM.
+ *
+ * Answered false in the two cases where freezing the default cannot change a
+ * signature: the parameter carries a type annotation, so its type is declared
+ * rather than inferred — looked for up the whole pattern, since a destructured
+ * parameter carries it on the pattern (`({ distance = DEFAULT }: Props)`) and
+ * a plain one on its binding (`(model: ModelName = DEFAULT)`) — or the default
+ * belongs to a destructuring declaration rather than a parameter list, which
+ * declares no signature at all.
+ */
+const isInferredParameterDefault = (pattern) => {
+    let current = pattern;
+    for (;;) {
+        if (current.typeAnnotation) {
+            return false;
+        }
+        const parent = current.parent;
+        if (!parent) {
+            return false;
+        }
+        if (FUNCTION_TYPES.has(parent.type)) {
+            return parent.params.includes(current);
+        }
+        if (!PATTERN_CONTAINERS.has(parent.type)) {
+            return false;
+        }
+        current = parent;
+    }
+};
+/**
+ * Whether a reference sits where TypeScript INFERS a type from it — a default
+ * parameter or a class property initializer — reached directly or through a
+ * composite literal it is stored into.
+ *
+ * `as const` does not only freeze: it makes the literal type NON-WIDENING, and
+ * an inference site that widened `'ready'` to `string` then keeps the literal.
+ * A parameter defaulted from the constant therefore narrows to that one value,
+ * and every call passing a different one stops compiling (TS2345) for an input
+ * that compiled. The mutation walk cannot see this: nothing is written, the
+ * declaration is simply inferred from a value the assertion changes.
+ *
+ * Both sites are answered on the same terms, because an annotation is what
+ * settles the question in each: a type written by hand is DECLARED, so nothing
+ * infers from the value and freezing it cannot move the declaration. Only the
+ * unannotated spelling narrows.
+ *
+ * A RETURN position infers in exactly the same way and is deliberately absent.
+ * Declining there costs 59 of 778 consumer reports (7.6%) — the constant need
+ * only be held in a literal that is returned — to prevent breaks that the
+ * consumer does not contain, so it is documented as a limitation instead. The
+ * comparable trade in #2330 was rejected at 5%.
+ */
+const isInferenceSite = (identifier) => {
+    let value = outermostValueOf(identifier);
+    for (;;) {
+        const parent = value.parent;
+        if (parent?.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+            parent.right === value) {
+            return isInferredParameterDefault(parent.left);
+        }
+        // A class property's type is inferred from its initializer exactly as a
+        // parameter's is from its default, so `session.stage = 'live'` becomes
+        // TS2322 once the constant behind `stage = DEFAULT_STAGE` is frozen.
+        if ((parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+            parent?.type === utils_1.AST_NODE_TYPES.AccessorProperty) &&
+            parent.value === value) {
+            return !parent.typeAnnotation;
+        }
+        const container = storageContainerOf(value);
+        if (!container) {
+            return false;
+        }
+        value = outermostValueOf(container);
+    }
+};
+/**
+ * Whether anything in the file stops this binding taking `as const`, under its
+ * own name or through an alias of it.
+ *
+ * Two things disqualify it, because `as const` does two things. It freezes the
+ * value, so a WRITE — through the binding (`X.push(1)`), or to a binding that
+ * aliases it (`other = X`) — becomes TS2339/TS2540. And it makes the literal
+ * type NON-WIDENING, so an INFERENCE site that read the widened type keeps the
+ * literal instead, which rewrites a declaration the assertion was never asked
+ * to touch.
+ *
+ * The type half reaches further than the value half, so the walk follows one
+ * edge the mutation question does not need: a COPY (`[...X]`, `X.concat()`),
+ * which is a fresh value but not a fresh type, and breaks on a write to the
+ * copy rather than to `X`.
+ *
+ * Answered from the scope manager's reference list rather than a textual
+ * search for the name, so a same-named binding in
  * another scope (`const arr` shadowed inside a callback) contributes nothing,
  * and a same-named method on an unrelated receiver (`other.push(1)`) is never
  * even visited.
@@ -394,21 +564,39 @@ const aliasDeclaratorOf = (identifier) => {
  * check keyed on `const` would leave the `let` spelling breaking builds under
  * `--fix`.
  */
-const isBindingMutated = (variable, declaredVariablesOf) => {
+const blocksAsConstAssertion = (variable, declaredVariablesOf) => {
     // Grown in place and walked by index: an alias found mid-walk is appended and
     // reached by the same loop, so the traversal needs no recursion of its own.
     const pending = [variable];
     const visited = new Set(pending);
     for (let index = 0; index < pending.length; index += 1) {
         for (const reference of pending[index].references) {
+            // Reassigning an alias is as disqualifying as writing through one. A
+            // binding that takes its type from the constant narrows to the frozen
+            // literal, so `let stage = DEFAULT; stage = 'live';` becomes TS2322 for
+            // an input that compiled. `init` excludes the declaration's own write,
+            // which is how the alias was established rather than a change to it.
+            if (reference.isWrite() && !reference.init) {
+                return true;
+            }
+            if (isInferenceSite(reference.identifier)) {
+                return true;
+            }
             const path = accessPathOf(reference.identifier);
-            if (path !== null) {
-                if (isMutatingMethodCall(path) || isWriteTarget(path)) {
-                    return true;
-                }
-                continue;
+            if (path !== null &&
+                (isMutatingMethodCall(path) || isWriteTarget(path))) {
+                return true;
             }
-            const declarator = aliasDeclaratorOf(reference.identifier);
+            // A copy carries the constant's frozen type into a second binding, so it
+            // is enrolled on the same terms as an alias — but it is reached through a
+            // member access (`ITEMS.concat()`), which the alias walk deliberately
+            // refuses, so it is resolved before that refusal applies.
+            const copy = copyExpressionOf(outermostValueOf(reference.identifier));
+            const declarator = copy
+                ? aliasDeclaratorOf(copy)
+                : path === null
+                    ? aliasDeclaratorOf(reference.identifier)
+                    : null;
             if (!declarator) {
                 continue;
             }
@@ -837,7 +1025,7 @@ exports.default = (0, createRule_1.createRule)({
                                 .getDeclaredVariables(declaration)
                                 .find((variable) => variable.name === name);
                             return (!declaredVariable ||
-                                !isBindingMutated(declaredVariable, declaredVariablesOf));
+                                !blocksAsConstAssertion(declaredVariable, declaredVariablesOf));
                         };
                         if (shouldHaveAsConst(init)) {
                             context.report({

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.21.9",
+    "date": "2026-09-05T05:55:33.427Z",
+    "rules": [
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          2331
+        ],
+        "summary": "withhold the assertion where a copy or a class property carries the frozen type (closes #2331)"
+      }
+    ]
+  },
+  {
+    "version": "1.21.8",
+    "date": "2026-09-05T03:15:57.605Z",
+    "rules": [
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          2329
+        ],
+        "summary": "withhold the assertion where a type is inferred from the constant (closes #2329)"
+      }
+    ]
+  },
   {
     "version": "1.21.7",
     "date": "2026-09-04T21:52:00.765Z",