@blumintinc/eslint-plugin-blumint 1.20.84 → 1.20.85

package/lib/index.js

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

package/lib/rules/prefer-spread-over-reassembly.js

@@ -83,6 +83,75 @@ const ELEMENT_CALLBACK_METHODS = new Set([
     'flatMap',
 ]);
 const ARRAY_TYPE_NAMES = new Set(['Array', 'ReadonlyArray']);
+/**
+ * Type operators that are homomorphic over their argument: each one rewrites
+ * the modifiers of every member and leaves the key set identical, so a member
+ * list read through them describes the wrapped type exactly. `Readonly<{...}>`
+ * is the idiomatic spelling of a data record, and refusing to see through it
+ * makes the narrowing proof inert on the code it exists to protect (#1643).
+ *
+ * `Pick`, `Omit`, `Record`, `Exclude` and `Extract` are deliberately absent:
+ * they rewrite the key set, and a wrong proof silences a report the rule owes
+ * rather than merely failing to find one.
+ */
+const KEY_PRESERVING_TYPE_OPERATORS = new Set([
+    'Readonly',
+    'Required',
+    'Partial',
+]);
+/**
+ * Collects every name the file itself binds in a way that can stand in front of
+ * a type argument list — a type alias, an interface, a class, an enum, a
+ * namespace or an import. A file spelling `Readonly` as one of these is talking
+ * about its own declaration rather than the lib utility, so the key-preserving
+ * unwrap must not apply to it.
+ *
+ * The walk covers nested declarations too, since a `type Partial<T>` inside a
+ * function body shadows the global just as effectively as a top-level one.
+ */
+function collectLocallyBoundNames(node, names) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration:
+        case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration:
+        case utils_1.AST_NODE_TYPES.TSEnumDeclaration:
+        case utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration:
+            names.add(node.id.name);
+            break;
+        case utils_1.AST_NODE_TYPES.ClassDeclaration:
+        case utils_1.AST_NODE_TYPES.ClassExpression:
+            if (node.id) {
+                names.add(node.id.name);
+            }
+            break;
+        case utils_1.AST_NODE_TYPES.TSModuleDeclaration:
+            if (node.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                names.add(node.id.name);
+            }
+            break;
+        case utils_1.AST_NODE_TYPES.ImportSpecifier:
+        case utils_1.AST_NODE_TYPES.ImportDefaultSpecifier:
+        case utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier:
+            names.add(node.local.name);
+            break;
+        default:
+            break;
+    }
+    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 (child && typeof child === 'object' && 'type' in child) {
+                    collectLocallyBoundNames(child, names);
+                }
+            }
+        }
+        else if (value && typeof value === 'object' && 'type' in value) {
+            collectLocallyBoundNames(value, names);
+        }
+    }
+}
 /**
  * Resolves `Promise<T>` to `T`, leaving anything else as it stands, which is
  * what `await` does to the type of the expression it operates on.
@@ -172,32 +241,43 @@ function findLocalTypeDeclaration(program, name) {
  * Enumerates every property name a type node declares, or null when the member
  * list cannot be established with certainty.
  *
- * Only an unambiguous, fully written-out member list qualifies. A union, an
- * intersection, a mapped or conditional type, a generic instantiation and an
- * interface with an `extends` clause all describe a member set assembled
- * elsewhere, so none of them can prove anything here.
+ * Only an unambiguous, fully written-out member list qualifies, reached either
+ * directly or through the key-preserving operators in
+ * {@link KEY_PRESERVING_TYPE_OPERATORS}. A union, an intersection, a mapped or
+ * conditional type, any other generic instantiation and an interface with an
+ * `extends` clause all describe a member set assembled elsewhere, so none of
+ * them can prove anything here.
  */
