@blumintinc/eslint-plugin-blumint 1.14.0 → 1.16.0

package/lib/rules/global-const-style.js

@@ -31,6 +31,21 @@ exports.default = (0, createRule_1.createRule)({
             }
             return target;
         };
+        const isDynamicValue = (node) => {
+            const target = unwrapAssertions(node);
+            if (target.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                target.type === utils_1.AST_NODE_TYPES.NewExpression ||
+                target.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+                return true;
+            }
+            if (target.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+                return isDynamicValue(target.expression);
+            }
+            if (target.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                return isDynamicValue(target.object);
+            }
+            return false;
+        };
         const describeValueKind = (node) => {
             const target = unwrapAssertions(node);
             if (target.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
@@ -102,10 +117,7 @@ exports.default = (0, createRule_1.createRule)({
                     const { name } = declaration.id;
                     const init = declaration.init;
                     // Skip if no initializer or if it's a dynamic value or class instance
-                    if (!init ||
-                        init.type === utils_1.AST_NODE_TYPES.CallExpression ||
-                        init.type === utils_1.AST_NODE_TYPES.BinaryExpression ||
-                        init.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                    if (!init || isDynamicValue(init)) {
                         return;
                     }
                     const sourceCode = context.sourceCode;
@@ -146,6 +158,15 @@ exports.default = (0, createRule_1.createRule)({
                             if (target.type === utils_1.AST_NODE_TYPES.Literal && 'regex' in target) {
                                 return false;
                             }
+                            // Skip null and boolean literals. `null as const` is invalid
+                            // TypeScript (TS1355), so the autofix would produce uncompilable
+                            // code; `true`/`false` already have literal types, so `as const`
+                            // is redundant. (`undefined` is an Identifier, not a Literal, so
+                            // it never reaches the literal branch below.)
+                            if (target.type === utils_1.AST_NODE_TYPES.Literal &&
+                                (target.value === null || typeof target.value === 'boolean')) {
+                                return false;
+                            }
                             return (target.type === utils_1.AST_NODE_TYPES.Literal ||
                                 target.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
                                 target.type === utils_1.AST_NODE_TYPES.ObjectExpression);

package/lib/rules/logical-top-to-bottom-grouping.js

@@ -760,18 +760,26 @@ function handleGuardHoists(ruleContext, body, parent) {
 }
 function handleDerivedGrouping(ruleContext, body, parent) {
     const declaredIndices = new Map();
+    /**
+     * Each binding name → the declarator that introduced it. Sibling bindings of
+     * one multi-target declarator (e.g. `const [a, b] = ...`) share one node, so
+     * a statement deriving from `a` is recognizable as a sibling of one deriving
+     * from `b` even though `a` separates `b` from its declaration.
+     */
+    const sourceDeclarators = new Map();
     const { sourceCode } = ruleContext;
     body.forEach((statement, index) => {
         if (isVariableDeclaration(statement)) {
-            processVariableDeclaration(ruleContext, statement, index, body, declaredIndices, parent, sourceCode);
+            processVariableDeclaration(ruleContext, statement, index, body, declaredIndices, sourceDeclarators, parent, sourceCode);
         }
         trackDeclaredNames(statement, index, declaredIndices);
+        trackSourceDeclarators(statement, sourceDeclarators);
     });
 }
 function isVariableDeclaration(statement) {
     return statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration;
 }
-function processVariableDeclaration(ruleContext, statement, index, body, declaredIndices, parent, sourceCode) {
+function processVariableDeclaration(ruleContext, statement, index, body, declaredIndices, sourceDeclarators, parent, sourceCode) {
     const dependencies = collectDependencies(statement);
     const priorDependencies = findPriorDependencies(dependencies, declaredIndices);
     if (priorDependencies.length === 0 ||
@@ -784,6 +792,9 @@ function processVariableDeclaration(ruleContext, statement, index, body, declare
     }
     const declaredNames = getDeclaredNames(statement);
     const priorDependencySet = new Set(priorDependencies);
+    if (interveningAreSiblingDerivations(body, lastDependencyIndex, index, priorDependencySet, sourceDeclarators)) {
+        return;
+    }
     if (hasBlockers(body, lastDependencyIndex, index, priorDependencySet, declaredNames)) {
         return;
     }
@@ -829,6 +840,73 @@ function trackDeclaredNames(statement, index, declaredIndices) {
     const declared = getDeclaredNames(statement);
     declared.forEach((name) => declaredIndices.set(name, index));
 }
+function trackSourceDeclarators(statement, sourceDeclarators) {
+    if (statement.type !== utils_1.AST_NODE_TYPES.VariableDeclaration) {
+        return;
+    }
+    statement.declarations.forEach((declarator) => {
+        const names = new Set();
+        collectDeclaredNamesFromPattern(declarator.id, names);
+        names.forEach((name) => sourceDeclarators.set(name, declarator));
+    });
+}
+/**
+ * True when every statement between a dependency and the statement deriving from
+ * it is itself a pure derivation from a *sibling binding of the same declarator*.
+ *
+ * `const [a, b] = await Promise.all([...]); const x = a; const y = b;` is already
+ * grouped: `x` and `y` unpack one source declaration in order, so the `x` line is
+ * not "unrelated" separation between `b` and `y`. Suppressing here keeps such
+ * cohesive sibling-destructure groups intact instead of reordering them.
+ */
+function interveningAreSiblingDerivations(body, lastDependencyIndex, currentIndex, priorDependencySet, sourceDeclarators) {
+    const sourceNodes = new Set();
+    priorDependencySet.forEach((name) => {
+        const declarator = sourceDeclarators.get(name);
+        if (declarator) {
+            sourceNodes.add(declarator);
+        }
+    });
+    if (sourceNodes.size === 0) {
+        return false;
+    }
+    const intervening = body.slice(lastDependencyIndex + 1, currentIndex);
+    if (intervening.length === 0) {
+        return false;
+    }
+    return intervening.every((between) => isSiblingSourceDerivation(between, sourceNodes, sourceDeclarators));
+}
+/**
+ * A statement is a sibling-source derivation when it is a pure declaration whose
+ * every prior-declared dependency was introduced by one of `sourceNodes` — i.e.
+ * it unpacks a sibling binding of the same multi-target declaration the dependent
+ * statement derives from.
+ */
+function isSiblingSourceDerivation(statement, sourceNodes, sourceDeclarators) {
+    if (statement.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
+        !isPureDeclaration(statement, { allowHooks: false })) {
+        return false;
+    }
+    const dependencies = collectDependencies(statement);
+    const siblingSourced = Array.from(dependencies).filter((name) => {
+        const declarator = sourceDeclarators.get(name);
+        return Boolean(declarator && sourceNodes.has(declarator));
+    });
+    if (siblingSourced.length === 0) {
+        return false;
+    }
+    /**
+     * Reject when the statement also pulls in any prior-declared name from outside
+     * the sibling source: that would be genuine extra coupling, not a clean sibling
+     * unpack.
+     */
+    return Array.from(dependencies).every((name) => {
+        if (siblingSourced.includes(name)) {
+            return true;
+        }
+        return !sourceDeclarators.has(name);
+    });
+}
 function handleLateDeclarations(ruleContext, body, parent) {
     const { sourceCode } = ruleContext;
     body.forEach((statement, index) => {

package/lib/rules/memo-compare-deeply-complex-props.js

@@ -6,6 +6,29 @@ const createRule_1 = require("../utils/createRule");
 function isUtilMemoModulePath(path) {
     return /(?:^|\/|\\)util\/memo$/.test(path);
 }
+/**
+ * Reserved React slots that never reach a component's props object at runtime.
+ * React extracts `ref` and `key` before invoking the memo equality function, so
+ * a deep comparator can never observe them. Some prop-type sources (notably the
+ * `forwardRef<T, P>` exotic-component signature, whose params include the
+ * synthetic `RefAttributes<T> = { ref?: Ref<T> }` member) surface them as
+ * structural members anyway; flagging them would emit dead `compareDeeply('ref')`
+ * advice. Excluded the same way `children` is.
+ */
+const RESERVED_REACT_PROP_NAMES = new Set(['ref', 'key', 'children']);
+function isReservedReactPropName(name) {
+    return RESERVED_REACT_PROP_NAMES.has(name);
+}
+/**
+ * Checks if a property name is handled by the default deep equality logic
+ * in our custom memo implementation (blumintAreEqual).
+ */
+function isDefaultDeepCompareProp(name) {
+    return (name === 'sx' ||
+        name.endsWith('Sx') ||
+        name === 'style' ||
+        name.endsWith('Style'));
+}
 function unwrapExpression(expression) {
     let node = expression;
     // Unwrap harmless wrappers so detection treats casted/parenthesized expressions the same.
@@ -286,6 +309,91 @@ function ensureCompareDeeplyImportFixes(sourceCode, fixer, usedNames, preferredS
         localName: preferredLocalName,
     };
 }
+/**
+ * Names of React types that represent renderable UI or component references.
+ * Props typed as any of these are stable references (JSX elements, component
+ * constructors, render-prop functions) and do NOT benefit from deep value
+ * comparison — flagging them would produce false positives.
+ */
+const REACT_RENDER_TYPE_NAMES = new Set([
+    'ReactNode',
+    'ReactChild',
+    'ReactElement',
+    'ReactPortal',
+    'ReactFragment',
+    // JSX.Element resolves to a global symbol named 'Element' in the JSX namespace
+    'Element',
+    'Component',
+    'PureComponent',
+    'ComponentClass',
+    'FunctionComponent',
+    'FC',
+    'ComponentType',
+    'ExoticComponent',
+    'NamedExoticComponent',
+    'MemoExoticComponent',
+    'ForwardRefExoticComponent',
+    'LazyExoticComponent',
+    'JSXElementConstructor',
+    'RefObject',
+    'RefCallback',
+    'Ref',
+]);
+/**
+ * Returns true when `sym` is declared inside a `.d.ts` file whose path
+ * contains "react" — indicating it originates from @types/react rather than
+ * from user code that happens to use the same name.
+ *
+ * Also returns true when the symbol has NO declarations at all: this happens
+ * when TypeScript resolves the type as `any` because the source module (e.g.
+ * @types/react) is not included in the tsconfig `types` array.  A symbol with
+ * no declarations cannot be a user-defined type, so treating it as "from
+ * React" is safe — it avoids flagging props that would otherwise be excluded
+ * once the types are properly wired.
+ */
+function isSymbolFromReactDeclarationFile(sym) {
+    const declarations = sym.declarations;
+    // No declarations ⟹ the type was resolved from an unresolvable external
+    // module (common when @types/react is absent from the tsconfig types list).
+    // User-defined types always have at least one declaration.
+    if (!declarations || declarations.length === 0)
+        return true;
+    return declarations.some((decl) => {
+        const fileName = decl.getSourceFile?.()?.fileName ?? '';
+        return fileName.endsWith('.d.ts') && /react/i.test(fileName);
+    });
+}
+/**
+ * Returns true when `type` is a React render-related type that should be
+ * excluded from the "complex prop" check.  Detects by matching the type's
+ * alias symbol or own symbol name against a known React-type allowlist AND
+ * verifying the matched symbol's declaration originates from a React `.d.ts`
+ * file to avoid false negatives for user types that coincidentally share the
+ * same name.
+ */
+function isReactRenderType(type) {
+    // Check the aliasSymbol first (covers type aliases like ReactNode, FC, etc.)
+    const aliasSymbol = type
+        .aliasSymbol;
+    if (aliasSymbol) {
+        const name = aliasSymbol.escapedName;
+        if (REACT_RENDER_TYPE_NAMES.has(name) &&
+            isSymbolFromReactDeclarationFile(aliasSymbol)) {
+            return true;
+        }
+    }
+    // Check the type's own symbol (covers interfaces / classes like ReactElement,
+    // ComponentClass, ForwardRefExoticComponent, etc.)
+    const sym = type.symbol;
+    if (sym) {
+        const name = sym.escapedName;
+        if (REACT_RENDER_TYPE_NAMES.has(name) &&
+            isSymbolFromReactDeclarationFile(sym)) {
+            return true;
+        }
+    }
+    return false;
+}
 function isComplexType(ts, type, checker) {
     return isComplexTypeInternal(ts, type, checker, new Set());
 }
@@ -293,6 +401,13 @@ function isComplexTypeInternal(ts, type, checker, visited) {
     if (visited.has(type))
         return false;
     visited.add(type);
+    // Exclude React render-related types before any structural checks.
+    // This must come early so that ReactElement (an object type) and ReactNode
+    // (a union containing ReactElement) are both short-circuited here rather
+    // than being caught by the isObjectType / checkUnionType branches below.
+    if (isReactRenderType(type)) {
+        return false;
+    }
     const flags = type.flags ?? 0;
     if (isUnionType(ts, flags)) {
         return checkUnionType(ts, type, checker, visited);
@@ -379,13 +494,72 @@ function extractAnnotationType(propDeclaration) {
     }
     return undefined;
 }
-function shouldTreatAnyAsComplex(prop, propType, ts, treatAnyAsComplex, parentTypeFlags) {
+/**
+ * Returns true when an annotation TypeNode (the explicit type written in
+ * source, e.g. `React.ComponentType` or `React.ReactNode | null`) resolves to
+ * a React render type that must be excluded from the complex-prop check.
+ *
+ * This path is taken when the prop type resolves to `any` (common when
+ * @types/react is not listed in the tsconfig `types` array) but the
+ * annotation still carries the original alias name via the TypeScript
+ * type-checker.
+ *
+ * For union annotation nodes (e.g. `ReactNode | null`), all non-null /
+ * non-undefined members must themselves be React render types for the whole
+ * union to be considered a React render type.
+ */
+function isAnnotationReactRenderType(annotationType, checker, ts) {
+    try {
+        const tsModule = ts;
+        // Handle union annotation nodes like `React.ReactNode | null`.
+        if (tsModule.isUnionTypeNode?.(annotationType)) {
+            const nonNullishMembers = annotationType.types.filter((member) => {
+                // Nullish keywords appearing directly (older TypeScript AST forms)
+                if (member.kind === tsModule.SyntaxKind.NullKeyword ||
+                    member.kind === tsModule.SyntaxKind.UndefinedKeyword ||
+                    member.kind === tsModule.SyntaxKind.VoidKeyword) {
+                    return false;
+                }
+                // `null` and `undefined` appear as LiteralTypeNode wrapping the
+                // corresponding keyword in modern TypeScript AST.
+                if (tsModule.isLiteralTypeNode?.(member)) {
+                    const lit = member.literal;
+                    if (lit.kind === tsModule.SyntaxKind.NullKeyword ||
+                        lit.kind === tsModule.SyntaxKind.UndefinedKeyword) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+            // If every non-nullish member is a React render type, the union is too.
+            return (nonNullishMembers.length > 0 &&
+                nonNullishMembers.every((member) => isAnnotationReactRenderType(member, checker, ts)));
+        }
+        // For plain TypeReference nodes (the common case), resolve via the checker.
+        const resolvedType = checker.getTypeFromTypeNode?.(annotationType);
+        if (!resolvedType)
+            return false;
+        return isReactRenderType(resolvedType);
+    }
+    catch {
+        return false;
+    }
+}
+function shouldTreatAnyAsComplex(prop, propType, ts, treatAnyAsComplex, parentTypeFlags, checker) {
     if (!(propType.flags & ts.TypeFlags.Any))
         return false;
     if (treatAnyAsComplex)
         return true;
     const propDeclaration = extractPropertyDeclaration(prop);
     const annotationType = extractAnnotationType(propDeclaration);
+    // When the annotation resolves to a React render type, the prop is a
+    // stable component/render-prop reference that does not benefit from deep
+    // value comparison — exclude it regardless of the any-as-complex heuristic.
+    if (annotationType &&
+        checker &&
+        isAnnotationReactRenderType(annotationType, checker, ts)) {
+        return false;
+    }
     return ((annotationType && annotationType.kind !== ts.SyntaxKind.AnyKeyword) ||
         (!annotationType && Boolean(parentTypeFlags & ts.TypeFlags.Object)));
 }
@@ -394,13 +568,13 @@ function isPropertyComplex(prop, checker, tsNode, ts, treatAnyAsComplex, parentT
     if (isComplexType(ts, propType, checker)) {
         return true;
     }
-    return shouldTreatAnyAsComplex(prop, propType, ts, treatAnyAsComplex, parentTypeFlags);
+    return shouldTreatAnyAsComplex(prop, propType, ts, treatAnyAsComplex, parentTypeFlags, checker);
 }
 function getComplexPropertiesFromType(type, checker, tsNode, ts, treatAnyAsComplex = false, parentTypeFlags = 0) {
     const properties = checker.getPropertiesOfType(type);
     const complexProps = [];
     for (const prop of properties) {
-        if (prop.name === 'children')
+        if (isReservedReactPropName(prop.name))
             continue;
         if (isPropertyComplex(prop, checker, tsNode, ts, treatAnyAsComplex, parentTypeFlags)) {
             complexProps.push(prop.name);
@@ -733,13 +907,16 @@ exports.memoCompareDeeplyComplexProps = (0, createRule_1.createRule)({
             const comparatorArg = node.arguments[1];
             return { memoCall, componentArg, comparatorArg };
         }
-        function analyzeComponentAndProps(componentArg, comparatorArg, currentScope) {
+        function analyzeComponentAndProps(componentArg, comparatorArg, currentScope, memoSource) {
             const componentTargets = findComponentAnalysisTargets(componentArg, (name) => initializerTracking.getInitializer(name, currentScope));
             if (!componentTargets)
                 return null;
             if (isComparatorProvided(comparatorArg, currentScope))
                 return null;
-            const complexProps = collectComplexPropsForTargets(componentTargets, (expr) => collectComplexProps(expr, sourceCode, complexPropsCache));
+            let complexProps = collectComplexPropsForTargets(componentTargets, (expr) => collectComplexProps(expr, sourceCode, complexPropsCache));
+            if (isUtilMemoModulePath(memoSource)) {
+                complexProps = complexProps.filter((prop) => !isDefaultDeepCompareProp(prop));
+            }
             if (complexProps.length === 0)
                 return null;
             const componentName = resolveComponentName(componentTargets, componentArg);
@@ -763,7 +940,7 @@ exports.memoCompareDeeplyComplexProps = (0, createRule_1.createRule)({
                     return;
                 const { memoCall, componentArg, comparatorArg } = validationResult;
                 const currentScope = context.getScope();
-                const analysisResult = analyzeComponentAndProps(componentArg, comparatorArg, currentScope);
+                const analysisResult = analyzeComponentAndProps(componentArg, comparatorArg, currentScope, memoCall.source);
                 if (!analysisResult)
                     return;
                 const { complexProps, componentName } = analysisResult;