@blumintinc/eslint-plugin-blumint 1.14.0 → 1.16.0

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

@@ -32,6 +32,21 @@ const COMPOSITING_VALUES = new Set([
     'translateZ',
     'transparent',
 ]);
+// CSS reset/identity values that explicitly DON'T promote a layer for a given
+// property. These are the opt-out counterparts to COMPOSITING_VALUES: `none`
+// removes the effect, `auto`/global keywords disable the hint, and the default
+// keyword leaves the element un-promoted. Keyed by normalized property name so
+// the allowlist stays property-specific (e.g. `none` clears `transform` but is
+// not a valid no-op for `opacity`).
+const NON_COMPOSITING_VALUES = {
+    filter: new Set(['none']),
+    'backdrop-filter': new Set(['none']),
+    transform: new Set(['none']),
+    contain: new Set(['none']),
+    perspective: new Set(['none']),
+    'will-change': new Set(['auto', 'unset', 'initial', 'inherit', 'revert']),
+    'backface-visibility': new Set(['visible']),
+};
 exports.noCompositingLayerProps = (0, createRule_1.createRule)({
     name: 'no-compositing-layer-props',
     meta: {
@@ -54,6 +69,14 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
                 value.includes('scale3d') ||
                 value.includes('translateZ'));
         }
+        // Strip `!important` and normalize casing so reset/identity values written
+        // as e.g. `none !important` are still recognized as non-promoting.
+        function normalizePropertyValue(value) {
+            return value
+                .replace(/\s*!important\s*$/i, '')
+                .trim()
+                .toLowerCase();
+        }
         function checkProperty(propertyName, propertyValue) {
             const normalizedName = normalizePropertyName(propertyName);
             if (COMPOSITING_PROPERTIES.has(normalizedName)) {
@@ -66,6 +89,14 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
                         return false;
                     return numValue > 0 && numValue < 1;
                 }
+                // CSS reset/identity values can't create a compositing layer, so don't
+                // flag them (mirrors the opacity value-awareness for the other props).
+                const allowedValues = NON_COMPOSITING_VALUES[normalizedName];
+                if (allowedValues &&
+                    propertyValue &&
+                    allowedValues.has(normalizePropertyValue(propertyValue))) {
+                    return false;
+                }
                 return true;
             }
             if (propertyValue && checkPropertyValue(propertyValue)) {

package/lib/rules/no-console-error.js

@@ -4,6 +4,7 @@ exports.noConsoleError = void 0;
 const minimatch_1 = require("minimatch");
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const defaultIgnorePatterns = [
     '**/__tests__/**',
     '**/__mocks__/**',
@@ -69,19 +70,20 @@ const getResolvedVariable = (scope, identifier) => {
     return findVariable(scope, identifier.name);
 };
 const getScopeForNode = (context, node) => {
-    const sourceCode = context.getSourceCode();
-    const sourceCodeWithScope = sourceCode;
-    if (typeof sourceCodeWithScope.getScope === 'function') {
-        return sourceCodeWithScope.getScope(node) ?? context.getScope();
+    try {
+        const sourceCode = context.getSourceCode();
+        const sourceCodeWithScope = sourceCode;
+        if (typeof sourceCodeWithScope.getScope === 'function') {
+            return sourceCodeWithScope.getScope(node) ?? context.getScope();
+        }
+        return context.getScope();
+    }
+    catch {
+        return context.getScope();
     }
-    return context.getScope();
 };
 const getDeclaredVariablesForNode = (context, node) => {
-    const sourceCodeWithDeclaredVariables = context.getSourceCode();
-    if (typeof sourceCodeWithDeclaredVariables.getDeclaredVariables === 'function') {
-        return sourceCodeWithDeclaredVariables.getDeclaredVariables(node);
-    }
-    return context.getDeclaredVariables(node);
+    return ASTHelpers_1.ASTHelpers.getDeclaredVariables(context, node);
 };
 const isErrorKey = (key, computed) => {
     if (!computed && key.type === utils_1.AST_NODE_TYPES.Identifier) {

package/lib/rules/no-empty-dependency-use-callbacks.js

@@ -515,7 +515,7 @@ exports.noEmptyDependencyUseCallbacks = (0, createRule_1.createRule)({
             const callback = getCallbackArg(callExpression);
             if (!callback)
                 return;
-            if (ASTHelpers_1.ASTHelpers.returnsJSX(callback.body))
+            if (ASTHelpers_1.ASTHelpers.returnsJSX(callback.body, context))
                 return;
             const extraTypeRoots = [];
             if (callExpression.parent &&

package/lib/rules/no-entire-object-hook-deps.js

@@ -55,12 +55,23 @@ function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
         return false;
     }
 }
+function unwrapExpression(expr) {
+    let current = expr;
+    while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+        current.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+        current = current.expression;
+    }
+    return current;
+}
 function getObjectUsagesInHook(hookBody, objectName, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 context) {
     const usages = new Map(); // Track usage and its position
     const visited = new Set();
     let needsEntireObject = false;
+    let isUsed = false;
     // Built-in array methods that indicate usage of the entire array
     const ARRAY_METHODS = new Set([
         'map',
@@ -125,12 +136,12 @@ context) {
                 // For computed properties with variables (like user[key]), we need the entire object
                 if (memberExpr.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                     // Check if this is accessing our target object
-                    let current = memberExpr.object;
-                    while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                        current = current.object;
+                    let currentBase = unwrapExpression(memberExpr.object);
+                    while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        currentBase = unwrapExpression(currentBase.object);
                     }
-                    if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        current.name === objectName) {
+                    if (currentBase.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        currentBase.name === objectName) {
                         // This is a computed property access on our target object, so we need the entire object
                         needsEntireObject = true;
                     }
@@ -172,29 +183,29 @@ context) {
                     (ARRAY_METHODS.has(memberExpr.property.name) ||
                         STRING_METHODS.has(memberExpr.property.name))) {
                     // Check if this is accessing our target object or a property of it
-                    let current = memberExpr.object;
+                    let currentBase = unwrapExpression(memberExpr.object);
                     let pathParts = [];
-                    let hasOptionalChaining = false;
+                    let hasOptionalChainingInMethod = false;
                     // Build the path to the array/string being accessed
-                    while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                        const currentMember = current;
+                    while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        const currentMember = currentBase;
                         if (currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                             pathParts.unshift(currentMember.property.name);
                         }
                         if (currentMember.optional) {
-                            hasOptionalChaining = true;
+                            hasOptionalChainingInMethod = true;
                         }
-                        current = currentMember.object;
+                        currentBase = unwrapExpression(currentMember.object);
                     }
-                    if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        current.name === objectName) {
+                    if (currentBase.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        currentBase.name === objectName) {
                         if (pathParts.length === 0) {
                             // Direct method call on the object (e.g., userData.map(...))
                             needsEntireObject = true;
                         }
                         else {
                             // Method call on a property (e.g., userData.items.map(...) or userData?.items?.map(...))
-                            let path = objectName + (hasOptionalChaining ? '?' : '');
+                            let path = objectName + (hasOptionalChainingInMethod ? '?' : '');
                             path += '.' + pathParts.join('.');
                             usages.set(path, memberExpr.range?.[0] || 0);
                         }
@@ -206,11 +217,11 @@ context) {
             if (memberExpr.optional) {
                 hasOptionalChaining = true;
             }
-            current = memberExpr.object;
+            current = unwrapExpression(memberExpr.object);
         }
         // Check if we reached the target identifier
-        if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
-            current.name === objectName) {
+        const base = unwrapExpression(current);
+        if (base.type === utils_1.AST_NODE_TYPES.Identifier && base.name === objectName) {
             // Build the path with optional chaining
             let path = objectName + (hasOptionalChaining ? '?' : '');
             // Add each part with proper formatting (dot notation or bracket notation)
@@ -230,15 +241,74 @@ context) {
         if (!node || visited.has(node))
             return;
         visited.add(node);
+        if (node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === objectName) {
+            // Skip TS type assertions, ChainExpression and TSNonNullExpression wrappers
+            // (used around the Identifier) so we can attribute the Identifier's usage
+            // to its actual parent context (e.g., call/member/assignment) and avoid
+            // misclassifying the dependency when determining if the whole object is referenced.
+            let wrapperNode = node;
+            let effectiveParent = node.parent;
+            while (effectiveParent &&
+                (effectiveParent.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression)) {
+                wrapperNode = effectiveParent;
+                effectiveParent = effectiveParent.parent;
+            }
+            // Exclude: property name in `other.objectName` (not our target object)
+            const isMemberProperty = effectiveParent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                effectiveParent.property === wrapperNode &&
+                !effectiveParent.computed;
+            // Exclude: object in `objectName.prop` (handled by MemberExpression visitor for field tracking)
+            const isMemberObject = effectiveParent?.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                effectiveParent.object === wrapperNode;
+            // Exclude: key in `{ objectName: value }` (not usage, just a label)
+            // Include: shorthand `{ objectName }` (actual usage)
+            const isPropertyKey = effectiveParent?.type === utils_1.AST_NODE_TYPES.Property &&
+                effectiveParent.key === wrapperNode &&
+                !effectiveParent.computed &&
+                !effectiveParent.shorthand;
+            if (!isMemberProperty && !isMemberObject && !isPropertyKey) {
+                isUsed = true;
+                // Patterns that require the entire object (cannot refactor to specific fields)
+                const isTypeAUsage = effectiveParent?.type === utils_1.AST_NODE_TYPES.ReturnStatement ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.BinaryExpression ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.UnaryExpression ||
+                    (effectiveParent?.type === utils_1.AST_NODE_TYPES.Property &&
+                        (effectiveParent.value === wrapperNode ||
+                            effectiveParent.shorthand ||
+                            (effectiveParent.key === wrapperNode &&
+                                effectiveParent.computed))) ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.TemplateLiteral ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.AssignmentExpression ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.SpreadElement ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.ForInStatement ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.ForOfStatement ||
+                    effectiveParent?.type === utils_1.AST_NODE_TYPES.CallExpression;
+                if (isTypeAUsage) {
+                    needsEntireObject = true;
+                }
+            }
+        }
         if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
             // Check if the object is being called as a function
-            if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.callee.name === objectName) {
+            const callee = unwrapExpression(node.callee);
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.name === objectName) {
                 needsEntireObject = true;
             }
             // Check if the object is directly passed as an argument
             node.arguments.forEach((arg) => {
-                if (arg.type === utils_1.AST_NODE_TYPES.Identifier && arg.name === objectName) {
+                const unwrappedArg = unwrapExpression(arg);
+                if (unwrappedArg.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    unwrappedArg.name === objectName) {
                     needsEntireObject = true;
                 }
             });
@@ -248,18 +318,21 @@ context) {
             // If we find a JSX element, check its attributes for spread operator
             if (node.type === utils_1.AST_NODE_TYPES.JSXElement) {
                 node.openingElement.attributes.forEach((attr) => {
-                    if (attr.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute &&
-                        attr.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        attr.argument.name === objectName) {
-                        needsEntireObject = true;
+                    if (attr.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute) {
+                        const argument = unwrapExpression(attr.argument);
+                        if (argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            argument.name === objectName) {
+                            needsEntireObject = true;
+                        }
                     }
                 });
             }
         }
         else if (node.type === utils_1.AST_NODE_TYPES.SpreadElement) {
             // If we find a spread operator with our target object, consider it as accessing all properties
-            if (node.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.argument.name === objectName) {
+            const argument = unwrapExpression(node.argument);
+            if (argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                argument.name === objectName) {
                 needsEntireObject = true;
                 return;
             }
@@ -267,43 +340,51 @@ context) {
         else if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
             // Check if this is accessing a property of our target object
             const memberExpr = node;
-            // Only process if this is the outermost member expression in a chain
-            // (i.e., its parent is not also a member expression)
-            const parent = memberExpr.parent;
-            if (parent && parent.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                // This is an intermediate member expression, skip it
-                return;
+            // Skip TS type assertions, ChainExpression and TSNonNullExpression wrappers
+            // so we can attribute the MemberExpression's usage to its actual parent
+            // context and avoid misclassifying the dependency.
+            // We only process if this is the outermost member expression in a chain.
+            let effectiveParent = memberExpr.parent;
+            while (effectiveParent &&
+                (effectiveParent.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+                    effectiveParent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression)) {
+                effectiveParent = effectiveParent.parent;
             }
-            // Check if this member expression involves our target object
-            let current = memberExpr;
-            let foundTargetObject = false;
-            let hasDynamicComputed = false;
-            // Walk up the member expression chain to see if it involves our target object
-            while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                const currentMember = current;
-                // Check if this level uses dynamic computed property access
-                if (currentMember.computed &&
-                    currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    hasDynamicComputed = true;
+            const isIntermediate = effectiveParent && effectiveParent.type === utils_1.AST_NODE_TYPES.MemberExpression;
+            if (!isIntermediate) {
+                // Check if this member expression involves our target object
+                let current = memberExpr;
+                let foundTargetObject = false;
+                let hasDynamicComputed = false;
+                // Walk up the member expression chain to see if it involves our target object
+                while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    const currentMember = current;
+                    // Check if this level uses dynamic computed property access
+                    if (currentMember.computed &&
+                        currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        hasDynamicComputed = true;
+                    }
+                    current = unwrapExpression(currentMember.object);
                 }
-                current = currentMember.object;
-            }
-            // Check if we reached our target object
-            if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
-                current.name === objectName) {
-                foundTargetObject = true;
-            }
-            if (foundTargetObject) {
-                if (hasDynamicComputed) {
-                    // Dynamic computed property access means we need the entire object
-                    needsEntireObject = true;
-                    return;
+                // Check if we reached our target object
+                const base = unwrapExpression(current);
+                if (base.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    base.name === objectName) {
+                    foundTargetObject = true;
                 }
-                else {
-                    // Static property access - add to usages
-                    const path = buildAccessPath(memberExpr);
-                    if (path) {
-                        usages.set(path, memberExpr.range?.[0] || 0);
+                if (foundTargetObject) {
+                    if (hasDynamicComputed) {
+                        // Dynamic computed property access means we need the entire object
+                        needsEntireObject = true;
+                    }
+                    else {
+                        // Static property access - add to usages
+                        const path = buildAccessPath(memberExpr);
+                        if (path) {
+                            usages.set(path, memberExpr.range?.[0] || 0);
+                        }
                     }
                 }
             }
@@ -431,7 +512,7 @@ context) {
         return posA - posB;
     });
     const filteredUsages = new Set(sortedPaths);
-    const notUsed = !needsEntireObject && filteredUsages.size === 0;
+    const notUsed = !needsEntireObject && !isUsed && filteredUsages.size === 0;
     return {
         usages: filteredUsages,
         needsEntireObject,
@@ -486,16 +567,17 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                 }
                 // Check each dependency in the array
                 depsArg.elements.forEach((element) => {
-                    if (!element)
+                    const unwrappedElement = element ? unwrapExpression(element) : null;
+                    if (!unwrappedElement)
                         return; // Skip null elements (holes in the array)
-                    if (element.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const objectName = element.name;
+                    if (unwrappedElement.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const objectName = unwrappedElement.name;
                         // Skip type checking if we don't have TypeScript services
                         if (hasFullTypeChecking && parserServices) {
                             const checker = parserServices.program.getTypeChecker();
                             const nodeMap = parserServices.esTreeNodeToTSNodeMap;
                             // Skip if the dependency is an array or primitive type
-                            if (isArrayOrPrimitive(checker, element, nodeMap)) {
+                            if (isArrayOrPrimitive(checker, unwrappedElement, nodeMap)) {
                                 return;
                             }
                         }

package/lib/rules/no-excessive-parent-chain.js

@@ -260,6 +260,9 @@ exports.noExcessiveParentChain = (0, createRule_1.createRule)({
                     suggest: [
                         {
                             messageId: 'excessiveParentChain',
+                            data: {
+                                count: parentCount,
+                            },
                             fix(fixer) {
                                 return fixer.replaceText(node, 'event.params');
                             },

package/lib/rules/no-explicit-return-type.js

@@ -225,6 +225,12 @@ function isTypeGuardFunction(node) {
     // Check for type predicates (is keyword)
     if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypePredicate)
         return true;
+    // `never` is never inferred: TypeScript infers `void` for a function whose
+    // every path throws, so an explicit `: never` always carries more information
+    // than inference (callers rely on it for control-flow narrowing and
+    // exhaustiveness). Removing it would silently widen the type to `void`.
+    if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSNeverKeyword)
+        return true;
     // Check for assertion functions (asserts keyword)
     if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
         const typeName = typeAnnotation.typeName;