@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/no-unused-usestate.js

@@ -17,7 +17,7 @@ exports.noUnusedUseState = createRule({
         },
         fixable: 'code',
         messages: {
-            unusedUseState: 'The state variable is ignored. Remove the unused useState hook.',
+            unusedUseState: 'State value "{{stateName}}" from useState is discarded. React still allocates state and re-renders for a value you never read, which misleads readers into thinking the component depends on that state. Remove the useState pair or switch to a ref/derived value when you only need the setter-style side effect.',
         },
         schema: [],
     },
@@ -41,12 +41,16 @@ exports.noUnusedUseState = createRule({
                                 utils_1.TSESTree.AST_NODE_TYPES.Identifier &&
                             (arrayPattern.elements[0].name === '_' ||
                                 arrayPattern.elements[0].name.startsWith('_'))) {
+                            const stateIdentifier = arrayPattern.elements[0];
                             context.report({
                                 node,
                                 messageId: 'unusedUseState',
+                                data: {
+                                    stateName: stateIdentifier.name,
+                                },
                                 fix: (fixer) => {
                                     // Remove the entire useState declaration
-                                    const sourceCode = context.getSourceCode();
+                                    const sourceCode = context.sourceCode;
                                     const parentStatement = node.parent;
                                     if (parentStatement &&
                                         parentStatement.type ===

package/lib/rules/no-useless-fragment.js

@@ -1,16 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUselessFragment = void 0;
+/**
+ * Normalizes JSX child node types into short descriptors used inside lint messages.
+ * Keeps message phrasing consistent regardless of the specific child node shape.
+ * @param child - The JSX child node to describe.
+ * @returns Human-readable descriptor for the child type used in lint messages.
+ */
+const describeChild = (child) => {
+    switch (child.type) {
+        case 'JSXElement':
+            return 'JSX element';
+        case 'JSXFragment':
+            return 'fragment';
+        case 'JSXExpressionContainer':
+            return 'expression result';
+        case 'JSXText':
+            return 'text node';
+        case 'JSXSpreadChild':
+            return 'spread child';
+        default:
+            return 'child node';
+    }
+};
 exports.noUselessFragment = {
     create(context) {
         return {
             JSXFragment(node) {
                 if (node.children.length === 1) {
+                    const [child] = node.children;
                     context.report({
                         node,
                         messageId: 'noUselessFragment',
+                        data: {
+                            childKind: describeChild(child),
+                        },
                         fix(fixer) {
-                            const sourceCode = context.getSourceCode();
+                            const sourceCode = context.sourceCode;
                             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                             const openingFragment = sourceCode.getFirstToken(node);
                             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -38,7 +64,7 @@ exports.noUselessFragment = {
             recommended: 'error',
         },
         messages: {
-            noUselessFragment: 'React fragment is unnecessary when wrapping a single child. Instead of `<>{"text"}</> or <Fragment>{"text"}</Fragment>`, use just `{"text"}`. Fragments are only needed when returning multiple elements.',
+            noUselessFragment: 'React fragment wraps a single {{childKind}} and does not provide grouping. Fragments exist to wrap multiple siblings; leaving this fragment adds extra syntax and a React tree node without changing the rendered output. Remove the fragment and return the child directly.',
         },
         schema: [],
         fixable: 'code',

package/lib/rules/no-useless-usememo-primitives.d.ts

@@ -0,0 +1,9 @@
+type Options = [
+    {
+        ignoreCallExpressions?: boolean;
+        ignoreSymbol?: boolean;
+        tsOnly?: boolean;
+    }
+];
+export declare const noUselessUsememoPrimitives: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"uselessUseMemoPrimitive", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default noUselessUsememoPrimitives;

package/lib/rules/no-useless-usememo-primitives.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUselessUsememoPrimitives = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const tsTypeClassifier_1 = require("../utils/tsTypeClassifier");
+const DEFAULT_OPTIONS = {
+    ignoreCallExpressions: true,
+    ignoreSymbol: true,
+    tsOnly: false,
+};
+const NON_DETERMINISTIC_MEMBERS = new Set([
+    'Date.now',
+    'Math.random',
+    'performance.now',
+    'crypto.randomUUID',
+    'crypto.getRandomValues',
+]);
+const NON_DETERMINISTIC_CONSTRUCTORS = new Set(['Date']);
+const COMPARISON_OPERATORS = new Set([
+    '==',
+    '===',
+    '!=',
+    '!==',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    'instanceof',
+    'in',
+]);
+function isStringLikeWithoutTypes(expr) {
+    switch (expr.type) {
+        case utils_1.AST_NODE_TYPES.Literal:
+            return typeof expr.value === 'string';
+        case utils_1.AST_NODE_TYPES.TemplateLiteral:
+            return true;
+        case utils_1.AST_NODE_TYPES.UnaryExpression:
+            return expr.operator === 'typeof';
+        case utils_1.AST_NODE_TYPES.BinaryExpression:
+            return (expr.operator === '+' &&
+                (isStringLikeWithoutTypes(expr.left) ||
+                    isStringLikeWithoutTypes(expr.right)));
+        default:
+            return false;
+    }
+}
+function isUseMemoCallee(callee) {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name === 'useMemo';
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.property.name === 'useMemo';
+    }
+    return false;
+}
+function getReturnedExpression(callback) {
+    if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return callback.body;
+    }
+    if (callback.body.body.length !== 1) {
+        return null;
+    }
+    const soleStatement = callback.body.body[0];
+    if (soleStatement.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+        soleStatement.argument &&
+        soleStatement.argument.type !== utils_1.AST_NODE_TYPES.SequenceExpression) {
+        return soleStatement.argument;
+    }
+    return null;
+}
+function walkExpression(expr, predicate, maxDepth = 100) {
+    const stack = [
+        { node: expr, depth: 0 },
+    ];
+    while (stack.length > 0) {
+        const { node: current, depth } = stack.pop();
+        if (depth > maxDepth)
+            continue;
+        if (predicate(current)) {
+            return true;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        for (const key of Object.keys(current)) {
+            if (key === 'parent')
+                continue;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const value = current[key];
+            if (!value)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (child && typeof child === 'object' && 'type' in child) {
+                        stack.push({ node: child, depth: depth + 1 });
+                    }
+                }
+            }
+            else if (typeof value === 'object' && 'type' in value) {
+                stack.push({ node: value, depth: depth + 1 });
+            }
+        }
+    }
+    return false;
+}
+function containsCallExpression(expr) {
+    return walkExpression(expr, (node) => [
+        utils_1.AST_NODE_TYPES.CallExpression,
+        utils_1.AST_NODE_TYPES.NewExpression,
+        utils_1.AST_NODE_TYPES.TaggedTemplateExpression,
+    ].includes(node.type));
+}
+function isNonDeterministicCall(node) {
+    const callee = node.callee;
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression && !callee.computed) {
+        const object = callee.object;
+        const property = callee.property;
+        if (object.type === utils_1.AST_NODE_TYPES.Identifier &&
+            property.type === utils_1.AST_NODE_TYPES.Identifier) {
+            const key = `${object.name}.${property.name}`;
+            if (NON_DETERMINISTIC_MEMBERS.has(key)) {
+                return true;
+            }
+        }
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier && callee.name === 'Date') {
+        return true;
+    }
+    return false;
+}
+function isNonDeterministicInvocation(expr) {
+    return walkExpression(expr, (node) => {
+        if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            return isNonDeterministicCall(node);
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
+            if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                NON_DETERMINISTIC_CONSTRUCTORS.has(node.callee.name)) {
+                return true;
+            }
+        }
+        return false;
+    });
+}
+function hasUnsafeSideEffects(expr) {
+    return walkExpression(expr, (node) => [
+        utils_1.AST_NODE_TYPES.AssignmentExpression,
+        utils_1.AST_NODE_TYPES.AwaitExpression,
+        utils_1.AST_NODE_TYPES.UpdateExpression,
+        utils_1.AST_NODE_TYPES.YieldExpression,
+        utils_1.AST_NODE_TYPES.SequenceExpression,
+    ].includes(node.type) ||
+        (node.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+            node.operator === 'delete'));
+}
+function describePrimitiveExpression(expr) {
+    switch (expr.type) {
+        case utils_1.AST_NODE_TYPES.Literal: {
+            if ('regex' in expr && expr.regex) {
+                return 'RegExp object';
+            }
+            if ('bigint' in expr && expr.bigint !== undefined) {
+                return 'bigint value';
+            }
+            if (expr.value === null)
+                return 'null value';
+            if (typeof expr.value === 'boolean')
+                return 'boolean value';
+            if (typeof expr.value === 'number')
+                return 'number value';
+            if (typeof expr.value === 'string')
+                return 'string value';
+            /* istanbul ignore next -- defensive fallback for uncommon literals */
+            return 'primitive value';
+        }
+        case utils_1.AST_NODE_TYPES.TemplateLiteral:
+            return 'string value';
+        case utils_1.AST_NODE_TYPES.UnaryExpression:
+            if (expr.operator === '!')
+                return 'boolean condition';
+            if (expr.operator === 'void')
+                return 'undefined value';
+            if (expr.operator === 'typeof')
+                return 'string value';
+            /* istanbul ignore next -- other unary operators are treated as primitives */
+            return 'primitive value';
+        case utils_1.AST_NODE_TYPES.BinaryExpression:
+            if (COMPARISON_OPERATORS.has(expr.operator)) {
+                return 'boolean condition';
+            }
+            if (expr.operator === '+' && isStringLikeWithoutTypes(expr)) {
+                return 'string value';
+            }
+            return 'number value';
+        case utils_1.AST_NODE_TYPES.LogicalExpression:
+            return 'primitive value';
+        case utils_1.AST_NODE_TYPES.ConditionalExpression:
+            return 'primitive value';
+        case utils_1.AST_NODE_TYPES.Identifier:
+            if (expr.name === 'undefined')
+                return 'undefined value';
+            if (expr.name === 'Infinity' || expr.name === 'NaN')
+                return 'number value';
+            return 'primitive value';
+        default:
+            /* istanbul ignore next -- unreachable with current node set */
+            return 'primitive value';
+    }
+}
+function isPrimitiveExpressionWithoutTypes(expr) {
+    switch (expr.type) {
+        case utils_1.AST_NODE_TYPES.Literal: {
+            if ('regex' in expr && expr.regex) {
+                return { primitive: false, kind: describePrimitiveExpression(expr) };
+            }
+            return { primitive: true, kind: describePrimitiveExpression(expr) };
+        }
+        case utils_1.AST_NODE_TYPES.Identifier: {
+            const identifier = expr;
+            if (identifier.name === 'undefined' ||
+                identifier.name === 'Infinity' ||
+                identifier.name === 'NaN') {
+                return { primitive: true, kind: describePrimitiveExpression(expr) };
+            }
+            return { primitive: false, kind: 'primitive value' };
+        }
+        case utils_1.AST_NODE_TYPES.TemplateLiteral:
+            return { primitive: true, kind: describePrimitiveExpression(expr) };
+        case utils_1.AST_NODE_TYPES.UnaryExpression:
+            return { primitive: true, kind: describePrimitiveExpression(expr) };
+        case utils_1.AST_NODE_TYPES.BinaryExpression: {
+            const primitive = COMPARISON_OPERATORS.has(expr.operator) ||
+                (isPrimitiveExpressionWithoutTypes(expr.left)
+                    .primitive &&
+                    isPrimitiveExpressionWithoutTypes(expr.right)
+                        .primitive);
+            return {
+                primitive,
+                kind: describePrimitiveExpression(expr),
+            };
+        }
+        case utils_1.AST_NODE_TYPES.LogicalExpression:
+            return {
+                primitive: isPrimitiveExpressionWithoutTypes(expr.left)
+                    .primitive &&
+                    isPrimitiveExpressionWithoutTypes(expr.right)
+                        .primitive,
+                kind: describePrimitiveExpression(expr),
+            };
+        case utils_1.AST_NODE_TYPES.ConditionalExpression:
+            return {
+                primitive: isPrimitiveExpressionWithoutTypes(expr.consequent).primitive &&
+                    isPrimitiveExpressionWithoutTypes(expr.alternate).primitive,
+                kind: describePrimitiveExpression(expr),
+            };
+        case utils_1.AST_NODE_TYPES.ChainExpression:
+            return isPrimitiveExpressionWithoutTypes(expr.expression);
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+        case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            return isPrimitiveExpressionWithoutTypes(expr.expression);
+        default:
+            return { primitive: false, kind: 'primitive value' };
+    }
+}
+exports.noUselessUsememoPrimitives = (0, createRule_1.createRule)({
+    name: 'no-useless-usememo-primitives',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow useless useMemo with primitive values.',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignoreCallExpressions: { type: 'boolean', default: true },
+                    ignoreSymbol: { type: 'boolean', default: true },
+                    tsOnly: { type: 'boolean', default: false },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            uselessUseMemoPrimitive: 'useMemo wraps a primitive {{valueKind}}. → Primitives are pass-by-value and have no identity to preserve, so memoization provides zero referential-stability benefit and only adds unnecessary hook overhead. → Remove useMemo and inline the expression directly.',
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context) {
+        const options = { ...DEFAULT_OPTIONS, ...context.options[0] };
+        const sourceCode = context.sourceCode;
+        const services = sourceCode.parserServices;
+        const parserServices = services &&
+            'hasFullTypeInformation' in services &&
+            services.hasFullTypeInformation
+            ? services
+            : null;
+        if (options.tsOnly && !parserServices) {
+            return {};
+        }
+        let tsModule = null;
+        let checker = null;
+        if (parserServices) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const ts = require('typescript');
+                tsModule = ts;
+                checker = parserServices.program.getTypeChecker();
+            }
+            catch {
+                /* istanbul ignore next -- TypeScript not available, falls back to heuristic path */
+            }
+        }
+        function classifyExpressionTypeInternal(expr) {
+            if (!checker || !tsModule || !parserServices) {
+                return { status: 'unknown', kind: 'unknown value' };
+            }
+            return (0, tsTypeClassifier_1.classifyExpressionType)(expr, {
+                checker,
+                tsModule,
+                parserServices,
+                options,
+            });
+        }
+        return {
+            CallExpression(node) {
+                if (!isUseMemoCallee(node.callee)) {
+                    return;
+                }
+                if (node.arguments.length === 0) {
+                    return;
+                }
+                const callback = node.arguments[0];
+                if (callback.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                    callback.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    return;
+                }
+                if (callback.async) {
+                    return;
+                }
+                if (callback.generator) {
+                    return;
+                }
+                const returnedExpression = getReturnedExpression(callback);
+                if (!returnedExpression) {
+                    return;
+                }
+                if (hasUnsafeSideEffects(returnedExpression)) {
+                    return;
+                }
+                if (isNonDeterministicInvocation(returnedExpression)) {
+                    return;
+                }
+                if (options.ignoreCallExpressions &&
+                    containsCallExpression(returnedExpression)) {
+                    return;
+                }
+                const typeEvaluation = classifyExpressionTypeInternal(returnedExpression);
+                let isPrimitive = false;
+                let valueKind = typeEvaluation.kind;
+                if (typeEvaluation.status === 'primitive') {
+                    isPrimitive = true;
+                }
+                else if (typeEvaluation.status !== 'non-primitive') {
+                    const heuristic = isPrimitiveExpressionWithoutTypes(returnedExpression);
+                    if (heuristic.primitive) {
+                        isPrimitive = true;
+                        valueKind = heuristic.kind;
+                    }
+                }
+                if (!isPrimitive) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'uselessUseMemoPrimitive',
+                    data: {
+                        valueKind,
+                    },
+                    fix(fixer) {
+                        const replacement = `(${sourceCode.getText(returnedExpression)})`;
+                        return fixer.replaceText(node, replacement);
+                    },
+                });
+            },
+        };
+    },
+});
+exports.default = exports.noUselessUsememoPrimitives;
+//# sourceMappingURL=no-useless-usememo-primitives.js.map

package/lib/rules/no-usememo-for-pass-by-value.d.ts

@@ -0,0 +1,13 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type Options = [
+    {
+        /**
+         * Patterns (regex strings) that describe call expressions considered "expensive"
+         * and therefore allowed even when they return pass-by-value types.
+         */
+        allowExpensiveCalleePatterns?: string[];
+    }
+];
+type MessageIds = 'primitiveMemo' | 'invalidRegex';
+export declare const noUsememoForPassByValue: TSESLint.RuleModule<MessageIds, Options, TSESLint.RuleListener>;
+export default noUsememoForPassByValue;