@blumintinc/eslint-plugin-blumint 1.14.0 → 1.16.0

package/lib/rules/prefer-nullish-coalescing-boolean-props.js

@@ -1,9 +1,73 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferNullishCoalescingBooleanProps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const ts = __importStar(require("typescript"));
 const createRule_1 = require("../utils/createRule");
 const BOOLEAN_PROP_REGEX = /^(is|has|should|can|will|do|does|did|was|were|enable|disable)/;
+function isBooleanType(type, checker) {
+    if (type.isUnion()) {
+        return type.types.every((t) => isBooleanType(t, checker));
+    }
+    // For type parameters, check if the constraint is a boolean type
+    if (type.getFlags() & ts.TypeFlags.TypeParameter) {
+        if (checker) {
+            const constraint = checker.getBaseConstraintOfType(type);
+            if (constraint && constraint !== type) {
+                return isBooleanType(constraint, checker);
+            }
+        }
+        return false;
+    }
+    return ((type.getFlags() & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral)) !==
+        0);
+}
+function isPossiblyNullish(type, checker) {
+    if (type.isUnion()) {
+        return type.types.some((t) => isPossiblyNullish(t, checker));
+    }
+    // For type parameters, check if the constraint excludes nullish
+    if (type.getFlags() & ts.TypeFlags.TypeParameter) {
+        if (checker) {
+            const constraint = checker.getBaseConstraintOfType(type);
+            if (constraint && constraint !== type) {
+                return isPossiblyNullish(constraint, checker);
+            }
+        }
+        // If we can't determine the constraint, assume it could be nullish
+        return true;
+    }
+    return ((type.getFlags() &
+        (ts.TypeFlags.Null |
+            ts.TypeFlags.Undefined |
+            ts.TypeFlags.Void |
+            ts.TypeFlags.Any |
+            ts.TypeFlags.Unknown)) !==
+        0);
+}
 function isInJSXBooleanAttribute(node) {
     const parent = node.parent;
     if (parent?.type !== utils_1.AST_NODE_TYPES.JSXAttribute)
@@ -57,7 +121,34 @@ function isInConditionalContext(node) {
 /**
  * Determines if a node is within a boolean context in JSX props or other boolean contexts
  */
-function isInBooleanContext(node) {
+function isInBooleanContext(node, checker, parserServices) {
+    if (checker && parserServices) {
+        try {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const contextualType = checker.getContextualType(tsNode);
+            if (contextualType && isBooleanType(contextualType, checker)) {
+                return true;
+            }
+            // Also check if the expression itself is a boolean type
+            const actualType = checker.getTypeAtLocation(tsNode);
+            if (actualType && isBooleanType(actualType, checker)) {
+                return true;
+            }
+            // If this is a logical expression, also check if the left operand is a boolean
+            if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+                const leftTSNode = parserServices.esTreeNodeToTSNodeMap.get(node.left);
+                const leftType = checker.getTypeAtLocation(leftTSNode);
+                if (leftType && isBooleanType(leftType, checker)) {
+                    return true;
+                }
+            }
+        }
+        catch {
+            // esTreeNodeToTSNodeMap may fail for synthetic nodes or nodes without
+            // source positions; getContextualType may return undefined for non-expression
+            // contexts. Fall back to AST-based heuristics in these cases.
+        }
+    }
     let current = node;
     // Traverse up the AST to find if we're in a boolean context
     while (current && current.parent) {
@@ -365,7 +456,19 @@ function isInBooleanContext(node) {
 /**
  * Checks if the left operand could be nullish (null or undefined)
  */
-function couldBeNullish(node) {
+function couldBeNullish(node, checker, parserServices) {
+    if (checker && parserServices) {
+        try {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            return isPossiblyNullish(type, checker);
+        }
+        catch {
+            // esTreeNodeToTSNodeMap may fail for synthetic nodes or nodes without
+            // source positions; getTypeAtLocation may throw for nodes without
+            // type information. Fall back to manual check.
+        }
+    }
     // For literals, check the actual value
     if (node.type === utils_1.AST_NODE_TYPES.Literal) {
         return node.value === null || node.value === undefined;
@@ -402,16 +505,18 @@ exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const parserServices = utils_1.ESLintUtils.getParserServices(context, true);
+        const checker = parserServices?.program?.getTypeChecker();
         return {
             LogicalExpression(node) {
                 if (node.operator === '||') {
                     // If the node is in a boolean context, we allow logical OR
-                    if (isInBooleanContext(node)) {
+                    if (isInBooleanContext(node, checker, parserServices)) {
                         return;
                     }
                     // Check if this could benefit from nullish coalescing
                     // We only suggest nullish coalescing when the left operand could be nullish
-                    if (couldBeNullish(node.left)) {
+                    if (couldBeNullish(node.left, checker, parserServices)) {
                         const sourceCode = context.getSourceCode();
                         const leftText = sourceCode.getText(node.left);
                         const rightText = sourceCode.getText(node.right);

package/lib/rules/prefer-params-over-parent-id.js

@@ -202,7 +202,7 @@ exports.preferParamsOverParentId = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer handler params for parent IDs instead of traversing ref.parent.id so Firebase triggers stay aligned with path templates and type-safe.',
+            description: 'Prefer event.params over ref.parent.id for type-safe Firebase trigger paths.',
             recommended: 'error',
         },
         fixable: 'code',

package/lib/rules/prefer-settings-object.js

@@ -47,6 +47,7 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
     defaultOptions: [defaultOptions],
     create(context, [options]) {
         const finalOptions = { ...defaultOptions, ...options };
+        const { sourceCode } = context;
         function getParameterType(param) {
             if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
                 return getParameterType(param.left);
@@ -56,13 +57,10 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 const typeNode = param.typeAnnotation.typeAnnotation;
                 if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
                     // Include type parameters in the type signature to differentiate generic types
-                    const typeName = typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
-                        ? typeNode.typeName.name
-                        : 'unknown';
+                    const typeName = sourceCode.getText(typeNode.typeName);
                     // If there are type parameters, include them in the type signature
                     if (typeNode.typeParameters &&
                         typeNode.typeParameters.params.length > 0) {
-                        const sourceCode = context.sourceCode;
                         const typeParams = typeNode.typeParameters.params
                             .map((param) => sourceCode.getText(param))
                             .join(', ');
@@ -76,13 +74,10 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 const typeNode = param.typeAnnotation.typeAnnotation;
                 if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
                     // Include type parameters in the type signature to differentiate generic types
-                    const typeName = typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
-                        ? typeNode.typeName.name
-                        : 'unknown';
+                    const typeName = sourceCode.getText(typeNode.typeName);
                     // If there are type parameters, include them in the type signature
                     if (typeNode.typeParameters &&
                         typeNode.typeParameters.params.length > 0) {
-                        const sourceCode = context.sourceCode;
                         const typeParams = typeNode.typeParameters.params
                             .map((param) => sourceCode.getText(param))
                             .join(', ');
@@ -98,12 +93,14 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                     return 'boolean';
                 return typeNode.type;
             }
-            return 'unknown';
+            return null;
         }
         function findDuplicateParameterType(params) {
             const typeMap = new Map();
             for (const param of params) {
                 const type = getParameterType(param);
+                if (type === null)
+                    continue;
                 const count = (typeMap.get(type) || 0) + 1;
                 typeMap.set(type, count);
                 if (count > 1) {
@@ -248,6 +245,24 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
             }
             return false;
         }
+        function hasImplicitlyTypedParams(params) {
+            return params.some((param) => {
+                let current = param;
+                if (current.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+                    current = current.parameter;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                    current = current.left;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.Identifier ||
+                    current.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrayPattern ||
+                    current.type === utils_1.AST_NODE_TYPES.RestElement) {
+                    return !current.typeAnnotation;
+                }
+                return true;
+            });
+        }
         function shouldIgnoreNode(node) {
             // Ignore built-in objects and third-party modules
             if (isBuiltInOrThirdParty(node))
@@ -270,7 +285,7 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                     parent = parent.parent;
                 }
             }
-            // Ignore functions with A/B pattern parameters
+            // Ignore functions with A/B pattern parameters or missing type annotations
             if ((node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
                 node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
                 node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
@@ -279,6 +294,8 @@ exports.preferSettingsObject = (0, createRule_1.createRule)({
                 Array.isArray(node.params)) {
                 if (hasABPattern(node.params))
                     return true;
+                if (hasImplicitlyTypedParams(node.params))
+                    return true;
             }
             // Check if the function is a handler with transaction parameter
             // This is a common pattern in Firebase/Firestore handlers

package/lib/rules/prefer-type-alias-over-typeof-constant.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferTypeAliasOverTypeofConstant = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const PAREN_TYPE = utils_1.AST_NODE_TYPES.TSParenthesizedType ??
     'TSParenthesizedType';
 const isParenthesizedType = (node) => {
@@ -87,6 +88,71 @@ function collectReferencedTypeNames(node, acc = new Set()) {
                 collectReferencedTypeNames(e, acc);
             break;
         }
+        case utils_1.AST_NODE_TYPES.TSIndexedAccessType: {
+            const idx = node;
+            collectReferencedTypeNames(idx.objectType, acc);
+            collectReferencedTypeNames(idx.indexType, acc);
+            break;
+        }
+        case utils_1.AST_NODE_TYPES.TSMappedType: {
+            const mapped = node;
+            if (mapped.typeAnnotation)
+                collectReferencedTypeNames(mapped.typeAnnotation, acc);
+            if (mapped.nameType)
+                collectReferencedTypeNames(mapped.nameType, acc);
+            if (mapped.typeParameter && mapped.typeParameter.constraint) {
+                collectReferencedTypeNames(mapped.typeParameter.constraint, acc);
+            }
+            break;
+        }
+        case utils_1.AST_NODE_TYPES.TSConditionalType: {
+            const cond = node;
+            collectReferencedTypeNames(cond.checkType, acc);
+            collectReferencedTypeNames(cond.extendsType, acc);
+            collectReferencedTypeNames(cond.trueType, acc);
+            collectReferencedTypeNames(cond.falseType, acc);
+            break;
+        }
+        case utils_1.AST_NODE_TYPES.TSTypeLiteral: {
+            const lit = node;
+            for (const m of lit.members) {
+                if (m.type === utils_1.AST_NODE_TYPES.TSPropertySignature && m.typeAnnotation) {
+                    collectReferencedTypeNames(m.typeAnnotation.typeAnnotation, acc);
+                }
+                else if (m.type === utils_1.AST_NODE_TYPES.TSMethodSignature) {
+                    if (m.returnType) {
+                        collectReferencedTypeNames(m.returnType.typeAnnotation, acc);
+                    }
+                    for (const p of m.params) {
+                        if (p.typeAnnotation) {
+                            collectReferencedTypeNames(p.typeAnnotation.typeAnnotation, acc);
+                        }
+                    }
+                }
+                else if (m.type === utils_1.AST_NODE_TYPES.TSIndexSignature) {
+                    if (m.typeAnnotation) {
+                        collectReferencedTypeNames(m.typeAnnotation.typeAnnotation, acc);
+                    }
+                    for (const p of m.parameters) {
+                        if (p.typeAnnotation) {
+                            collectReferencedTypeNames(p.typeAnnotation.typeAnnotation, acc);
+                        }
+                    }
+                }
+                else if (m.type === utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration ||
+                    m.type === utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration) {
+                    if (m.returnType) {
+                        collectReferencedTypeNames(m.returnType.typeAnnotation, acc);
+                    }
+                    for (const p of m.params) {
+                        if (p.typeAnnotation) {
+                            collectReferencedTypeNames(p.typeAnnotation.typeAnnotation, acc);
+                        }
+                    }
+                }
+            }
+            break;
+        }
         default: {
             if (isParenthesizedType(node)) {
                 collectReferencedTypeNames(node.typeAnnotation, acc);
@@ -225,10 +291,15 @@ exports.preferTypeAliasOverTypeofConstant = (0, createRule_1.createRule)({
             TSTypeQuery(node) {
                 if (!collected)
                     return;
-                // Skip `keyof typeof X`
-                if (node.parent &&
-                    node.parent.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
-                    node.parent.operator === 'keyof') {
+                const ancestors = ASTHelpers_1.ASTHelpers.getAncestors(context, node);
+                // Skip if inside a type alias declaration (Issue #1117, #1175)
+                // This allows 'type T = typeof CONST' as the canonical way to define the alias.
+                if (ancestors.some((a) => a.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration)) {
+                    return;
+                }
+                // Skip `keyof typeof X` as it's a canonical way to derive a union of keys from a constant object.
+                if (ancestors.some((a) => a.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                    a.operator === 'keyof')) {
                     return;
                 }
                 if (node.exprName.type !== utils_1.AST_NODE_TYPES.Identifier) {

package/lib/rules/prefer-use-deep-compare-memo.js

@@ -60,8 +60,6 @@ function isNonPrimitiveWithoutTypes(expr) {
     switch (expr.type) {
         case utils_1.AST_NODE_TYPES.ArrayExpression:
         case utils_1.AST_NODE_TYPES.ObjectExpression:
-        case utils_1.AST_NODE_TYPES.FunctionExpression:
-        case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
         case utils_1.AST_NODE_TYPES.NewExpression:
         case utils_1.AST_NODE_TYPES.ClassExpression:
             return true;
@@ -74,6 +72,8 @@ function isNonPrimitiveWithoutTypes(expr) {
         case utils_1.AST_NODE_TYPES.MemberExpression:
         case utils_1.AST_NODE_TYPES.ChainExpression:
         case utils_1.AST_NODE_TYPES.CallExpression:
+        case utils_1.AST_NODE_TYPES.FunctionExpression:
+        case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
         default:
             return false;
     }
@@ -92,9 +92,9 @@ function isNonPrimitiveWithTypes(context, expr) {
         if (!tsNode)
             return false;
         const type = checker.getTypeAtLocation(tsNode);
-        // Only consider explicit functions as non-primitive here
+        // Explicitly ignore functions even though they are non-primitive
         if (type.getCallSignatures().length > 0)
-            return true;
+            return false;
         // Avoid guessing for unknown/any or non-function types
         if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown))
             return false;
@@ -243,7 +243,7 @@ function isImportedIdentifier(context, name) {
     }
     return false;
 }
-function identifierUsedAsObjectOrFunction(callback, name) {
+function identifierUsedAsObjectOrArray(callback, name) {
     const stack = [callback.body];
     while (stack.length) {
         const node = stack.pop();
@@ -268,12 +268,6 @@ function identifierUsedAsObjectOrFunction(callback, name) {
                 }
             }
         }
-        if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
-            const callee = node.callee;
-            if (callee.type === utils_1.AST_NODE_TYPES.Identifier && callee.name === name) {
-                return true; // function usage
-            }
-        }
         if (node.type === utils_1.AST_NODE_TYPES.JSXSpreadAttribute) {
             if (node.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
                 node.argument.name === name) {
@@ -313,13 +307,13 @@ exports.preferUseDeepCompareMemo = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce using useDeepCompareMemo when dependency array contains non-primitive values (objects, arrays, functions) that are not already memoized. This prevents unnecessary re-renders due to reference changes.',
+            description: 'Enforce using useDeepCompareMemo when dependency array contains non-primitive values (objects, arrays) that are not already memoized. This prevents unnecessary re-renders due to reference changes.',
             recommended: 'error',
         },
         fixable: 'code',
         schema: [],
         messages: {
-            preferUseDeepCompareMemo: 'Dependency array for "{{hook}}" includes objects/arrays/functions that change identity each render, so React treats them as changed and reruns the memoized computation, triggering avoidable renders. Use useDeepCompareMemo (or memoize those dependencies first) so comparisons use deep equality and the memo stays stable.',
+            preferUseDeepCompareMemo: 'Dependency array for "{{hook}}" includes objects/arrays that change identity each render, so React treats them as changed and reruns the memoized computation, triggering avoidable renders. Use useDeepCompareMemo (or memoize those dependencies first) so comparisons use deep equality and the memo stays stable.',
         },
     },
     defaultOptions: [],
@@ -366,7 +360,7 @@ exports.preferUseDeepCompareMemo = (0, createRule_1.createRule)({
                         if (isImportedIdentifier(context, expr.name)) {
                             isNonPrimitive = false;
                         }
-                        else if (identifierUsedAsObjectOrFunction(callback, expr.name) &&
+                        else if (identifierUsedAsObjectOrArray(callback, expr.name) &&
                             !isIdentifierMemoizedAbove(expr.name, memoizedIds)) {
                             isNonPrimitive = true;
                         }

package/lib/rules/prefer-usememo-over-useeffect-usestate.js

@@ -11,7 +11,7 @@ exports.preferUseMemoOverUseEffectUseState = (0, createRule_1.createRule)({
             recommended: 'error',
         },
         messages: {
-            preferUseMemo: 'Derived state "{{stateName}}" is computed inside useEffect and copied into React state even though the value comes from a pure calculation. That extra render cycle and state indirection make components re-render more and risk stale snapshots when dependencies change. Compute the value with useMemo (or inline in render) and read it directly instead of mirroring it into state.',
+            preferUseMemo: 'Use useMemo to compute derived state "{{stateName}}" instead of useEffect + useState to avoid extra render cycles and stale snapshots.',
         },
         schema: [],
     },

package/lib/rules/prevent-children-clobber.js

@@ -44,12 +44,12 @@ function resolveFunctionName(node) {
     }
     return null;
 }
-function isComponentLike(node) {
+function isComponentLike(node, context) {
     const name = resolveFunctionName(node);
     if (name && /^[A-Z]/.test(name)) {
         return true;
     }
-    return ASTHelpers_1.ASTHelpers.returnsJSX(node.body);
+    return ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context);
 }
 function patternHasChildrenProperty(pattern) {
     return pattern.properties.some((prop) => {
@@ -266,7 +266,8 @@ function bindingMayContainChildren(binding, context) {
         return false;
     if (binding.typeAnnotationExcludesProperty)
         return false;
-    const services = context.sourceCode?.parserServices ?? context.parserServices;
+    const services = context.sourceCode?.parserServices ??
+        context.parserServices;
     if (!services?.program || !services?.esTreeNodeToTSNodeMap) {
         return true;
     }
@@ -410,7 +411,7 @@ exports.preventChildrenClobber = (0, createRule_1.createRule)({
         return {
             ':function'(node) {
                 const ctx = {
-                    isComponent: isComponentLike(node),
+                    isComponent: isComponentLike(node, context),
                     bindings: new Map(),
                     propsLikeIdentifiers: new Set(),
                     childrenValueSourceIds: new Map(),
@@ -510,7 +511,10 @@ exports.preventChildrenClobber = (0, createRule_1.createRule)({
                     if (!bindingMayContainChildren(binding, context)) {
                         continue;
                     }
-                    offendingSpreads.push({ name, childrenSourceId: binding.childrenSourceId });
+                    offendingSpreads.push({
+                        name,
+                        childrenSourceId: binding.childrenSourceId,
+                    });
                 }
                 if (offendingSpreads.length === 0)
                     return;