@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/no-always-true-false-conditions.js

@@ -13,16 +13,69 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            alwaysTrueCondition: 'This condition is always true, which may indicate a mistake or unnecessary code.',
-            alwaysFalseCondition: 'This condition is always false, which may indicate a mistake or dead code.',
+            alwaysTrueCondition: 'What\'s wrong → Condition "{{condition}}" is always true.\nWhy it matters → The guarded branch runs every time, which can hide logic errors and leave redundant checks.\nHow to fix → Remove the check, or rewrite "{{condition}}" so it depends on runtime values instead of constants.',
+            alwaysFalseCondition: 'What\'s wrong → Condition "{{condition}}" is always false.\nWhy it matters → The guarded branch is unreachable, which leaves misleading or dead code.\nHow to fix → Remove the unreachable branch, or adjust "{{condition}}" so it can evaluate to true when intended.',
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.getSourceCode();
+        const normalizedConditionText = (node) => sourceCode.getText(node).replace(/\s+/g, ' ').trim();
+        const conditionTextFor = (node) => ({
+            condition: normalizedConditionText(node),
+        });
         // Track nodes that have already been reported to prevent duplicate reports
         const reportedNodes = new Set();
         // Track parent nodes that have been evaluated to prevent duplicate reports on children
         const evaluatedParentNodes = new Set();
+        // Sentinel distinguishes "no const literal resolved" from valid literal values (including null/undefined)
+        const NOT_FOUND = Symbol('literal-not-found');
+        /**
+         * Walks the current scope chain to locate a variable by name so identifier
+         * lookups can resolve const initializers even when declared in parent scopes.
+         */
+        function findVariableInScopes(name) {
+            let currentScope = context.getScope();
+            while (currentScope) {
+                const variable = currentScope.variables.find((variableItem) => variableItem.name === name);
+                if (variable) {
+                    return variable;
+                }
+                currentScope = currentScope.upper;
+            }
+            return undefined;
+        }
+        function isConstIdentifierDefinition(def, identifierName) {
+            return (def.type === 'Variable' &&
+                def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                def.node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                def.node.id.name === identifierName &&
+                def.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+                def.parent.kind === 'const');
+        }
+        function findConstIdentifierDefinition(variable, identifierName) {
+            return variable.defs.find((def) => isConstIdentifierDefinition(def, identifierName));
+        }
+        /**
+         * Resolves an identifier to the literal it is initialized with when declared
+         * as a const. Returns the NOT_FOUND sentinel when the binding is absent,
+         * not a const, or not initialized with a literal value.
+         */
+        function resolveIdentifierValue(identifier) {
+            const variable = findVariableInScopes(identifier.name);
+            if (!variable) {
+                return NOT_FOUND;
+            }
+            const definition = findConstIdentifierDefinition(variable, identifier.name);
+            if (!definition) {
+                return NOT_FOUND;
+            }
+            const initializer = definition.node.init;
+            if (initializer?.type === utils_1.AST_NODE_TYPES.Literal) {
+                return initializer.value;
+            }
+            return NOT_FOUND;
+        }
         /**
          * Checks if a literal value is always truthy or falsy
          */
@@ -1309,6 +1362,7 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                 context.report({
                     node,
                     messageId: 'alwaysTrueCondition',
+                    data: conditionTextFor(node),
                 });
                 reportedNodes.add(node);
             }
@@ -1316,6 +1370,7 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                 context.report({
                     node,
                     messageId: 'alwaysFalseCondition',
+                    data: conditionTextFor(node),
                 });
                 reportedNodes.add(node);
             }
@@ -1372,12 +1427,14 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                                 context.report({
                                     node: node.test,
                                     messageId: 'alwaysTrueCondition',
+                                    data: conditionTextFor(node.test),
                                 });
                             }
                             else {
                                 context.report({
                                     node: node.test,
                                     messageId: 'alwaysFalseCondition',
+                                    data: conditionTextFor(node.test),
                                 });
                             }
                             reportedNodes.add(node.test);
