@blumintinc/eslint-plugin-blumint 1.15.0 → 1.16.1

package/lib/rules/prefer-memoized-props.js

@@ -1,445 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preferMemoizedProps = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const createRule_1 = require("../utils/createRule");
-const HOOK_NAMES = new Set(['useMemo', 'useCallback']);
-exports.preferMemoizedProps = (0, createRule_1.createRule)({
-    name: 'prefer-memoized-props',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Require memoizing reference props (objects, arrays, functions) inside React.memo components while avoiding unnecessary useMemo for pass-through values.',
-            recommended: 'error',
-        },
-        schema: [],
-        messages: {
-            memoizeReferenceProp: 'Prop "{{propName}}" in a React.memo component receives a {{kind}} that is recreated every render, so memoized children lose referential equality and re-render. Memoize this {{kind}} with useMemo/useCallback or hoist a stable constant so the prop reference stays stable.',
-            avoidPrimitiveMemo: 'useMemo around "{{value}}" only wraps a pass-through value. Primitives already compare by value, and wrapping existing references without creating new objects does not improve stability. Return the value directly instead of adding memoization noise.',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const sourceCode = context.getSourceCode();
-        const visitorKeys = sourceCode.visitorKeys;
-        const memoizedComponents = new WeakSet();
-        const memoScopes = [];
-        const componentStack = [];
-        const scopedFunctions = new WeakSet();
-        function pushMemoScope() {
-            memoScopes.push(new Map());
-        }
-        function popMemoScope() {
-            memoScopes.pop();
-        }
-        function currentMemoScope() {
-            return memoScopes[memoScopes.length - 1];
-        }
-        function declareFunctionBinding(name, node) {
-            const scope = currentMemoScope();
-            if (!scope)
-                return;
-            scope.set(name, node);
-        }
-        function resolveFunctionBinding(name) {
-            for (let i = memoScopes.length - 1; i >= 0; i -= 1) {
-                const binding = memoScopes[i].get(name);
-                if (binding) {
-                    return binding;
-                }
-            }
-            return undefined;
-        }
-        function hoistFunctionDeclarations(statements) {
-            const scope = currentMemoScope();
-            if (!scope)
-                return;
-            for (const statement of statements) {
-                if (statement.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
-                    statement.id?.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    scope.set(statement.id.name, statement);
-                }
-            }
-        }
-        function registerFunctionVariable(node) {
-            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
-                return;
-            const { init } = node;
-            if (init &&
-                (init.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-                    init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
-                declareFunctionBinding(node.id.name, init);
-            }
-        }
-        function isReactMemoCallee(callee) {
-            if (callee.type === utils_1.AST_NODE_TYPES.Identifier && callee.name === 'memo') {
-                return true;
-            }
-            if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                !callee.computed &&
-                callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                callee.property.name === 'memo') {
-                return true;
-            }
-            return false;
-        }
-        function isHookCall(node, name) {
-            if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.callee.name === name) {
-                return true;
-            }
-            return (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                !node.callee.computed &&
-                node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.callee.property.name === name);
-        }
-        function collectMemoizedComponents(node) {
-            pushMemoScope();
-            if (node.type === utils_1.AST_NODE_TYPES.Program) {
-                hoistFunctionDeclarations(node.body);
-            }
-            function traverse(current) {
-                const isFunctionLike = current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
-                    current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-                    current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression;
-                if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
-                    current.id?.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    declareFunctionBinding(current.id.name, current);
-                }
-                let pushedScope = false;
-                if (current.type === utils_1.AST_NODE_TYPES.BlockStatement || isFunctionLike) {
-                    pushMemoScope();
-                    pushedScope = true;
-                    if (isFunctionLike &&
-                        'id' in current &&
-                        current.id?.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        declareFunctionBinding(current.id.name, current);
-                    }
-                    if (current.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                        hoistFunctionDeclarations(current.body);
-                    }
-                    else if (isFunctionLike &&
-                        current.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                        hoistFunctionDeclarations(current.body.body);
-                    }
-                }
-                if (current.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
-                    registerFunctionVariable(current);
-                }
-                if (current.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                    isReactMemoCallee(current.callee)) {
-                    const [firstArg] = current.arguments;
-                    if (firstArg &&
-                        (firstArg.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                            firstArg.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
-                        memoizedComponents.add(firstArg);
-                    }
-                    else if (firstArg && firstArg.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const binding = resolveFunctionBinding(firstArg.name);
-                        if (binding) {
-                            memoizedComponents.add(binding);
-                        }
-                    }
-                }
-                const keys = visitorKeys[current.type] ?? [];
-                for (const key of keys) {
-                    const value = current[key];
-                    if (Array.isArray(value)) {
-                        for (const child of value) {
-                            if (child && typeof child === 'object') {
-                                traverse(child);
-                            }
-                        }
-                    }
-                    else if (value && typeof value === 'object') {
-                        traverse(value);
-                    }
-                }
-                if (pushedScope) {
-                    popMemoScope();
-                }
-            }
-            traverse(node);
-            popMemoScope();
-        }
-        collectMemoizedComponents(sourceCode.ast);
-        function isMemoizedComponent(node) {
-            return memoizedComponents.has(node);
-        }
-        function pushComponent(node) {
-            componentStack.push({ node, scopes: [new Map()] });
-        }
-        function popComponent(node) {
-            const top = componentStack[componentStack.length - 1];
-            if (top && top.node === node) {
-                componentStack.pop();
-            }
-        }
-        function currentComponent() {
-            return componentStack[componentStack.length - 1];
-        }
-        function currentScope() {
-            const component = currentComponent();
-            if (!component)
-                return undefined;
-            return component.scopes[component.scopes.length - 1];
-        }
-        function pushScopeForNestedFunction(node) {
-            const component = currentComponent();
-            if (!component)
-                return;
-            component.scopes.push(new Map());
-            scopedFunctions.add(node);
-        }
-        function popScopeForNestedFunction(node) {
-            const component = currentComponent();
-            if (!component)
-                return;
-            if (!scopedFunctions.has(node))
-                return;
-            component.scopes.pop();
-            scopedFunctions.delete(node);
-        }
-        function unwrapExpression(expression) {
-            let current = expression;
-            while (true) {
-                if (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
-                    current.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
-                    current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
-                    current = current.expression;
-                    continue;
-                }
-                if (current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
-                    current = current.expression;
-                    continue;
-                }
-                break;
-            }
-            return current;
-        }
-        function getBindingKind(init) {
-            if (!init) {
-                return null;
-            }
-            const unwrapped = unwrapExpression(init);
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                ((unwrapped.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    HOOK_NAMES.has(unwrapped.callee.name)) ||
-                    (unwrapped.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        !unwrapped.callee.computed &&
-                        unwrapped.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        HOOK_NAMES.has(unwrapped.callee.property.name)))) {
-                return null;
-            }
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.ObjectExpression)
-                return 'object';
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.ArrayExpression)
-                return 'array';
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                unwrapped.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
-                return 'function';
-            }
-            return null;
-        }
-        function recordBinding(node) {
-            const scope = currentScope();
-            if (!scope)
-                return;
-            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier || !node.init) {
-                return;
-            }
-            const initializer = unwrapExpression(node.init);
-            const aliasKind = initializer.type === utils_1.AST_NODE_TYPES.Identifier
-                ? findBindingKind(initializer.name)
-                : null;
-            const kind = aliasKind ?? getBindingKind(initializer);
-            if (kind)
-                scope.set(node.id.name, kind);
-        }
-        function findBindingKind(name) {
-            for (let i = componentStack.length - 1; i >= 0; i -= 1) {
-                const component = componentStack[i];
-                for (let j = component.scopes.length - 1; j >= 0; j -= 1) {
-                    const binding = component.scopes[j].get(name);
-                    if (binding)
-                        return binding;
-                }
-            }
-            return null;
-        }
-        function getAttributeName(name) {
-            if (name.type === utils_1.AST_NODE_TYPES.JSXIdentifier) {
-                return name.name;
-            }
-            if (name.type === utils_1.AST_NODE_TYPES.JSXNamespacedName) {
-                return name.name.name;
-            }
-            return 'prop';
-        }
-        function reportReference(node, propName, kind) {
-            context.report({
-                node,
-                messageId: 'memoizeReferenceProp',
-                data: { propName, kind },
-            });
-        }
-        function isEnvironmentFreeLiteral(expression) {
-            const unwrapped = unwrapExpression(expression);
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.Literal)
-                return true;
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
-                unwrapped.expressions.length === 0) {
-                return true;
-            }
-            return false;
-        }
-        function isStableReference(expression) {
-            const unwrapped = unwrapExpression(expression);
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.Literal)
-                return true;
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
-                return unwrapped.expressions.every((expr) => isStableReference(expr));
-            }
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.Identifier)
-                return true;
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.MemberExpression)
-                return true;
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.ChainExpression &&
-                unwrapped.expression.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                return true;
-            }
-            return false;
-        }
-        function extractReturnExpression(callback) {
-            if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
-                return callback.body;
-            }
-            const [statement] = callback.body.body;
-            if (statement &&
-                statement.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
-                statement.argument) {
-                return statement.argument;
-            }
-            return null;
-        }
-        function handleUseMemo(node) {
-            if (!currentComponent() || !isHookCall(node, 'useMemo')) {
-                return;
-            }
-            const [callback, deps] = node.arguments;
-            if (!callback ||
-                (callback.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
-                    callback.type !== utils_1.AST_NODE_TYPES.FunctionExpression)) {
-                return;
-            }
-            const returnExpression = extractReturnExpression(callback);
-            if (!returnExpression)
-                return;
-            const dependencies = deps && deps.type === utils_1.AST_NODE_TYPES.ArrayExpression ? deps : null;
-            if (dependencies &&
-                dependencies.elements.length === 0 &&
-                !isEnvironmentFreeLiteral(returnExpression)) {
-                return;
-            }
-            if (isStableReference(returnExpression)) {
-                const valueText = sourceCode.getText(returnExpression).slice(0, 80);
-                context.report({
-                    node,
-                    messageId: 'avoidPrimitiveMemo',
-                    data: { value: valueText },
-                });
-            }
-        }
-        function handleJSXAttribute(node) {
-            if (!currentComponent())
-                return;
-            if (!node.value ||
-                node.value.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
-                return;
-            }
-            const rawExpression = node.value.expression;
-            if (rawExpression.type === utils_1.AST_NODE_TYPES.JSXEmptyExpression) {
-                return;
-            }
-            const expression = unwrapExpression(rawExpression);
-            const propName = getAttributeName(node.name);
-            if (expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                reportReference(expression, propName, 'object');
-                return;
-            }
-            if (expression.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
-                reportReference(expression, propName, 'array');
-                return;
-            }
-            if (expression.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                expression.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
-                reportReference(expression, propName, 'function');
-                return;
-            }
-            if (expression.type === utils_1.AST_NODE_TYPES.Identifier) {
-                const bindingKind = findBindingKind(expression.name);
-                if (bindingKind) {
-                    reportReference(expression, propName, bindingKind);
-                }
-            }
-        }
-        return {
-            FunctionDeclaration(node) {
-                if (isMemoizedComponent(node)) {
-                    pushComponent(node);
-                    return;
-                }
-                const scope = currentScope();
-                if (scope && node.id?.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    scope.set(node.id.name, 'function');
-                }
-                if (currentComponent()) {
-                    pushScopeForNestedFunction(node);
-                }
-            },
-            'FunctionDeclaration:exit'(node) {
-                if (isMemoizedComponent(node)) {
-                    popComponent(node);
-                    return;
-                }
-                popScopeForNestedFunction(node);
-            },
-            FunctionExpression(node) {
-                if (isMemoizedComponent(node)) {
-                    pushComponent(node);
-                    return;
-                }
-                if (currentComponent()) {
-                    pushScopeForNestedFunction(node);
-                }
-            },
-            'FunctionExpression:exit'(node) {
-                if (isMemoizedComponent(node)) {
-                    popComponent(node);
-                    return;
-                }
-                popScopeForNestedFunction(node);
-            },
-            ArrowFunctionExpression(node) {
-                if (isMemoizedComponent(node)) {
-                    pushComponent(node);
-                    return;
-                }
-                if (currentComponent()) {
-                    pushScopeForNestedFunction(node);
-                }
-            },
-            'ArrowFunctionExpression:exit'(node) {
-                if (isMemoizedComponent(node)) {
-                    popComponent(node);
-                    return;
-                }
-                popScopeForNestedFunction(node);
-            },
-            VariableDeclarator: recordBinding,
-            CallExpression: handleUseMemo,
-            JSXAttribute: handleJSXAttribute,
-        };
-    },
-});
-//# sourceMappingURL=prefer-memoized-props.js.map

