@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/extract-global-constants.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractGlobalConstants = void 0;
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
 function isInsideFunction(node) {
     let current = node;
     while (current) {
@@ -19,53 +20,61 @@ function isFunctionDefinition(node) {
     return (node?.type === 'FunctionExpression' ||
         node?.type === 'ArrowFunctionExpression');
 }
-function isImmutableValue(node) {
+const unwrapOnce = (node) => {
     if (!node)
-        return false;
+        return null;
+    const maybeParen = node;
+    if (maybeParen.type === 'ParenthesizedExpression') {
+        return maybeParen.expression ?? null;
+    }
     switch (node.type) {
-        case 'Literal':
-            return true;
-        case 'TemplateLiteral':
-            return node.expressions.length === 0;
-        case 'UnaryExpression':
-            return isImmutableValue(node.argument);
-        case 'BinaryExpression':
-            if (node.left.type === 'PrivateIdentifier')
-                return false;
-            return isImmutableValue(node.left) && isImmutableValue(node.right);
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+        case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+        case utils_1.AST_NODE_TYPES.ChainExpression:
+        case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+            return node.expression;
         default:
-            return false;
+            return null;
+    }
+};
+function unwrapExpression(node) {
+    let current = node;
+    while (current) {
+        const inner = unwrapOnce(current);
+        if (!inner)
+            break;
+        current = inner;
     }
+    return current;
 }
 function isMutableValue(node) {
-    if (!node)
+    const unwrapped = unwrapExpression(node);
+    if (!unwrapped)
+        return false;
+    // If explicitly marked readonly with `as const`, treat as immutable
+    if (node && isAsConstExpression(node)) {
         return false;
+    }
     // Check for JSX elements (always mutable due to props/context)
-    if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
+    if (unwrapped.type === 'JSXElement' || unwrapped.type === 'JSXFragment') {
         return true;
     }
     // Check for object expressions (always mutable)
-    if (node.type === 'ObjectExpression') {
+    if (unwrapped.type === 'ObjectExpression') {
         return true;
     }
-    // Check array literals - mutable if empty or if they contain mutable values
-    if (node.type === 'ArrayExpression') {
-        // Empty arrays are mutable since they can be modified later
-        if (node.elements.length === 0)
-            return true;
-        // Arrays with spread elements are mutable
-        if (node.elements.some((element) => !element || element.type === 'SpreadElement'))
-            return true;
-        // Arrays with non-immutable values are mutable
-        return node.elements.some((element) => !isImmutableValue(element));
+    // Arrays are mutable objects unless explicitly narrowed with `as const`.
+    if (unwrapped.type === 'ArrayExpression') {
+        return true;
     }
     // Check for new expressions (e.g., new Map(), new Set())
-    if (node.type === 'NewExpression') {
+    if (unwrapped.type === 'NewExpression') {
         return true;
     }
     // Check for array/object methods that return mutable values
-    if (node.type === 'CallExpression') {
-        const callee = node.callee;
+    if (unwrapped.type === 'CallExpression') {
+        const callee = unwrapped.callee;
         if (callee.type === 'MemberExpression') {
             // Handle both Identifier and non-Identifier property nodes
             if (callee.property.type !== 'Identifier') {
@@ -103,17 +112,31 @@ function isZeroOrOne(node) {
     return value === 0 || value === 1;
 }
 function isAsConstExpression(node) {
-    if (!node)
-        return false;
-    if (node.type === 'TSAsExpression') {
-        if (node.typeAnnotation.type === 'TSTypeReference' &&
-            node.typeAnnotation.typeName.type === 'Identifier' &&
-            node.typeAnnotation.typeName.name === 'const') {
+    let current = node;
+    while (current) {
+        if (current.type === 'TSAsExpression' &&
+            current.typeAnnotation.type === 'TSTypeReference' &&
+            current.typeAnnotation.typeName.type === 'Identifier' &&
+            current.typeAnnotation.typeName.name === 'const') {
             return true;
         }
+        current = unwrapOnce(current);
     }
     return false;
 }
+function analyzeDeclarator(declaration) {
+    const init = declaration.init ?? null;
+    const isFunctionOrMutable = isFunctionDefinition(init) || isMutableValue(init);
+    return {
+        isFunctionOrMutable,
+        hasDependencies: !isFunctionOrMutable && init
+            ? ASTHelpers_1.ASTHelpers.declarationIncludesIdentifier(init)
+            : false,
+        hasAsConstAssertion: !isFunctionOrMutable && init ? isAsConstExpression(init) : false,
+        hasReportableIdentifier: declaration.id?.type === utils_1.AST_NODE_TYPES.Identifier &&
+            !isFunctionOrMutable,
+    };
+}
 exports.extractGlobalConstants = (0, createRule_1.createRule)({
     create(context) {
         return {
@@ -121,29 +144,45 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                 if (node.kind !== 'const') {
                     return;
                 }
-                // Skip if any of the declarations are function definitions or mutable values
-                if (node.declarations.some((d) => isFunctionDefinition(d.init) || isMutableValue(d.init))) {
+                const declarations = node.declarations.filter((declaration) => declaration !== null && declaration !== undefined);
+                if (declarations.length === 0) {
+                    return;
+                }
+                let hasFunctionOrMutableValue = false;
+                let hasDependencies = false;
+                let hasAsConstAssertion = false;
+                let hasReportableIdentifierDeclaration = false;
+                for (const declaration of declarations) {
+                    const analysis = analyzeDeclarator(declaration);
+                    if (analysis.isFunctionOrMutable) {
+                        hasFunctionOrMutableValue = true;
+                        break;
+                    }
+                    hasDependencies ||= analysis.hasDependencies;
+                    hasAsConstAssertion ||= analysis.hasAsConstAssertion;
+                    hasReportableIdentifierDeclaration ||=
+                        analysis.hasReportableIdentifier;
+                }
+                if (hasFunctionOrMutableValue) {
                     return;
                 }
                 const scope = context.getScope();
-                const hasDependencies = node.declarations.some((declaration) => declaration.init &&
-                    ASTHelpers_1.ASTHelpers.declarationIncludesIdentifier(declaration.init));
-                // Skip constants with 'as const' type assertions used in loops
-                const hasAsConstAssertion = node.declarations.some((declaration) => declaration.init && isAsConstExpression(declaration.init));
                 // Only check function/block scoped constants without dependencies
                 if (!hasDependencies &&
                     !hasAsConstAssertion &&
                     (scope.type === 'function' || scope.type === 'block') &&
-                    isInsideFunction(node)) {
-                    const constName = node.declarations[0].id
-                        .name;
-                    context.report({
-                        node,
-                        messageId: 'extractGlobalConstants',
-                        data: {
-                            declarationName: constName,
-                        },
-                    });
+                    isInsideFunction(node) &&
+                    hasReportableIdentifierDeclaration) {
+                    for (const declaration of declarations) {
+                        if (declaration.id?.type !== utils_1.AST_NODE_TYPES.Identifier)
+                            continue;
+                        const constName = declaration.id.name;
+                        context.report({
+                            node: declaration,
+                            messageId: 'extractGlobalConstants',
+                            data: { declarationName: constName },
+                        });
+                    }
                 }
             },
             FunctionDeclaration(node) {
@@ -271,8 +310,8 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            extractGlobalConstants: 'Move this declaration {{ declarationName }} to the global scope and rename it to UPPER_SNAKE_CASE if necessary.',
-            requireAsConst: 'Numeric literal {{ value }} in loop expression should be extracted to a constant with "as const" type assertion.',
+            extractGlobalConstants: 'What\'s wrong: Declaration "{{declarationName}}" does not reference values from this scope.\nWhy it matters: Keeping it nested recreates the same constant/helper on every call, which adds avoidable allocations and obscures that the value can be shared.\nHow to fix: Hoist it to module scope (use UPPER_SNAKE_CASE for immutable constants) so it is created once and can be imported.',
+            requireAsConst: 'What\'s wrong: Numeric literal {{value}} is used directly as a loop boundary.\nWhy it matters: Without "as const", TypeScript widens it to number, so if you later extract or reuse the value you lose the literal-type boundary and it is easier for related loops to drift out of sync.\nHow to fix: Extract it to a named constant with "as const" (or add "as const" inline) to keep the boundary explicit and reusable.',
         },
     },
     defaultOptions: [],

package/lib/rules/fast-deep-equal-over-microdiff.d.ts

@@ -1,3 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'useFastDeepEqual' | 'addFastDeepEqualImport';
-export declare const fastDeepEqualOverMicrodiff: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const fastDeepEqualOverMicrodiff: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
 export {};