@blumintinc/eslint-plugin-blumint 1.20.165 → 1.20.167

package/lib/index.js

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

package/lib/rules/memo-compare-deeply-complex-props.js

@@ -822,12 +822,55 @@ function isPropertyComplex(prop, checker, tsNode, ts, treatAnyAsComplex, parentT
     }
     return shouldTreatAnyAsComplex(prop, propType, ts, treatAnyAsComplex, parentTypeFlags, checker);
 }
+/**
+ * Returns true when `declaration` was written by a dependency rather than by the
+ * component's author: a declaration file, or any file under `node_modules`.
+ * Keys on the same `getSourceFile().fileName` inspection the React and DOM
+ * origin gates use.
+ */
+function isExternalDeclaration(declaration) {
+    const sourceFile = declaration.getSourceFile?.();
+    if (!sourceFile)
+        return false;
+    const fileName = sourceFile.fileName ?? '';
+    return (sourceFile.isDeclarationFile === true ||
+        /\.d\.[cm]?ts$/.test(fileName) ||
+        /[/\\]node_modules[/\\]/.test(fileName));
+}
+/**
+ * Returns true when every declaration site of `prop` lives in a dependency.
+ *
+ * `checker.getPropertiesOfType` returns INHERITED members, so a props type that
+ * extends or intersects a library interface (MUI's `TypographyProps`, React's
+ * `HTMLAttributes`, …) surfaces that library's entire surface. Demanding the
+ * author name those in `compareDeeply` prescribes a remedy nobody can act on —
+ * the component neither declares nor receives them, and the lists run past a
+ * hundred names — so the only available exit is a blanket rule disable.
+ *
+ * The gate is `every` rather than "first declaration", so a prop the author
+ * redeclares alongside the library's (the intersection of two same-named
+ * members yields one symbol carrying BOTH declarations) still counts as
+ * authored and is still reported.
+ *
+ * A prop with no declarations at all is treated as authored. Synthesized
+ * symbols reach here from mapped and generic types over the component's own
+ * props, and reporting them preserves the rule's core behaviour; a missing
+ * declaration is not evidence of a dependency.
+ */
+function isExternallyDeclaredProperty(prop) {
+    const declarations = prop.declarations;
+    if (!declarations || declarations.length === 0)
+        return false;
+    return declarations.every(isExternalDeclaration);
+}
 function getComplexPropertiesFromType(type, checker, tsNode, ts, treatAnyAsComplex = false, parentTypeFlags = 0) {
     const properties = checker.getPropertiesOfType(type);
     const complexProps = [];
     for (const prop of properties) {
         if (isReservedReactPropName(prop.name))
             continue;
+        if (isExternallyDeclaredProperty(prop))
+            continue;
         if (isPropertyComplex(prop, checker, tsNode, ts, treatAnyAsComplex, parentTypeFlags)) {
             complexProps.push(prop.name);
         }

package/lib/rules/require-props-composition.js

@@ -119,8 +119,8 @@ function getTypeReferenceName(node) {
 /**
  * Recursively check if a TS type node composes with the given propsTypeName
  * via Pick/Omit (at any level of intersection / Readonly wrapping, union arm,
- * named-alias indirection, or nested in a TSTypeLiteral property's type
- * annotation).
+ * array or tuple element, named-alias indirection, or nested in a TSTypeLiteral
+ * property's type annotation).
  *
  * `scope` (when supplied) is the node the alias lookup walks outward from, which
  * enables resolving a locally-declared named type alias to its definition, so
@@ -185,6 +185,46 @@ function typeNodeComposesWithProps(typeNode, propsTypeName, scope, seenAliases =
             // case, where every arm composes with the single shared child.
             return typeNode.types.some((t) => typeNodeComposesWithProps(t, propsTypeName, scope, seenAliases));
         }
+        case utils_1.AST_NODE_TYPES.TSArrayType: {
+            // A list renderer's composition lives in the ELEMENT type: a parent
+            // declaring `buttons: readonly ActionButtonProps[]` and spreading one
+            // element onto each child forwards the child's ENTIRE prop object, which
+            // is the same DRY guarantee a direct `Pick`/`Omit` prop gives — the
+            // composition is simply one level of indirection away, inside the array.
+            // The child's contract belongs to the element type there, so demanding a
+            // whole-props Pick/Omit on the parent would name a composition a list
+            // renderer must not have (issue #2038). This is the array analogue of the
+            // union-arm unwrapping issue #1343 established.
+            return typeNodeComposesWithProps(typeNode.elementType, propsTypeName, scope, seenAliases);
+        }
+        case utils_1.AST_NODE_TYPES.TSTupleType: {
+            // A tuple is a fixed-length list, and each slot is handed to a child
+            // exactly as an array element is, so any slot that composes composes.
+            return typeNode.elementTypes.some((element) => typeNodeComposesWithProps(element, propsTypeName, scope, seenAliases));
+        }
+        case utils_1.AST_NODE_TYPES.TSNamedTupleMember: {
+            // A tuple slot's label names the slot, never its surface.
+            return typeNodeComposesWithProps(typeNode.elementType, propsTypeName, scope, seenAliases);
+        }
+        case utils_1.AST_NODE_TYPES.TSOptionalType:
+        case utils_1.AST_NODE_TYPES.TSRestType: {
+            // `?` and `...` govern how many slots a tuple carries, not what a slot
+            // carries, so the decorated type is the surface to test.
+            return typeNodeComposesWithProps(typeNode.typeAnnotation, propsTypeName, scope, seenAliases);
+        }
+        case utils_1.AST_NODE_TYPES.TSTypeOperator: {
+            // `readonly T[]` describes the same prop surface as `T[]`: the modifier
+            // constrains mutation of the container, never the shape of its elements.
+            //
+            // Only `readonly` unwraps. `keyof ChildProps` is the child's KEY union — a
+            // set of strings that hands the child nothing — and `unique symbol` is a
+            // nominal token, so crediting either would let a parent that merely names
+            // the child's keys pass as composing with its props.
+            if (typeNode.operator !== 'readonly' || !typeNode.typeAnnotation) {
+                return false;
+            }
+            return typeNodeComposesWithProps(typeNode.typeAnnotation, propsTypeName, scope, seenAliases);
+        }
         case utils_1.AST_NODE_TYPES.TSTypeLiteral: {
             // Check property signatures for nested composition
             // e.g. { iconProps?: Omit<GradientIconButtonProps, 'IconComponent'> }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.167",
+    "date": "2026-08-18T04:28:02.499Z",
+    "rules": [
+      {
+        "name": "require-props-composition",
+        "changeType": "fix",
+        "issues": [
+          2038
+        ],
+        "summary": "credit composition through an array element (closes #2038)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.166",
+    "date": "2026-08-18T03:18:38.188Z",
+    "rules": [
+      {
+        "name": "memo-compare-deeply-complex-props",
+        "changeType": "fix",
+        "issues": [
+          2037
+        ],
+        "summary": "exempt props declared by a dependency (closes #2037)"
+      }
+    ]
+  },
   {
     "version": "1.20.165",
     "date": "2026-08-18T00:07:35.027Z",