@blumintinc/eslint-plugin-blumint 1.19.29 → 1.19.31

package/lib/index.js

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

package/lib/rules/enforce-positive-naming.js

@@ -921,6 +921,122 @@ const BOOLEAN_POSITIVE_ALTERNATIVES = {
     WILL_NOT: ['WILL'],
     DOES_NOT: ['DOES'],
 };
+/**
+ * Recognizes type nodes that denote a boolean-only value: the `boolean`
+ * keyword, a `true`/`false` literal type, or a union whose every arm is
+ * boolean. A validator's `string | true` return type is deliberately NOT
+ * boolean-only, so a predicate annotated that way is not treated as a boolean.
+ */
+function isBooleanOnlyType(typeNode) {
+    if (typeNode.type === utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+        return true;
+    }
+    if (typeNode.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+        typeNode.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof typeNode.literal.value === 'boolean') {
+        return true;
+    }
+    if (typeNode.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+        return typeNode.types.every(isBooleanOnlyType);
+    }
+    return false;
+}
+/**
+ * Detects an expression that is definitively non-boolean — a string or number
+ * literal, or a template/object/array literal. Validator predicates return an
+ * error-message string on rejection (and `true` on success), so a string
+ * literal return is the syntactic tell that an `is`/`has`-prefixed value is not
+ * actually a boolean. Ambiguous expressions (calls, identifiers, comparisons,
+ * negations) are intentionally NOT treated as non-boolean, preserving the
+ * rule's existing flagging of genuine negatively-named booleans.
+ */
+function isDefinitelyNonBooleanExpression(node) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.Literal:
+            return typeof node.value === 'string' || typeof node.value === 'number';
+        case utils_1.AST_NODE_TYPES.TemplateLiteral:
+        case utils_1.AST_NODE_TYPES.ObjectExpression:
+        case utils_1.AST_NODE_TYPES.ArrayExpression:
+            return true;
+        case utils_1.AST_NODE_TYPES.ConditionalExpression:
+            return (isDefinitelyNonBooleanExpression(node.consequent) ||
+                isDefinitelyNonBooleanExpression(node.alternate));
+        default:
+            return false;
+    }
+}
+/**
+ * Yields the immediate AST-node children of `node`, skipping the `parent`
+ * back-reference so traversal only walks downward.
+ */
+function childNodesOf(node) {
+    const children = [];
+    for (const key of Object.keys(node)) {
+        if (key === 'parent')
+            continue;
+        const value = node[key];
+        const candidates = Array.isArray(value) ? value : [value];
+        for (const candidate of candidates) {
+            if (candidate &&
+                typeof candidate === 'object' &&
+                typeof candidate.type === 'string') {
+                children.push(candidate);
+            }
+        }
+    }
+    return children;
+}
+/**
+ * Whether any `return` statement belonging to `fn`'s own body (not a nested
+ * function's) yields a definitively non-boolean value.
+ */
+function blockReturnsNonBoolean(block) {
+    const stack = [block];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        // Do not descend into nested function scopes: their returns belong to them.
+        if (current !== block &&
+            (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
+            continue;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+            current.argument &&
+            isDefinitelyNonBooleanExpression(current.argument)) {
+            return true;
+        }
+        for (const child of childNodesOf(current)) {
+            stack.push(child);
+        }
+    }
+    return false;
+}
+/**
+ * Whether a function backing an `is`/`has`-prefixed name actually returns a
+ * non-boolean value — e.g. a validator predicate returning `string | true`. An
+ * explicit return-type annotation is authoritative; otherwise the body's own
+ * `return` statements (or the concise-arrow expression) are inspected.
+ */
+function functionReturnsNonBoolean(fn) {
+    if (fn.returnType) {
+        return !isBooleanOnlyType(fn.returnType.typeAnnotation);
+    }
+    if (fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return isDefinitelyNonBooleanExpression(fn.body);
+    }
+    return blockReturnsNonBoolean(fn.body);
+}
+/**
+ * When a declarator/property value is a function, whether that function is a
+ * non-boolean predicate that must be exempt from boolean negative-naming.
+ */
+function isNonBooleanFunctionValue(node) {
+    return (!!node &&
+        (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            node.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+        functionReturnsNonBoolean(node));
+}
 exports.enforcePositiveNaming = (0, createRule_1.createRule)({
     name: 'enforce-positive-naming',
     meta: {
@@ -1152,6 +1268,12 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             // Only check boolean-like variables
             if (!isBooleanLike(node.id) && !isBooleanLike(node))
                 return;
+            // A validator predicate (e.g. returns `string | true`) is name-prefixed
+            // with `is`/`has` but is not a boolean, so its domain-correct negation
+            // ("isNotBlank") must not be flagged. The name heuristic alone cannot
+            // tell them apart; the initializer's return shape can.
+            if (isNonBooleanFunctionValue(node.init))
+                return;
             const variableName = node.id.name;
             const { isNegative, alternatives } = hasBooleanNegativeNaming(variableName);
             if (isNegative) {
@@ -1192,6 +1314,10 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             // Only check boolean-returning functions
             if (!isBooleanLike(node.id || node))
                 return;
+            // Skip validator predicates that return a non-boolean value (e.g.
+            // `string | true`), whose negation is the domain-correct term.
+            if (functionReturnsNonBoolean(node))
+                return;
             const { isNegative, alternatives } = hasBooleanNegativeNaming(functionName);
             if (isNegative) {
                 context.report({
@@ -1213,6 +1339,9 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             // Only check boolean-returning methods
             if (!isBooleanLike(node.key))
                 return;
+            // Skip validator predicates returning a non-boolean value.
+            if (isNonBooleanFunctionValue(node.value))
+                return;
             const methodName = node.key.name;
             const { isNegative, alternatives } = hasBooleanNegativeNaming(methodName);
             if (isNegative) {
@@ -1235,6 +1364,9 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
             // Only check boolean properties
             if (!isBooleanLike(node.key))
                 return;
+            // Skip validator predicates returning a non-boolean value.
+            if (isNonBooleanFunctionValue(node.value))
+                return;
             const propertyName = node.key.name;
             const { isNegative, alternatives } = hasBooleanNegativeNaming(propertyName);
             if (isNegative) {

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.29",
+  "version": "1.19.31",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.19.31",
+    "date": "2026-07-24T00:26:32.378Z",
+    "rules": [
+      {
+        "name": "enforce-positive-naming",
+        "changeType": "fix",
+        "issues": [
+          1344
+        ],
+        "summary": "don't flag non-boolean validator predicates (closes #1344)"
+      }
+    ]
+  },
+  {
+    "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",