@blumintinc/eslint-plugin-blumint 1.19.28 → 1.19.30

package/lib/index.js

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

package/lib/rules/enforce-id-capitalization.js

@@ -27,6 +27,21 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
         // Regular expression to match standalone "id" surrounded by whitespace or punctuation
         // This ensures we only match "id" as a word, not as part of another word
         const idRegex = /(^|\s|[.,;:!?'"()\[\]{}])id(\s|$|[.,;:!?'"()\[\]{}])/g;
+        // DOM / Testing-Library APIs whose first argument is an attribute NAME
+        // (code), not user-facing text. A literal like 'id' passed here is a DOM
+        // attribute name; flagging or rewriting it to 'ID' breaks the call.
+        const ATTRIBUTE_NAME_METHODS = new Set([
+            'getAttribute',
+            'setAttribute',
+            'hasAttribute',
+            'removeAttribute',
+            'getAttributeNode',
+            'getAttributeNS',
+            'setAttributeNS',
+            'hasAttributeNS',
+            'removeAttributeNS',
+            'toHaveAttribute',
+        ]);
         /**
          * Check if a node is in a context that should be excluded from the rule
          * (e.g., parameter names, property names, type definitions)
@@ -82,6 +97,24 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
             if (node.parent && node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression) {
                 return true;
             }
+            // Check if the node is the attribute-name argument of a DOM / jest-dom
+            // attribute API call, e.g. element.getAttribute('id') or
+            // expect(el).toHaveAttribute('id', ...). The attribute name is code, not
+            // user-facing text. For the *NS variants the name is the second argument
+            // (the first is the namespace URI); otherwise it is the first argument.
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                node.parent.callee &&
+                node.parent.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.parent.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                ATTRIBUTE_NAME_METHODS.has(node.parent.callee.property.name)) {
+                const nameArgIndex = node.parent.callee.property.name.endsWith('NS')
+                    ? 1
+                    : 0;
+                if (node.parent.arguments[nameArgIndex] === node) {
+                    return true;
+                }
+            }
             // Check if the node is a string literal used for property access
             // This handles cases like obj['id'] or OverwolfGame['id']
             if (node.parent &&

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

@@ -112,10 +112,18 @@ 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, or nested
- * in a TSTypeLiteral property's type annotation).
+ * via Pick/Omit (at any level of intersection / Readonly wrapping, union arm,
+ * named-alias indirection, or nested in a TSTypeLiteral property's type
+ * annotation).
+ *
+ * `program` (when supplied) enables resolving a locally-declared named type
+ * alias to its definition, so composition can be seen through named union arms
+ * and shared bases. `seenAliases` guards against recursive-alias cycles; each
+ * descent *through* an alias extends a copy of the set so that sibling paths
+ * (e.g. two union arms sharing a base) each resolve the shared alias
+ * independently.
  */
-function typeNodeComposesWithProps(typeNode, propsTypeName) {
+function typeNodeComposesWithProps(typeNode, propsTypeName, program, seenAliases = new Set()) {
     switch (typeNode.type) {
         case utils_1.AST_NODE_TYPES.TSTypeReference: {
             // A direct reference to the child's whole props type (bare `ChildProps`
@@ -131,20 +139,45 @@ function typeNodeComposesWithProps(typeNode, propsTypeName) {
             // Also recurse into type params (e.g. Readonly<Pick<XProps, ...>>)
             if (typeNode.typeParameters) {
                 for (const param of typeNode.typeParameters.params) {
-                    if (typeNodeComposesWithProps(param, propsTypeName)) {
+                    if (typeNodeComposesWithProps(param, propsTypeName, program, seenAliases)) {
                         return true;
                     }
                 }
             }
+            // Resolve a locally-declared named type alias to its definition and
+            // recurse. This lets composition be seen through named union arms and
+            // shared bases (issue #1343): `RowActionableProps` → `RowBaseProps & {…}`
+            // → `Pick<MenuItemProps, …>`. Only in-file aliases resolve; imported
+            // names (e.g. MenuItemProps) return null and are left as-is.
+            if (program) {
+                const aliasName = getTypeReferenceName(typeNode);
+                if (aliasName && !seenAliases.has(aliasName)) {
+                    const alias = findPropsTypeAliasByName(program, aliasName);
+                    if (alias) {
+                        const nextSeen = new Set(seenAliases);
+                        nextSeen.add(aliasName);
+                        if (typeNodeComposesWithProps(alias.typeAnnotation, propsTypeName, program, nextSeen)) {
+                            return true;
+                        }
+                    }
+                }
+            }
             return false;
         }
         case utils_1.AST_NODE_TYPES.TSIntersectionType: {
-            // Check each member of an intersection (A & B & C)
-            return typeNode.types.some((t) => typeNodeComposesWithProps(t, propsTypeName));
+            // Check each member of an intersection (A & B & C) — the whole
+            // intersection composes if any member does.
+            return typeNode.types.some((t) => typeNodeComposesWithProps(t, propsTypeName, program, seenAliases));
         }
         case utils_1.AST_NODE_TYPES.TSUnionType: {
-            // Check each member of a union — for union types, at least one member composes
-            return typeNode.types.some((t) => typeNodeComposesWithProps(t, propsTypeName));
+            // A union (A | B) composes if ANY arm composes. `.some` (not `.every`) is
+            // deliberate: a discriminated union commonly renders a *different* child
+            // per arm (issue #1343's EditableBoolean: `Omit<SwitchProps>` on one arm,
+            // `Omit<CheckboxProps>` on the other). Requiring every arm to compose with
+            // every rendered child would flag that legitimate pattern — a false
+            // positive the repo prefers to avoid. `.some` still passes the target
+            // case, where every arm composes with the single shared child.
+            return typeNode.types.some((t) => typeNodeComposesWithProps(t, propsTypeName, program, seenAliases));
         }
         case utils_1.AST_NODE_TYPES.TSTypeLiteral: {
             // Check property signatures for nested composition
@@ -152,7 +185,7 @@ function typeNodeComposesWithProps(typeNode, propsTypeName) {
             return typeNode.members.some((member) => {
                 if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
                     member.typeAnnotation) {
-                    return typeNodeComposesWithProps(member.typeAnnotation.typeAnnotation, propsTypeName);
+                    return typeNodeComposesWithProps(member.typeAnnotation.typeAnnotation, propsTypeName, program, seenAliases);
                 }
                 return false;
             });
@@ -498,7 +531,7 @@ exports.requirePropsComposition = (0, createRule_1.createRule)({
             const missingComposition = [];
             for (const dep of depComponents) {
                 const expectedPropsType = toPropsTypeName(dep);
-                let composes = typeNodeComposesWithProps(propsTypeNode, expectedPropsType);
+                let composes = typeNodeComposesWithProps(propsTypeNode, expectedPropsType, prog);
                 // Inverse composition: the child derives its props FROM this parent's
                 // props type (e.g. `Omit<ParentProps, 'children'>`, often with no named
                 // ChildProps at all). The parent is then the single shared source of
@@ -508,7 +541,7 @@ exports.requirePropsComposition = (0, createRule_1.createRule)({
                 if (!composes && propsTypeName) {
                     const depPropsSource = getDependencyPropsSourceType(prog, dep);
                     if (depPropsSource &&
-                        typeNodeComposesWithProps(depPropsSource, propsTypeName)) {
+                        typeNodeComposesWithProps(depPropsSource, propsTypeName, prog)) {
                         composes = true;
                     }
                 }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.19.30",
+    "date": "2026-07-23T22:28:34.611Z",
+    "rules": [
+      {
+        "name": "require-props-composition",
+        "changeType": "fix",
+        "issues": [
+          1343
+        ],
+        "summary": "resolve named aliases through union arms (closes #1343)"
+      }
+    ]
+  },
+  {
+    "version": "1.19.29",
+    "date": "2026-07-23T21:23:38.334Z",
+    "rules": [
+      {
+        "name": "enforce-id-capitalization",
+        "changeType": "fix",
+        "issues": [
+          1337
+        ],
+        "summary": "exempt DOM attribute-name arguments (closes #1337)"
+      }
+    ]
+  },
   {
     "version": "1.19.28",
     "date": "2026-07-23T17:25:39.744Z",