-function memberNamesOf(typeNode, program, seen = new Set()) {
+function memberNamesOf(typeNode, scope, seen = new Set()) {
     if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
         return namesOfMembers(typeNode.members);
     }
     if (typeNode.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
-        typeNode.typeName.type !== utils_1.AST_NODE_TYPES.Identifier ||
-        typeNode.typeParameters) {
+        typeNode.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
         return null;
     }
     const name = typeNode.typeName.name;
+    if (typeNode.typeParameters) {
+        // An arity other than one is not the lib utility this name spells, so
+        // nothing about the wrapped member list follows from it.
+        if (!KEY_PRESERVING_TYPE_OPERATORS.has(name) ||
+            typeNode.typeParameters.params.length !== 1 ||
+            scope.isLocallyBound(name)) {
+            return null;
+        }
+        return memberNamesOf(typeNode.typeParameters.params[0], scope, seen);
+    }
     // A self-referential alias (`type T = T`) would otherwise recur forever.
     if (seen.has(name)) {
         return null;
     }
     seen.add(name);
-    const declaration = findLocalTypeDeclaration(program, name);
+    const declaration = findLocalTypeDeclaration(scope.program, name);
     if (!declaration || declaration.typeParameters) {
         return null;
     }
     if (declaration.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-        return memberNamesOf(declaration.typeAnnotation, program, seen);
+        return memberNamesOf(declaration.typeAnnotation, scope, seen);
     }
     if (declaration.extends && declaration.extends.length > 0) {
         return null;
@@ -627,6 +707,20 @@ exports.preferSpreadOverReassembly = (0, createRule_1.createRule)({
         const minFields = options?.minFields ?? DEFAULT_MIN_FIELDS;
         const sourceCode = context.getSourceCode();
         const program = sourceCode.ast;
+        // The scan walks the whole file, so it is deferred until a key-preserving
+        // operator actually turns up in a position the proof depends on — most
+        // files never reach it.
+        let locallyBoundNames = null;
+        const typeScope = {
+            program,
+            isLocallyBound: (name) => {
+                if (!locallyBoundNames) {
+                    locallyBoundNames = new Set();
+                    collectLocallyBoundNames(program, locallyBoundNames);
+                }
+                return locallyBoundNames.has(name);
+            },
+        };
         /**
          * Walks an expression toward its syntactic root and returns the type node
          * that root declares, mirroring the receiver trace in
@@ -753,7 +847,7 @@ exports.preferSpreadOverReassembly = (0, createRule_1.createRule)({
                 return null;
             }
             const elementType = arrayElementTypeOf(receiverType);
-            return elementType ? memberNamesOf(elementType, program) : null;
+            return elementType ? memberNamesOf(elementType, typeScope) : null;
         }
         /**
          * Reports whether the destructured pick is provably a PROPER subset of the
@@ -763,15 +857,16 @@ exports.preferSpreadOverReassembly = (0, createRule_1.createRule)({
          *
          * The proof runs in the safe direction only. A member set that matches the
          * pick exactly is exhaustive, so the rewrite is behavior-preserving and the
-         * rule still reports; a type it cannot resolve — imported, generic, a union,
-         * an index signature — yields no proof and the rule likewise still reports.
-         * Silence is reserved for the case where the widening is demonstrated.
+         * rule still reports; a type it cannot resolve — imported, a union, an
+         * index signature, or an instantiation of anything but a key-preserving
+         * operator — yields no proof and the rule likewise still reports. Silence
+         * is reserved for the case where the widening is demonstrated.
          */
         function isProvablyNarrowingPick(fn, param, destructuredNames) {
             // An explicit annotation overrides whatever the call site would imply,
             // so the contextual route is consulted only in its absence.
             const memberNames = param.typeAnnotation
-                ? memberNamesOf(param.typeAnnotation.typeAnnotation, program)
+                ? memberNamesOf(param.typeAnnotation.typeAnnotation, typeScope)
                 : contextualElementMemberNames(fn);
             if (!memberNames || memberNames.size <= destructuredNames.length) {
                 return false;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.85",
+    "date": "2026-08-03T03:21:29.711Z",
+    "rules": [
+      {
+        "name": "prefer-spread-over-reassembly",
+        "changeType": "fix",
+        "issues": [
+          1643
+        ],
+        "summary": "read the narrowing proof through Readonly (closes #1643)"
+      }
+    ]
+  },
   {
     "version": "1.20.84",
     "date": "2026-08-03T02:56:38.740Z",