@blumintinc/eslint-plugin-blumint 1.20.66 → 1.20.67

package/lib/index.js

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

package/lib/rules/enforce-microdiff.js

@@ -559,6 +559,11 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                     if (isJsonStringify(node.left) && isJsonStringify(node.right)) {
                         const leftArg = node.left.arguments[0];
                         const rightArg = node.right.arguments[0];
+                        // A zero-argument JSON.stringify() leaves these undefined. The
+                        // indexed read is typed non-optional, so nothing forces the check.
+                        if (!leftArg || !rightArg) {
+                            return;
+                        }
                         if (isObjectOrArrayType(leftArg) && isObjectOrArrayType(rightArg)) {
                             reportedNodes.add(node);
                             const isEqual = node.operator === '===';

package/lib/rules/memo-nested-react-components.js

@@ -712,8 +712,12 @@ See: https://react.dev/learn/your-first-component#nesting-and-organizing-compone
                 if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier)
                     return;
                 const attrName = node.name.name;
-                // Check if it's a component-type prop
-                if (!/(Wrapper|Component|Template|Header|Footer)$/.test(attrName)) {
+                // Check if it's a component-type prop. A non-PascalCase prop (e.g.
+                // renderHeader) is a render callback used with a render={...} prop, not
+                // a component—skip it, mirroring the binding-side carve-out above. The
+                // suffix alone is not enough: it matches the tail of renderHeader.
+                if (!isPascalCaseName(attrName) ||
+                    !/(Wrapper|Component|Template|Header|Footer)$/.test(attrName)) {
                     return;
                 }
                 if (!node.value ||

package/lib/rules/no-compositing-layer-props.js

@@ -46,6 +46,10 @@ const NON_COMPOSITING_VALUES = {
     perspective: new Set(['none']),
     'will-change': new Set(['auto', 'unset', 'initial', 'inherit', 'revert']),
     'backface-visibility': new Set(['visible']),
+    // `normal` is the initial value and creates no stacking context. Because
+    // mix-blend-mode is not inherited, `initial`/`unset`/`revert` all resolve to
+    // it. `inherit` is excluded: it can resolve to a blending value set higher up.
+    'mix-blend-mode': new Set(['normal', 'initial', 'unset', 'revert']),
 };
 exports.noCompositingLayerProps = (0, createRule_1.createRule)({
     name: 'no-compositing-layer-props',

package/lib/rules/no-jsx-in-hooks.js

@@ -114,9 +114,12 @@ const containsJsxInUseMemo = (node) => {
                 body.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                 body.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                 body.callee.property.name === 'map') {
+                // A zero-argument .map() leaves this undefined. The indexed read is
+                // typed non-optional, so nothing forces the check.
                 const mapCallback = body.arguments[0];
-                if ((mapCallback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                    mapCallback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                if (mapCallback &&
+                    (mapCallback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        mapCallback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
                     isJsxElement(mapCallback.body)) {
                     return true;
                 }

package/lib/rules/optimize-object-boolean-conditions.d.ts

@@ -1 +1,2 @@
-export declare const optimizeObjectBooleanConditions: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"extractBooleanCondition", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const optimizeObjectBooleanConditions: TSESLint.RuleModule<"extractBooleanCondition", [], TSESLint.RuleListener>;

package/lib/rules/optimize-object-boolean-conditions.js

@@ -4,6 +4,270 @@ exports.optimizeObjectBooleanConditions = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
+const STATE_HOOK_NAMES = new Set(['useState']);
+/**
+ * Approved boolean-name prefixes, kept in sync with `DEFAULT_BOOLEAN_PREFIXES`
+ * in `enforce-boolean-naming-prefixes`. The list is duplicated rather than
+ * imported because that rule keeps it module-private, and exporting it would
+ * make a single change span two rule files, which the repository's
+ * one-rule-per-commit scope contract forbids.
+ *
+ * The duplication matters for correctness, not style: `enforce-boolean-naming-prefixes`
+ * *requires* booleans to carry one of these prefixes, so treating `!isCollapsed`
+ * as an object dependency would make the two rules contradict each other.
+ *
+ * `have` and `were` are the plural forms that rule derives at runtime from
+ * `has` and `was`; `are` already ships in its base list.
+ */
+const BOOLEAN_NAME_PREFIXES = [
+    'is',
+    'are',
+    'has',
+    'have',
+    'does',
+    'can',
+    'should',
+    'will',
+    'was',
+    'were',
+    'had',
+    'did',
+    'would',
+    'must',
+    'allows',
+    'supports',
+    'needs',
+    'asserts',
+    'includes',
+];
+/**
+ * A name carries a boolean prefix only when the prefix ends on a word boundary,
+ * so `isVisible` matches while object names that merely start with the same
+ * letters (`isolatedConfig`, `canvasContext`, `willowTree`) do not.
+ */
+function hasBooleanNamePrefix(name) {
+    const normalized = name.startsWith('_') ? name.slice(1) : name;
+    const lowerName = normalized.toLowerCase();
+    return BOOLEAN_NAME_PREFIXES.some((prefix) => {
+        if (!lowerName.startsWith(prefix)) {
+            return false;
+        }
+        if (normalized.length === prefix.length) {
+            return true;
+        }
+        const nextChar = normalized.charAt(prefix.length);
+        const isScreamingSnakeCase = normalized === normalized.toUpperCase() && /[a-z]/i.test(normalized);
+        if (isScreamingSnakeCase) {
+            return nextChar === '_';
+        }
+        return (nextChar === '_' ||
+            nextChar === '$' ||
+            (nextChar >= '0' && nextChar <= '9') ||
+            (nextChar === nextChar.toUpperCase() &&
+                nextChar !== nextChar.toLowerCase()));
+    });
+}
+const PRIMITIVE_TYPE_KEYWORDS = new Set([
+    utils_1.AST_NODE_TYPES.TSBooleanKeyword,
+    utils_1.AST_NODE_TYPES.TSNumberKeyword,
+    utils_1.AST_NODE_TYPES.TSStringKeyword,
+    utils_1.AST_NODE_TYPES.TSBigIntKeyword,
+]);
+const NULLISH_TYPE_KEYWORDS = new Set([
+    utils_1.AST_NODE_TYPES.TSNullKeyword,
+    utils_1.AST_NODE_TYPES.TSUndefinedKeyword,
+]);
+function isPrimitiveTypeNode(node) {
+    if (!node) {
+        return false;
+    }
+    if (PRIMITIVE_TYPE_KEYWORDS.has(node.type)) {
+        return true;
+    }
+    // Literal types (`true`, `'grid'`, `2`) are primitives too.
+    if (node.type === utils_1.AST_NODE_TYPES.TSLiteralType) {
+        return true;
+    }
+    // `boolean | undefined` stays a primitive; a union qualifies only when every
+    // member is primitive or nullish, and at least one is an actual primitive.
+    if (node.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+        return (node.types.some((member) => isPrimitiveTypeNode(member)) &&
+            node.types.every((member) => isPrimitiveTypeNode(member) || NULLISH_TYPE_KEYWORDS.has(member.type)));
+    }
+    return false;
+}
+/**
+ * Every expression form handled here evaluates to a primitive regardless of its
+ * operands: comparisons and arithmetic yield numbers/strings/booleans, and `!`,
+ * `typeof` and friends yield booleans/strings/numbers.
+ */
+function isPrimitiveExpression(node) {
+    if (!node) {
+        return false;
+    }
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.Literal: {
+            const { value } = node;
+            return (typeof value === 'string' ||
+                typeof value === 'number' ||
+                typeof value === 'boolean' ||
+                typeof value === 'bigint');
+        }
+        case utils_1.AST_NODE_TYPES.TemplateLiteral:
+            return true;
+        case utils_1.AST_NODE_TYPES.UnaryExpression:
+            return ['!', '-', '+', '~', 'typeof', 'void'].includes(node.operator);
+        case utils_1.AST_NODE_TYPES.BinaryExpression:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+            return isPrimitiveTypeNode(node.typeAnnotation);
+        default:
+            return false;
+    }
+}
+function propertyKeyNameOf(key, computed) {
+    if (!computed && key.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    if (key.type === utils_1.AST_NODE_TYPES.Literal && typeof key.value === 'string') {
+        return key.value;
+    }
+    return undefined;
+}
+function memberTypeOf(members, keyName) {
+    for (const member of members) {
+        if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
+            continue;
+        }
+        if (propertyKeyNameOf(member.key, member.computed === true) === keyName) {
+            return member.typeAnnotation?.typeAnnotation;
+        }
+    }
+    return undefined;
+}
+function findVariableInScopes(scope, name) {
+    let currentScope = scope;
+    while (currentScope) {
+        const variable = currentScope.variables.find((v) => v.name === name);
+        if (variable) {
+            return variable;
+        }
+        currentScope = currentScope.upper;
+    }
+    return undefined;
+}
+/**
+ * Resolves the declared type of a property inside an object type, following at
+ * most a couple of hops through same-file type aliases and interfaces. Anything
+ * that needs cross-file resolution stays unresolved: the rule then falls back to
+ * reporting, which is the conservative direction for a suggestion-only rule.
+ */
+function propertyTypeOf(typeNode, keyName, scope, depth = 0) {
+    if (!typeNode || depth > 2) {
+        return undefined;
+    }
+    if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+        return memberTypeOf(typeNode.members, keyName);
+    }
+    if (typeNode.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+        for (const member of typeNode.types) {
+            const resolved = propertyTypeOf(member, keyName, scope, depth + 1);
+            if (resolved) {
+                return resolved;
+            }
+        }
+        return undefined;
+    }
+    if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+        typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+        const variable = findVariableInScopes(scope, typeNode.typeName.name);
+        for (const def of variable?.defs ?? []) {
+            if (def.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                return propertyTypeOf(def.node.typeAnnotation, keyName, scope, depth + 1);
+            }
+            if (def.node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                return memberTypeOf(def.node.body.body, keyName);
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds the type annotation attached to a binding, including the annotation a
+ * destructured prop inherits from its object pattern (`({ isOpen }: Props)`).
+ */
+function declaredTypeOf(nameNode, scope) {
+    if (nameNode.typeAnnotation) {
+        return nameNode.typeAnnotation.typeAnnotation;
+    }
+    let binding = nameNode;
+    const defaulted = binding.parent;
+    if (defaulted?.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+        defaulted.left === binding) {
+        if (defaulted.typeAnnotation) {
+            return defaulted.typeAnnotation.typeAnnotation;
+        }
+        binding = defaulted;
+    }
+    const property = binding.parent;
+    if (property?.type !== utils_1.AST_NODE_TYPES.Property ||
+        property.value !== binding ||
+        property.parent?.type !== utils_1.AST_NODE_TYPES.ObjectPattern) {
+        return undefined;
+    }
+    const keyName = propertyKeyNameOf(property.key, property.computed);
+    if (!keyName) {
+        return undefined;
+    }
+    return propertyTypeOf(property.parent.typeAnnotation?.typeAnnotation, keyName, scope);
+}
+function isPrimitiveStateHookCall(node) {
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+        return false;
+    }
+    const { callee } = node;
+    const isStateHook = (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        STATE_HOOK_NAMES.has(callee.name)) ||
+        (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            !callee.computed &&
+            callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            STATE_HOOK_NAMES.has(callee.property.name));
+    if (!isStateHook) {
+        return false;
+    }
+    const explicitType = node.typeParameters?.params[0];
+    if (explicitType) {
+        return isPrimitiveTypeNode(explicitType);
+    }
+    return isPrimitiveExpression(node.arguments[0]);
+}
+function isPrimitiveInitializedVariable(nameNode, declarator) {
+    if (!declarator.init) {
+        return false;
+    }
+    if (declarator.id === nameNode) {
+        return isPrimitiveExpression(declarator.init);
+    }
+    // `const [isOpen, setIsOpen] = useState(false)` binds the state value first.
+    if (declarator.id.type === utils_1.AST_NODE_TYPES.ArrayPattern &&
+        declarator.id.elements[0] === nameNode) {
+        return isPrimitiveStateHookCall(declarator.init);
+    }
+    return false;
+}
+function isPrimitiveBinding(variable, scope) {
+    return variable.defs.some((def) => {
+        const nameNode = def.name;
+        if (nameNode.type !== utils_1.AST_NODE_TYPES.Identifier) {
+            return false;
+        }
+        if (isPrimitiveTypeNode(declaredTypeOf(nameNode, scope))) {
+            return true;
+        }
+        return (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+            isPrimitiveInitializedVariable(nameNode, def.node));
+    });
+}
 function isHookCall(node) {
     const callee = node.callee;
     return ((callee.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -29,20 +293,20 @@ function generateBooleanVariableName(objectName, conditionType, isNegated) {
 function capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
-function isObjectExistenceCheck(node) {
+function isObjectExistenceCheck(node, isObjectIdentifier) {
     // Check for patterns like !obj
     if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
         // !obj
         if (node.operator === '!' &&
             node.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-            return true;
+            return isObjectIdentifier(node.argument);
         }
         // !!obj
         if (node.operator === '!' &&
             node.argument.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
             node.argument.operator === '!' &&
             node.argument.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
-            return true;
+            return isObjectIdentifier(node.argument.argument);
         }
     }
     return false;
@@ -75,21 +339,25 @@ function isObjectKeyCountCheck(node) {
     }
     return false;
 }
-function isComplexBooleanExpression(node) {
+function isComplexBooleanExpression(node, isObjectIdentifier) {
     // Check for complex expressions involving objects
     if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
-        return (containsObjectCondition(node.left) || containsObjectCondition(node.right));
+        return (containsObjectCondition(node.left, isObjectIdentifier) ||
+            containsObjectCondition(node.right, isObjectIdentifier));
     }
     return false;
 }
-function containsObjectCondition(node) {
-    return (isObjectExistenceCheck(node) ||
+function containsObjectCondition(node, isObjectIdentifier) {
+    return (isObjectExistenceCheck(node, isObjectIdentifier) ||
         isObjectKeyCountCheck(node) ||
-        isComplexBooleanExpression(node));
+        isComplexBooleanExpression(node, isObjectIdentifier));
 }
-function extractObjectName(node) {
+function extractObjectName(node, isObjectIdentifier) {
     if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
-        if (node.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+        // Mirror the existence matcher so a primitive negation inside a larger
+        // expression never becomes the reported "object".
+        if (node.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+            isObjectIdentifier(node.argument)) {
             return node.argument.name;
         }
     }
@@ -105,18 +373,18 @@ function extractObjectName(node) {
     }
     else if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
         // For complex expressions, try to extract from the first object condition found
-        const leftObj = extractObjectName(node.left);
+        const leftObj = extractObjectName(node.left, isObjectIdentifier);
         if (leftObj)
             return leftObj;
-        return extractObjectName(node.right);
+        return extractObjectName(node.right, isObjectIdentifier);
     }
     return null;
 }
-function analyzeBooleanCondition(node, context) {
+function analyzeBooleanCondition(node, context, isObjectIdentifier) {
     const sourceCode = context.sourceCode;
     const expression = sourceCode.getText(node);
-    if (isObjectExistenceCheck(node)) {
-        const objectName = extractObjectName(node);
+    if (isObjectExistenceCheck(node, isObjectIdentifier)) {
+        const objectName = extractObjectName(node, isObjectIdentifier);
         if (objectName) {
             const isNegated = node.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
                 node.operator === '!' &&
@@ -132,7 +400,7 @@ function analyzeBooleanCondition(node, context) {
         }
     }
     else if (isObjectKeyCountCheck(node)) {
-        const objectName = extractObjectName(node);
+        const objectName = extractObjectName(node, isObjectIdentifier);
         if (objectName) {
             const isNegated = expression.includes('=== 0') || expression.includes('<= 0');
             return {
@@ -144,8 +412,8 @@ function analyzeBooleanCondition(node, context) {
             };
         }
     }
-    else if (isComplexBooleanExpression(node)) {
-        const objectName = extractObjectName(node);
+    else if (isComplexBooleanExpression(node, isObjectIdentifier)) {
+        const objectName = extractObjectName(node, isObjectIdentifier);
         if (objectName) {
             return {
                 type: 'complex',
@@ -158,12 +426,12 @@ function analyzeBooleanCondition(node, context) {
     }
     return null;
 }
-function findBooleanConditionsInDependencies(depsArray, context) {
+function findBooleanConditionsInDependencies(depsArray, context, isObjectIdentifier) {
     const patterns = [];
     for (const element of depsArray.elements) {
         if (!element)
             continue; // Skip holes in array
-        const pattern = analyzeBooleanCondition(element, context);
+        const pattern = analyzeBooleanCondition(element, context, isObjectIdentifier);
         if (pattern) {
             patterns.push(pattern);
         }
@@ -172,20 +440,7 @@ function findBooleanConditionsInDependencies(depsArray, context) {
 }
 function isAlreadyBooleanVariable(node) {
     // Check if the dependency is already a boolean variable (starts with is, has, can, etc.)
-    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
-        const name = node.name;
-        const booleanPrefixes = [
-            'is',
-            'has',
-            'can',
-            'should',
-            'will',
-            'was',
-            'were',
-        ];
-        return booleanPrefixes.some((prefix) => name.toLowerCase().startsWith(prefix.toLowerCase()));
-    }
-    return false;
+    return (node.type === utils_1.AST_NODE_TYPES.Identifier && hasBooleanNamePrefix(node.name));
 }
 exports.optimizeObjectBooleanConditions = (0, createRule_1.createRule)({
     name: 'optimize-object-boolean-conditions',
@@ -212,8 +467,28 @@ exports.optimizeObjectBooleanConditions = (0, createRule_1.createRule)({
                 if (!depsArg || depsArg.type !== utils_1.AST_NODE_TYPES.ArrayExpression) {
                     return;
                 }
+                const scope = context.getScope();
+                const primitiveByName = new Map();
+                // A negated identifier only carries the cost this rule targets when it
+                // can actually hold an object. Approved boolean prefixes (which
+                // enforce-boolean-naming-prefixes mandates) and same-file primitive
+                // evidence both rule that out; unresolved identifiers keep reporting.
+                const isObjectIdentifier = (identifier) => {
+                    const { name } = identifier;
+                    if (hasBooleanNamePrefix(name)) {
+                        return false;
+                    }
+                    const cached = primitiveByName.get(name);
+                    if (cached !== undefined) {
+                        return !cached;
+                    }
+                    const variable = findVariableInScopes(scope, name);
+                    const isPrimitive = !!variable && isPrimitiveBinding(variable, scope);
+                    primitiveByName.set(name, isPrimitive);
+                    return !isPrimitive;
+                };
                 // Find boolean conditions in dependencies
-                const patterns = findBooleanConditionsInDependencies(depsArg, context);
+                const patterns = findBooleanConditionsInDependencies(depsArg, context, isObjectIdentifier);
                 for (const pattern of patterns) {
                     // Skip if it's already a boolean variable
                     if (isAlreadyBooleanVariable(pattern.node)) {

package/lib/rules/prefer-getter-over-parameterless-method.js

@@ -199,7 +199,7 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
         ],
         messages: {
             preferGetter: 'Problem: Method "{{name}}" is a parameterless synchronous method that returns a value. → Impact: Calling it with parentheses disguises that it behaves like a computed property, increasing the chance callers omit parentheses or treat it like an action. → Solution: Convert it to a getter: "get {{suggestedName}}()" to signal property semantics and remove call-site parentheses.',
-            preferGetterSideEffect: 'Problem: Method "{{name}}" looks like a computed value. → Impact: However, {{reason}}, so converting it to a getter would execute side effects on every property access and violate the principle of least surprise. → Solution: Keep it as a method to indicate it performs work, or remove the side effects before converting to "get {{suggestedName}}()".',
+            preferGetterSideEffect: 'Problem: Method "{{name}}" looks like a computed value. → Impact: However, {{reason}}, so converting it to a getter would execute side effects on every property access and violate the principle of least surprise. → Solution: If the side effects are intentional, declare them with an "@sideEffect" (or "@mutates") tag inside a /** */ JSDoc block placed immediately above "{{name}}" with no blank line between: the tag warns callers that reading this value performs work, and the rule honors it (option "respectJsDocSideEffects", enabled by default) and stops reporting the method. If the side effects are not intentional, remove them and convert the method to "get {{suggestedName}}()".',
         },
     },
     defaultOptions: [DEFAULT_OPTIONS],

package/lib/rules/prefer-sx-prop-over-system-props.d.ts

@@ -3,6 +3,7 @@ type Options = [
     {
         components?: string[];
         allowedProps?: string[];
+        printWidth?: number;
     }
 ];
 export declare const preferSxPropOverSystemProps: TSESLint.RuleModule<"preferSxProp", Options, TSESLint.RuleListener>;