@blumintinc/eslint-plugin-blumint 1.19.30 → 1.19.32

package/lib/index.js

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

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

@@ -921,6 +921,130 @@ 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));
+        // Unwrap type-only expression wrappers (`'msg' as const`, `x satisfies T`,
+        // `x!`) so an asserted string/number literal is still recognized. Unwrapping
+        // can only expose a non-boolean literal, never mask a real boolean, so it
+        // cannot over-exempt a genuinely negatively-named boolean.
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+        case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            return isDefinitelyNonBooleanExpression(node.expression);
+        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 +1276,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 +1322,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 +1347,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 +1372,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/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.19.32",
+    "date": "2026-07-24T00:36:05.744Z",
+    "rules": [
+      {
+        "name": "enforce-positive-naming",
+        "changeType": "fix",
+        "issues": [
+          1344
+        ],
+        "summary": "recognize wrapped and annotated non-boolean validator returns"
+      }
+    ]
+  },
+  {
+    "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",