@taiga-ui/eslint-plugin-experience-next 0.473.0 → 0.474.0

package/README.md

@@ -54,7 +54,7 @@ export default [
 | no-playwright-empty-fill                        | Enforce `clear()` over `fill('')` in Playwright tests                                               | ✅  | 🔧  |     |
 | no-project-as-in-ng-template                    | `ngProjectAs` has no effect inside `<ng-template>` or dynamic outlets                               | ✅  |     |     |
 | no-redundant-type-annotation                    | Disallow redundant type annotations when the type is already inferred from the initializer          | ✅  | 🔧  |     |
-| no-side-effects-in-computed                     | Disallow observable side effects inside Angular `computed()` callbacks                              | ✅  |     |     |
+| no-side-effects-in-computed                     | Disallow side effects and effectful helper calls inside Angular `computed()` callbacks              | ✅  |     |     |
 | no-signal-reads-after-await-in-reactive-context | Disallow bare signal reads after `await` inside reactive callbacks                                  | ✅  |     |     |
 | no-string-literal-concat                        | Disallow string literal concatenation; merge adjacent literals into one                             | ✅  | 🔧  |     |
 | no-untracked-outside-reactive-context           | Disallow `untracked()` outside reactive callbacks, except explicit post-`await` snapshots           | ✅  | 🔧  |     |
@@ -681,8 +681,9 @@ const doubled = computed(() => {
 <sup>`✅ Recommended`</sup>
 
 `computed()` should only derive a value from its inputs. This rule reports observable side effects inside Angular
-`computed()` callbacks, including signal writes (`.set()`, `.update()`, `.mutate()`), assignments to captured state,
-`++/--`, `delete`, and property mutations on objects that were not created inside the computation itself.
+`computed()` callbacks, including signal writes (`.set()`, `.update()`, `.mutate()`), `effect()`, `inject()`,
+assignments to captured state, `++/--`, `delete`, property mutations on objects that were not created inside the
+computation itself, and calls to local helper functions or methods when their bodies perform those operations.
 
 ```ts
 // ❌ error
@@ -691,8 +692,12 @@ import {computed, signal} from '@angular/core';
 const source = signal(0);
 const target = signal(0);
 
-const derived = computed(() => {
+function syncTarget(): void {
   target.set(source() + 1);
+}
+
+const derived = computed(() => {
+  syncTarget();
   return target();
 });
 ```

package/index.esm.js

@@ -2718,6 +2718,9 @@ function appendObjectPropertyReactiveScopes(scopes, call, object, labels) {
 function isAngularEffectCall(node, program) {
     return isAngularCoreCall(node, program, 'effect');
 }
+function isAngularInjectCall(node, program) {
+    return isAngularCoreCall(node, program, 'inject');
+}
 function isAngularUntrackedCall(node, program) {
     return isAngularCoreCall(node, program, 'untracked');
 }
@@ -3463,6 +3466,11 @@ function unwrapExpression(expression) {
 }
 
 const createRule$8 = ESLintUtils.RuleCreator((name) => name);
+function isFunctionLikeScope(node) {
+    return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+        node?.type === AST_NODE_TYPES.FunctionDeclaration ||
+        node?.type === AST_NODE_TYPES.FunctionExpression);
+}
 function isReactiveCallback(node) {
     return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
         node?.type === AST_NODE_TYPES.FunctionExpression);
@@ -3507,7 +3515,7 @@ function getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap) {
     }
     return checker.getSymbolAtLocation(tsNode) ?? null;
 }
-function isLocalIdentifier(node, context) {
+function isLocalIdentifier(node, context, localScopes) {
     const symbol = getSymbolAtNode(node, context.checker, context.esTreeNodeToTSNodeMap);
     if (!symbol) {
         return false;
@@ -3515,10 +3523,24 @@ function isLocalIdentifier(node, context) {
     return (symbol.declarations ?? []).some((declaration) => {
         const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
         return (!!estreeDeclaration &&
-            isNodeInsideSynchronousReactiveScope(estreeDeclaration, context.callback));
+            isDeclaredInsideLocalScope(estreeDeclaration, localScopes));
     });
 }
-function isLocallyCreatedExpression(node, context) {
+function isDeclaredInsideLocalScope(node, localScopes) {
+    return localScopes.some((scope) => isNodeInsideFunctionScope(node, scope));
+}
+function isNodeInsideFunctionScope(node, scope) {
+    let found = false;
+    walkSynchronousAst(scope, (inner) => {
+        if (inner !== node) {
+            return;
+        }
+        found = true;
+        return false;
+    });
+    return found;
+}
+function isLocallyCreatedExpression(node, context, localScopes) {
     const expression = unwrapExpression(node);
     switch (expression.type) {
         case AST_NODE_TYPES.ArrayExpression:
@@ -3526,60 +3548,222 @@ function isLocallyCreatedExpression(node, context) {
         case AST_NODE_TYPES.ObjectExpression:
             return true;
         case AST_NODE_TYPES.Identifier:
-            return isLocalIdentifier(expression, context);
+            return isLocalIdentifier(expression, context, localScopes);
         case AST_NODE_TYPES.MemberExpression:
-            return isLocallyCreatedExpression(expression.object, context);
+            return isLocallyCreatedExpression(expression.object, context, localScopes);
         default:
             return false;
     }
 }
-function hasObservableMutationTarget(node, context) {
+function hasObservableMutationTarget(node, context, localScopes) {
     return collectMutationTargets(node).some((target) => {
         if (target.type === AST_NODE_TYPES.Identifier) {
-            return !isLocalIdentifier(target, context);
+            return !isLocalIdentifier(target, context, localScopes);
         }
-        return !isLocallyCreatedExpression(target.object, context);
+        return !isLocallyCreatedExpression(target.object, context, localScopes);
     });
 }
-function reportSideEffect(node, inspectionContext, report) {
+function reportSideEffect(node, context, report) {
     const key = String(node.range);
-    if (inspectionContext.reported.has(key)) {
+    if (context.reported.has(key)) {
         return;
     }
-    inspectionContext.reported.add(key);
+    context.reported.add(key);
     report(node);
 }
-function inspectComputedBody(root, inspectionContext, report) {
+function isDirectAngularSideEffectCall(node, context) {
+    return (isWritableSignalWrite(node, context.checker, context.esTreeNodeToTSNodeMap) ||
+        isAngularEffectCall(node, context.program) ||
+        isAngularInjectCall(node, context.program));
+}
+function isInspectableFunctionContainer(node) {
+    return (!!node &&
+        (isFunctionLikeScope(node) ||
+            node.type === AST_NODE_TYPES.MethodDefinition ||
+            node.type === AST_NODE_TYPES.Property ||
+            node.type === AST_NODE_TYPES.PropertyDefinition ||
+            node.type === AST_NODE_TYPES.VariableDeclarator));
+}
+function resolveFunctionLikeFromContainer(node, context, seenSymbols = new Set()) {
+    if (isFunctionLikeScope(node)) {
+        return [node];
+    }
+    if ((node.type === AST_NODE_TYPES.MethodDefinition &&
+        isFunctionLikeScope(node.value)) ||
+        (node.type === AST_NODE_TYPES.Property && isFunctionLikeScope(node.value))) {
+        return [node.value];
+    }
+    if (node.type === AST_NODE_TYPES.Property &&
+        node.value.type === AST_NODE_TYPES.Identifier) {
+        return resolveFunctionLikeFromIdentifier(node.value, context, seenSymbols);
+    }
+    if (node.type === AST_NODE_TYPES.PropertyDefinition &&
+        node.value &&
+        isFunctionLikeScope(node.value)) {
+        return [node.value];
+    }
+    if (node.type === AST_NODE_TYPES.PropertyDefinition &&
+        node.value?.type === AST_NODE_TYPES.Identifier) {
+        return resolveFunctionLikeFromIdentifier(node.value, context, seenSymbols);
+    }
+    if (node.type === AST_NODE_TYPES.VariableDeclarator) {
+        const { init } = node;
+        if (init && isFunctionLikeScope(init)) {
+            return [init];
+        }
+        if (init?.type === AST_NODE_TYPES.Identifier) {
+            return resolveFunctionLikeFromIdentifier(init, context, seenSymbols);
+        }
+    }
+    return [];
+}
+function resolveFunctionLikeFromIdentifier(node, context, seenSymbols = new Set()) {
+    const symbol = getSymbolAtNode(node, context.checker, context.esTreeNodeToTSNodeMap);
+    if (!symbol) {
+        return [];
+    }
+    const symbolId = `${symbol.name}:${symbol.declarations?.[0]?.pos ?? -1}`;
+    if (seenSymbols.has(symbolId)) {
+        return [];
+    }
+    seenSymbols.add(symbolId);
+    return (symbol.declarations ?? []).flatMap((declaration) => {
+        const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
+        if (!estreeDeclaration || !isInspectableFunctionContainer(estreeDeclaration)) {
+            return [];
+        }
+        return resolveFunctionLikeFromContainer(estreeDeclaration, context, seenSymbols);
+    });
+}
+function resolveCalledFunctions(node, context) {
+    const resolved = new Map();
+    const tsNode = context.esTreeNodeToTSNodeMap.get(node);
+    const signature = tsNode ? context.checker.getResolvedSignature(tsNode) : undefined;
+    const declarations = new Set();
+    if (signature?.declaration) {
+        declarations.add(signature.declaration);
+    }
+    const callee = unwrapExpression(node.callee);
+    if (callee.type === AST_NODE_TYPES.Identifier ||
+        callee.type === AST_NODE_TYPES.MemberExpression) {
+        const symbol = getSymbolAtNode(callee, context.checker, context.esTreeNodeToTSNodeMap);
+        for (const declaration of symbol?.declarations ?? []) {
+            declarations.add(declaration);
+        }
+    }
+    for (const declaration of declarations) {
+        const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
+        if (!estreeDeclaration || !isInspectableFunctionContainer(estreeDeclaration)) {
+            continue;
+        }
+        for (const fn of resolveFunctionLikeFromContainer(estreeDeclaration, context)) {
+            resolved.set(String(fn.range), fn);
+        }
+    }
+    return [...resolved.values()];
+}
+function functionHasObservableSideEffects(root, context, localScopes, visitedFunctions) {
+    let hasSideEffect = false;
     walkSynchronousAst(root, (node) => {
         if (node.type === AST_NODE_TYPES.CallExpression) {
-            if (isWritableSignalWrite(node, inspectionContext.checker, inspectionContext.esTreeNodeToTSNodeMap)) {
-                reportSideEffect(node, inspectionContext, report);
+            if (isDirectAngularSideEffectCall(node, context)) {
+                hasSideEffect = true;
+                return false;
+            }
+            if (isAngularUntrackedCall(node, context.program)) {
+                const [arg] = node.arguments;
+                if (isReactiveCallback(arg) &&
+                    functionHasObservableSideEffects(arg, context, [...localScopes, arg], visitedFunctions)) {
+                    hasSideEffect = true;
+                }
+                return false;
+            }
+            if (isReactiveCallback(node.callee)) {
+                if (functionHasObservableSideEffects(node.callee, context, [...localScopes, node.callee], visitedFunctions)) {
+                    hasSideEffect = true;
+                }
+                return false;
+            }
+            for (const calledFunction of resolveCalledFunctions(node, context)) {
+                const key = String(calledFunction.range);
+                if (visitedFunctions.has(key)) {
+                    continue;
+                }
+                visitedFunctions.add(key);
+                const calledFunctionHasSideEffects = functionHasObservableSideEffects(calledFunction, context, [...localScopes, calledFunction], visitedFunctions);
+                visitedFunctions.delete(key);
+                if (!calledFunctionHasSideEffects) {
+                    continue;
+                }
+                hasSideEffect = true;
+                return false;
+            }
+        }
+        if (node.type === AST_NODE_TYPES.AssignmentExpression &&
+            hasObservableMutationTarget(node.left, context, localScopes)) {
+            hasSideEffect = true;
+            return false;
+        }
+        if (node.type === AST_NODE_TYPES.UpdateExpression &&
+            hasObservableMutationTarget(node.argument, context, localScopes)) {
+            hasSideEffect = true;
+            return false;
+        }
+        if (node.type === AST_NODE_TYPES.UnaryExpression &&
+            node.operator === 'delete' &&
+            hasObservableMutationTarget(node.argument, context, localScopes)) {
+            hasSideEffect = true;
+            return false;
+        }
+        return;
+    });
+    return hasSideEffect;
+}
+function inspectComputedBody(root, context, localScopes, visitedFunctions, report) {
+    walkSynchronousAst(root, (node) => {
+        if (node.type === AST_NODE_TYPES.CallExpression) {
+            if (isDirectAngularSideEffectCall(node, context)) {
+                reportSideEffect(node, context, report);
+                return false;
             }
-            if (isAngularUntrackedCall(node, inspectionContext.program)) {
+            if (isAngularUntrackedCall(node, context.program)) {
                 const [arg] = node.arguments;
                 if (isReactiveCallback(arg)) {
-                    inspectComputedBody(arg, inspectionContext, report);
+                    inspectComputedBody(arg, context, [...localScopes, arg], visitedFunctions, report);
                 }
                 return false;
             }
-            if (node.callee.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-                node.callee.type === AST_NODE_TYPES.FunctionExpression) {
-                inspectComputedBody(node.callee, inspectionContext, report);
+            if (isReactiveCallback(node.callee)) {
+                inspectComputedBody(node.callee, context, [...localScopes, node.callee], visitedFunctions, report);
+                return false;
+            }
+            for (const calledFunction of resolveCalledFunctions(node, context)) {
+                const key = String(calledFunction.range);
+                if (visitedFunctions.has(key)) {
+                    continue;
+                }
+                visitedFunctions.add(key);
+                const calledFunctionHasSideEffects = functionHasObservableSideEffects(calledFunction, context, [...localScopes, calledFunction], visitedFunctions);
+                visitedFunctions.delete(key);
+                if (!calledFunctionHasSideEffects) {
+                    continue;
+                }
+                reportSideEffect(node, context, report);
                 return false;
             }
         }
         if (node.type === AST_NODE_TYPES.AssignmentExpression &&
-            hasObservableMutationTarget(node.left, inspectionContext)) {
-            reportSideEffect(node.left, inspectionContext, report);
+            hasObservableMutationTarget(node.left, context, localScopes)) {
+            reportSideEffect(node.left, context, report);
         }
         if (node.type === AST_NODE_TYPES.UpdateExpression &&
-            hasObservableMutationTarget(node.argument, inspectionContext)) {
-            reportSideEffect(node.argument, inspectionContext, report);
+            hasObservableMutationTarget(node.argument, context, localScopes)) {
+            reportSideEffect(node.argument, context, report);
         }
         if (node.type === AST_NODE_TYPES.UnaryExpression &&
             node.operator === 'delete' &&
-            hasObservableMutationTarget(node.argument, inspectionContext)) {
-            reportSideEffect(node.argument, inspectionContext, report);
+            hasObservableMutationTarget(node.argument, context, localScopes)) {
+            reportSideEffect(node.argument, context, report);
         }
         return;
     });
@@ -3598,15 +3782,14 @@ const rule$b = createRule$8({
                     if (scope.kind !== 'computed()') {
                         continue;
                     }
-                    const inspectionContext = {
-                        callback: scope.callback,
+                    const analysisContext = {
                         checker,
                         esTreeNodeToTSNodeMap,
                         program,
                         reported: new Set(),
                         tsNodeToESTreeNodeMap,
                     };
-                    inspectComputedBody(scope.callback, inspectionContext, (reportNode) => {
+                    inspectComputedBody(scope.callback, analysisContext, [scope.callback], new Set([String(scope.callback.range)]), (reportNode) => {
                         context.report({
                             data: { expression: sourceCode.getText(reportNode) },
                             messageId: 'sideEffectInComputed',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.473.0",
+  "version": "0.474.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "repository": {
     "type": "git",

package/rules/utils/angular-signals.d.ts

@@ -17,6 +17,7 @@ export interface SignalUsage {
     readonly writes: TSESTree.CallExpression[];
 }
 export declare function isAngularEffectCall(node: TSESTree.CallExpression, program: TSESTree.Program): boolean;
+export declare function isAngularInjectCall(node: TSESTree.CallExpression, program: TSESTree.Program): boolean;
 export declare function isAngularUntrackedCall(node: TSESTree.CallExpression, program: TSESTree.Program): boolean;
 export declare function getReactiveScopes(node: TSESTree.CallExpression, program: TSESTree.Program): ReactiveScope[];
 export declare function isNodeInsideSynchronousReactiveScope(node: TSESTree.Node, callback: ReactiveCallback): boolean;