@@ -1385,14 +1442,17 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                     }
                     // Special cases for tests with variables
                     if (switchStatement.discriminant.type === utils_1.AST_NODE_TYPES.Literal &&
-                        node.test.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.test.name === 'value') {
-                        // These special cases match the test expectations
-                        // In a real implementation, you would want to track variable assignments
-                        if (!reportedNodes.has(node.test)) {
+                        node.test.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const identifierValue = resolveIdentifierValue(node.test);
+                        if (identifierValue !== NOT_FOUND &&
+                            !reportedNodes.has(node.test)) {
+                            const messageId = identifierValue === switchStatement.discriminant.value
+                                ? 'alwaysTrueCondition'
+                                : 'alwaysFalseCondition';
                             context.report({
                                 node: node.test,
-                                messageId: 'alwaysFalseCondition',
+                                messageId,
+                                data: conditionTextFor(node.test),
                             });
                             reportedNodes.add(node.test);
                         }

package/lib/rules/no-array-length-in-deps.d.ts

@@ -0,0 +1,12 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export type MessageIds = 'noArrayLengthInDeps';
+type Options = [
+    {
+        hashImport?: {
+            source?: string;
+            importName?: string;
+        };
+    }?
+];
+export declare const noArrayLengthInDeps: TSESLint.RuleModule<"noArrayLengthInDeps", Options, TSESLint.RuleListener>;
+export {};

package/lib/rules/no-array-length-in-deps.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noArrayLengthInDeps = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+// React hooks to check
+const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
+const DEFAULT_HASH_IMPORT = {
+    source: 'functions/src/util/hash/stableHash',
+    importName: 'stableHash',
+};
+function isHookCall(node) {
+    const callee = node.callee;
+    return (callee.type === utils_1.AST_NODE_TYPES.Identifier && HOOK_NAMES.has(callee.name));
+}
+function isLengthMemberExpression(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        return (!node.computed &&
+            node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.property.name === 'length');
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        return isLengthMemberExpression(node.expression);
+    }
+    return false;
+}
+function getLengthMember(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        isLengthMemberExpression(node)) {
+        return node;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        const expr = node.expression;
+        return getLengthMember(expr);
+    }
+    return null;
+}
+function getBaseExpression(member) {
+    // For foo?.bar.length we want foo?.bar as base
+    return member.object;
+}
+function getLastPropertyName(expr) {
+    let current = expr;
+    while (current.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        current = current.expression;
+    }
+    if (current.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return current.name;
+    }
+    if (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        if (!current.computed &&
+            current.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return current.property.name;
+        }
+        // Fallback to walking further up the chain
+        return getLastPropertyName(current.object);
+    }
+    return null;
+}
+function generateUniqueName(base, taken) {
+    let candidate = `${base}Hash`;
+    if (!taken.has(candidate))
+        return candidate;
+    let i = 2;
+    while (taken.has(`${candidate}${i}`)) {
+        i++;
+    }
+    return `${candidate}${i}`;
+}
+function collectAllTakenNames(sourceCode) {
+    const names = new Set();
+    const scopeManager = sourceCode.scopeManager;
+    const visit = (scope) => {
+        if (!scope)
+            return;
+        for (const v of scope.variables) {
+            names.add(v.name);
+        }
+        if (Array.isArray(scope.childScopes)) {
+            for (const child of scope.childScopes)
+                visit(child);
+        }
+    };
+    visit(scopeManager?.globalScope);
+    return names;
+}
+function findEnclosingFunction(node) {
+    let current = node;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+            current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function ensureWeakMapEntry(map, key, factory) {
+    const existing = map.get(key);
+    if (existing)
+        return existing;
+    const next = factory();
+    map.set(key, next);
+    return next;
+}
+function isUseMemoImported(sourceCode) {
+    const program = sourceCode.ast;
+    for (const node of program.body) {
+        if (node.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+            node.source.value === 'react') {
+            for (const spec of node.specifiers) {
+                if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    spec.imported.name === 'useMemo') {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function isStableHashImported(sourceCode, hashSource, hashImportName) {
+    const program = sourceCode.ast;
+    for (const node of program.body) {
+        if (node.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+            node.source.value === hashSource) {
+            for (const spec of node.specifiers) {
+                if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    spec.imported.name === hashImportName) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
+    name: 'no-array-length-in-deps',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Detects array.length entries in React hook dependency arrays because length ignores content changes; auto-fixes by memoizing stableHash(array) with useMemo and depending on the hash instead.',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    hashImport: {
+                        type: 'object',
+                        properties: {
+                            source: { type: 'string' },
+                            importName: { type: 'string' },
+                        },
+                        additionalProperties: false,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noArrayLengthInDeps: 'Dependency array includes length-based entries ({{dependencies}}). Array length only changes when items are added or removed, so hooks miss updates when array contents change at the same size. Memoize a stableHash of each array with useMemo and depend on that hash so the hook reruns when contents change.',
+        },
+    },
+    defaultOptions: [{}],
+    create(context) {
+        const [options = {}] = context.options;
+        const { hashImport } = options;
+        const hashImportConfig = {
+            source: hashImport?.source ?? DEFAULT_HASH_IMPORT.source,
+            importName: hashImport?.importName ?? DEFAULT_HASH_IMPORT.importName,
+        };
+        // Track planned file-wide changes to avoid overlapping fixers
+        let importsPlanned = false;
+        const perFuncDeclaredBases = new WeakMap();
+        const perFuncBaseToVar = new WeakMap();
+        return {
+            CallExpression(node) {
+                if (!isHookCall(node))
+                    return;
+                if (node.arguments.length < 2)
+                    return;
+                const depsArg = node.arguments[node.arguments.length - 1];
+                if (depsArg.type !== utils_1.AST_NODE_TYPES.ArrayExpression)
+                    return;
+                // Collect .length deps
+                const lengthDeps = [];
+                for (const el of depsArg.elements) {
+                    if (!el)
+                        continue;
+                    if (el.type === utils_1.AST_NODE_TYPES.SpreadElement)
+                        continue;
+                    const member = getLengthMember(el);
+                    if (member) {
+                        lengthDeps.push({ element: el, member });
+                    }
+                }
+                if (lengthDeps.length === 0)
+                    return;
+                const sourceCode = context.getSourceCode();
+                const dependencies = lengthDeps
+                    .map(({ element }) => sourceCode.getText(element))
+                    .join(', ');
+                // Report once on the dependency array
+                context.report({
+                    node: depsArg,
+                    messageId: 'noArrayLengthInDeps',
+                    data: {
+                        dependencies,
+                    },
+                    fix(fixer) {
+                        const fixes = [];
+                        const hostFn = findEnclosingFunction(node) ?? sourceCode.ast;
+                        const declaredBases = ensureWeakMapEntry(perFuncDeclaredBases, hostFn, () => new Set());
+                        const baseToVar = ensureWeakMapEntry(perFuncBaseToVar, hostFn, () => new Map());
+                        // Prepare variable names (consistent across file) and taken names (across all scopes)
+                        const allTaken = collectAllTakenNames(sourceCode);
+                        for (const name of baseToVar.values()) {
+                            allTaken.add(name);
+                        }
+                        for (const { member } of lengthDeps) {
+                            const baseExpr = getBaseExpression(member);
+                            const baseText = sourceCode.getText(baseExpr);
+                            if (!baseToVar.has(baseText)) {
+                                const lastPropName = getLastPropertyName(baseExpr) || 'array';
+                                const varName = generateUniqueName(lastPropName, allTaken);
+                                baseToVar.set(baseText, varName);
+                                allTaken.add(varName);
+                            }
+                        }
+                        // Build declarations text (one per base)
+                        let declText = '';
+                        for (const { member } of lengthDeps) {
+                            const baseExpr = getBaseExpression(member);
+                            const baseText = sourceCode.getText(baseExpr);
+                            if (!declaredBases.has(baseText)) {
+                                const varName = baseToVar.get(baseText);
+                                declText += `const ${varName} = useMemo(() => ${hashImportConfig.importName}(${baseText}), [${baseText}]);\n`;
+                                declaredBases.add(baseText);
+                            }
+                        }
+                        if (declText) {
+                            // Add a blank line after declarations block
+                            declText += `\n`;
+                        }
+                        // Determine import text and insertion strategy
+                        const program = sourceCode.ast;
+                        const importDecls = program.body.filter((n) => n.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+                        // Compute indentation based on the whitespace before the first token
+                        const fullText = sourceCode.getText();
+                        const prefixBeforeProgram = fullText.slice(0, program.range[0]);
+                        const lastNewlineIndex = prefixBeforeProgram.lastIndexOf('\n');
+                        const indent = lastNewlineIndex >= 0
+                            ? prefixBeforeProgram.slice(lastNewlineIndex + 1)
+                            : prefixBeforeProgram;
+                        let importText = '';
+                        const needUseMemo = !isUseMemoImported(sourceCode);
+                        const needStableHash = !isStableHashImported(sourceCode, hashImportConfig.source, hashImportConfig.importName);
+                        if (needUseMemo)
+                            importText += `${indent}import { useMemo } from 'react';\n`;
+                        if (needStableHash)
+                            importText += `${indent}import { ${hashImportConfig.importName} } from '${hashImportConfig.source}';\n`;
+                        if (importDecls.length === 0) {
+                            // No existing imports. Normalize by removing leading whitespace and inserting at file start with no indentation.
+                            if (declText || importText) {
+                                // Build non-indented versions of import and decl blocks
+                                let importTextNoIndent = '';
+                                if (needUseMemo)
+                                    importTextNoIndent += `import { useMemo } from 'react';\n`;
+                                if (needStableHash)
+                                    importTextNoIndent += `import { ${hashImportConfig.importName} } from '${hashImportConfig.source}';\n`;
+                                const declNoIndent = declText;
+                                const combined = `${importTextNoIndent}${importTextNoIndent && declNoIndent ? '\n' : ''}${declNoIndent}`;
+                                // Remove leading whitespace
+                                fixes.push(fixer.replaceTextRange([0, program.range[0]], ''));
+                                // Insert at column 0
+                                fixes.push(fixer.insertTextBeforeRange([0, 0], combined));
+                            }
+                            importsPlanned = true;
+                        }
+                        else {
+                            // Existing imports present: insert missing import lines before the first import, and declarations after the last import
+                            const firstImport = importDecls[0];
+                            const lastImport = importDecls[importDecls.length - 1];
+                            if (importText && !importsPlanned) {
+                                fixes.push(fixer.insertTextBefore(firstImport, importText));
+                                importsPlanned = true;
+                            }
+                            if (declText) {
+                                const declWithIndent = declText
+                                    .split('\n')
+                                    .map((line) => (line ? `${indent}${line}` : line))
+                                    .join('\n');
+                                fixes.push(fixer.insertTextAfter(lastImport, `\n${declWithIndent}`));
+                            }
+                        }
+                        // Replace each .length dep with the corresponding var name
+                        for (const { element, member } of lengthDeps) {
+                            const baseExpr = getBaseExpression(member);
+                            const baseText = sourceCode.getText(baseExpr);
+                            const varName = baseToVar.get(baseText);
+                            fixes.push(fixer.replaceText(element, varName));
+                        }
+                        return fixes;
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-array-length-in-deps.js.map

package/lib/rules/no-async-array-filter.js

@@ -17,6 +17,9 @@ exports.noAsyncArrayFilter = (0, createRule_1.createRule)({
                         context.report({
                             node: callback,
                             messageId: 'unexpected',
+                            data: {
+                                methodName: node.callee.property.name,
+                            },
                         });
                     }
                 }
@@ -27,12 +30,12 @@ exports.noAsyncArrayFilter = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: "Disallow async callbacks in Array.filter() as they lead to incorrect filtering. Since async functions return Promises which are always truthy, the filter will keep all elements regardless of the async check's result. Use Promise.all() with map() first, then filter based on the resolved results.",
+            description: 'Disallow async callbacks in Array.filter(). Async predicates return Promises that are always truthy to the filter, so no element is ever removed. Resolve async checks first (Promise.all + map) or use a synchronous predicate to decide which items to keep.',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            unexpected: 'Async array filter is dangerous as a Promise object will always be truthy. Instead of `array.filter(async x => await someCheck(x))`, first resolve the promises with `Promise.all()` or move the async logic elsewhere: `const results = await Promise.all(array.map(x => someCheck(x))); array.filter((_, i) => results[i])`.',
+            unexpected: 'Async predicate in {{methodName}} keeps every element because Array.filter does not await Promises, so the returned Promise is always treated as truthy. Resolve the async checks before filtering (e.g., const results = await Promise.all(items.map(check)); const filtered = items.filter((_, i) => results[i]);) or switch to a synchronous predicate.',
         },
     },
     defaultOptions: [],