package/lib/rules/prefer-nullish-coalescing-override.d.ts

@@ -1,7 +0,0 @@
-import { TSESLint } from '@typescript-eslint/utils';
-/**
- * This rule overrides the behavior of @typescript-eslint/prefer-nullish-coalescing
- * to only suggest using the nullish coalescing operator when checking for null/undefined,
- * not when intentionally checking for all falsy values.
- */
-export declare const preferNullishCoalescingOverride: TSESLint.RuleModule<"preferNullishCoalescing", [], TSESLint.RuleListener>;

package/lib/rules/prefer-nullish-coalescing-override.js

@@ -1,188 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preferNullishCoalescingOverride = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const createRule_1 = require("../utils/createRule");
-/**
- * This rule overrides the behavior of @typescript-eslint/prefer-nullish-coalescing
- * to only suggest using the nullish coalescing operator when checking for null/undefined,
- * not when intentionally checking for all falsy values.
- */
-exports.preferNullishCoalescingOverride = (0, createRule_1.createRule)({
-    name: 'prefer-nullish-coalescing-override',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Enforce using nullish coalescing operator instead of logical OR operator, but only when appropriate',
-            recommended: 'warn',
-        },
-        fixable: 'code',
-        schema: [],
-        messages: {
-            preferNullishCoalescing: 'Replace "{{left}} || {{right}}" with nullish coalescing when you only want a fallback for null or undefined. The logical OR operator treats "", 0, and false as missing values and silently swaps in the fallback, which hides valid data. Use "{{left}} ?? {{right}}" so only nullish inputs trigger the fallback.',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const contextWithSource = context;
-        const sourceCode = contextWithSource.sourceCode ?? contextWithSource.getSourceCode();
-        /**
-         * Checks if a node is in a boolean context where truthiness matters
-         */
-        function isInBooleanContext(node) {
-            const parent = node.parent;
-            if (!parent)
-                return false;
-            switch (parent.type) {
-                // Direct boolean contexts
-                case utils_1.AST_NODE_TYPES.IfStatement:
-                case utils_1.AST_NODE_TYPES.WhileStatement:
-                case utils_1.AST_NODE_TYPES.DoWhileStatement:
-                case utils_1.AST_NODE_TYPES.ForStatement:
-                    return parent.test === node;
-                case utils_1.AST_NODE_TYPES.ConditionalExpression:
-                    return parent.test === node;
-                // Logical expressions (&&, ||, !)
-                case utils_1.AST_NODE_TYPES.LogicalExpression:
-                    return true;
-                case utils_1.AST_NODE_TYPES.UnaryExpression:
-                    return parent.operator === '!';
-                // JSX expressions that expect boolean values
-                case utils_1.AST_NODE_TYPES.JSXExpressionContainer:
-                    return isJSXBooleanContext(parent);
-                default:
-                    return false;
-            }
-        }
-        /**
-         * Checks if a JSX expression container is in a boolean context
-         */
-        function isJSXBooleanContext(jsxContainer) {
-            const parent = jsxContainer.parent;
-            if (!parent)
-                return false;
-            // Check if used as a child expression (conditional rendering or child selection).
-            // Other guards (rightOperandSuggestsFalsyHandling, etc.) will prevent unsafe conversions.
-            if (parent.type === utils_1.AST_NODE_TYPES.JSXElement ||
-                parent.type === utils_1.AST_NODE_TYPES.JSXFragment) {
-                return true;
-            }
-            return false;
-        }
-        /**
-         * Checks if the right operand suggests we want to handle all falsy values
-         */
-        function rightOperandSuggestsFalsyHandling(right) {
-            // String literals suggest we want to handle empty strings too
-            if (right.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof right.value === 'string') {
-                return true;
-            }
-            // Number literals (especially 0) suggest we want to handle falsy numbers
-            if (right.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof right.value === 'number') {
-                return true;
-            }
-            // Boolean literals suggest boolean logic
-            if (right.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof right.value === 'boolean') {
-                return true;
-            }
-            return false;
-        }
-        /**
-         * Checks if the left operand is likely to be used for boolean logic
-         */
-        function leftOperandSuggestsBooleanLogic(left) {
-            // Variables with boolean-like names
-            if (left.type === utils_1.AST_NODE_TYPES.Identifier) {
-                const name = left.name.toLowerCase();
-                const booleanPrefixes = [
-                    'is',
-                    'has',
-                    'can',
-                    'should',
-                    'will',
-                    'was',
-                    'were',
-                    'are',
-                ];
-                const booleanSuffixes = [
-                    'enabled',
-                    'disabled',
-                    'active',
-                    'inactive',
-                    'valid',
-                    'invalid',
-                ];
-                return (booleanPrefixes.some((prefix) => name.startsWith(prefix)) ||
-                    booleanSuffixes.some((suffix) => name.endsWith(suffix)));
-            }
-            // Binary expressions that result in booleans
-            if (left.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
-                const comparisonOperators = [
-                    '===',
-                    '!==',
-                    '==',
-                    '!=',
-                    '<',
-                    '>',
-                    '<=',
-                    '>=',
-                ];
-                return comparisonOperators.includes(left.operator);
-            }
-            return false;
-        }
-        /**
-         * Checks if this is a variable assignment context where falsy handling is expected
-         */
-        function isVariableAssignmentWithFalsyHandling(node) {
-            const parent = node.parent;
-            if (!parent)
-                return false;
-            // Variable declarations like: const name = username || 'Anonymous'
-            if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                parent.init === node) {
-                return rightOperandSuggestsFalsyHandling(node.right);
-            }
-            // Assignment expressions like: this.name = username || 'Anonymous'
-            if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
-                parent.right === node) {
-                return rightOperandSuggestsFalsyHandling(node.right);
-            }
-            return false;
-        }
-        /**
-         * Checks if this logical OR should be converted to nullish coalescing
-         */
-        function shouldConvertToNullishCoalescing(node) {
-            void node;
-            return false;
-        }
-        void isInBooleanContext;
-        void leftOperandSuggestsBooleanLogic;
-        void rightOperandSuggestsFalsyHandling;
-        void isVariableAssignmentWithFalsyHandling;
-        return {
-            LogicalExpression(node) {
-                if (shouldConvertToNullishCoalescing(node)) {
-                    const leftText = sourceCode.getText(node.left);
-                    const rightText = sourceCode.getText(node.right);
-                    context.report({
-                        node,
-                        messageId: 'preferNullishCoalescing',
-                        data: {
-                            left: leftText,
-                            right: rightText,
-                        },
-                        fix(fixer) {
-                            return fixer.replaceText(node, `${leftText} ?? ${rightText}`);
-                        },
-                    });
-                }
-            },
-        };
-    },
-});
-//# sourceMappingURL=prefer-nullish-coalescing-override.js.map

package/lib/rules/require-usememo-object-literals.d.ts

@@ -1,4 +0,0 @@
-import { TSESTree } from '@typescript-eslint/utils';
-export declare const requireUseMemoObjectLiterals: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireUseMemo", never[], {
-    JSXAttribute(node: TSESTree.JSXAttribute): void;
-}>;