@taiga-ui/eslint-plugin-experience-next 0.468.0 → 0.470.0

package/README.md

@@ -53,9 +53,10 @@ 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-signal-reads-after-await-in-reactive-context | Disallow signal reads after `await` inside reactive callbacks                                       | ✅  |     |     |
+| no-side-effects-in-computed                     | Disallow observable side effects 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 the synchronous body of reactive callbacks                           | ✅  | 🔧  |     |
+| no-untracked-outside-reactive-context           | Disallow `untracked()` outside reactive callbacks, except explicit post-`await` snapshots           | ✅  | 🔧  |     |
 | no-useless-untracked                            | Disallow provably useless `untracked()` wrappers in reactive callbacks                              | ✅  | 🔧  |     |
 | object-single-line                              | Enforce single-line formatting for single-property objects when it fits `printWidth`                | ✅  | 🔧  |     |
 | prefer-deep-imports                             | Allow deep imports of Taiga UI packages                                                             |     | 🔧  |     |
@@ -566,12 +567,44 @@ const doubled = computed(() => {
 
 ---
 
+## no-side-effects-in-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.
+
+```ts
+// ❌ error
+import {computed, signal} from '@angular/core';
+
+const source = signal(0);
+const target = signal(0);
+
+const derived = computed(() => {
+  target.set(source() + 1);
+  return target();
+});
+```
+
+```ts
+// ✅ ok
+import {computed, signal} from '@angular/core';
+
+const source = signal(0);
+const derived = computed(() => source() + 1);
+```
+
+---
+
 ## no-signal-reads-after-await-in-reactive-context
 
 <sup>`✅ Recommended`</sup>
 
-Angular tracks signal reads only in synchronous code. If a reactive callback crosses an async boundary, any signal read
-after `await` will not become a dependency.
+Angular tracks signal reads only in synchronous code. If a reactive callback crosses an async boundary, any bare signal
+read after `await` will not become a dependency. Snapshot before `await` when you need the earlier value, or make an
+intentional post-`await` current-value read explicit with `untracked(...)`.
 
 ```ts
 // ❌ error
@@ -588,6 +621,14 @@ effect(async () => {
 });
 ```
 
+```ts
+// ✅ ok — explicit current-value read after await
+effect(async () => {
+  await this.fetchUser();
+  console.log(untracked(this.theme));
+});
+```
+
 ---
 
 ## no-untracked-outside-reactive-context
@@ -595,14 +636,15 @@ effect(async () => {
 <sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
 
 `untracked()` usually only affects signal reads that happen inside the synchronous body of a reactive callback. In
-ordinary non-reactive code, nested callbacks, or code that runs after `await`, it usually does not prevent dependency
-tracking and only adds noise. This rule reports those cases, but intentionally allows a few imperative Angular escape
-hatches where `untracked()` can still be useful: `@Pipe().transform`, `ControlValueAccessor.writeValue`,
-`registerOnChange` including patched accessors such as `accessor.writeValue = (...) => {}`, callback-form wrappers used
-inside deferred scheduler / event-handler callbacks, and narrow lazy DI factory wrappers like
-`InjectionToken({factory})` / `useFactory` when they guard creation of a reactive owner such as `effect()` against an
-accidental ambient reactive context. For the narrow case `untracked(() => effect(...))` and similar outer wrappers
-around a reactive call in ordinary code, autofix removes only the useless outer `untracked()` wrapper.
+ordinary non-reactive code or nested callbacks it usually does not prevent dependency tracking and only adds noise. This
+rule reports those cases, but intentionally allows a few explicit escape hatches: post-`await` reads inside a reactive
+callback when `untracked()` is used to document an intentional current-value snapshot, imperative Angular hooks such as
+`@Pipe().transform`, `ControlValueAccessor.writeValue`, `registerOnChange` including patched accessors such as
+`accessor.writeValue = (...) => {}`, callback-form wrappers used inside deferred scheduler / event-handler callbacks,
+and narrow lazy DI factory wrappers like `InjectionToken({factory})` / `useFactory` when they guard creation of a
+reactive owner such as `effect()` against an accidental ambient reactive context. For the narrow case
+`untracked(() => effect(...))` and similar outer wrappers around a reactive call in ordinary code, autofix removes only
+the useless outer `untracked()` wrapper.
 
 ```ts
 // ❌ error
@@ -624,6 +666,17 @@ effect(() => {
 const snapshot = computed(() => untracked(this.user));
 ```
 
+```ts
+// ✅ ok — after await, untracked can mark an intentional current snapshot
+effect(async () => {
+  await this.refresh();
+
+  if (untracked(this.user) !== previousUser) {
+    console.log('changed');
+  }
+});
+```
+
 ```ts
 // ❌ error
 untracked(() => {

package/index.d.ts

@@ -53,6 +53,9 @@ declare const plugin: {
         } | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'no-side-effects-in-computed': import("@typescript-eslint/utils/ts-eslint").RuleModule<"sideEffectInComputed", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'no-signal-reads-after-await-in-reactive-context': import("@typescript-eslint/utils/ts-eslint").RuleModule<"readAfterAwait", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/index.esm.js

@@ -908,6 +908,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-fully-untracked-effect': 'error',
             '@taiga-ui/experience-next/no-implicit-public': 'error',
             '@taiga-ui/experience-next/no-redundant-type-annotation': 'error',
+            '@taiga-ui/experience-next/no-side-effects-in-computed': 'error',
             '@taiga-ui/experience-next/no-signal-reads-after-await-in-reactive-context': 'error',
             '@taiga-ui/experience-next/no-untracked-outside-reactive-context': 'error',
             '@taiga-ui/experience-next/no-useless-untracked': 'error',
@@ -1333,8 +1334,8 @@ function intersect(a, b) {
     return a.some((type) => origin.has(type));
 }
 
-const createRule$f = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$f({
+const createRule$g = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$g({
     create(context, [configs]) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1503,9 +1504,9 @@ function isExternalPureTuple(typeChecker, type) {
     return typeArgs.every((item) => isClassType(item));
 }
 
-const createRule$e = ESLintUtils.RuleCreator((name) => name);
+const createRule$f = ESLintUtils.RuleCreator((name) => name);
 const MESSAGE_ID$7 = 'spreadArrays';
-var flatExports = createRule$e({
+var flatExports = createRule$f({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1711,8 +1712,8 @@ const config$2 = {
 
 const MESSAGE_ID$5 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
-const createRule$d = ESLintUtils.RuleCreator((name) => name);
-const rule$g = createRule$d({
+const createRule$e = ESLintUtils.RuleCreator((name) => name);
+const rule$h = createRule$e({
     create(context) {
         return {
             'NewExpression[callee.name="InjectionToken"]'(node) {
@@ -1779,8 +1780,8 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const createRule$c = ESLintUtils.RuleCreator((name) => name);
-const rule$f = createRule$c({
+const createRule$d = ESLintUtils.RuleCreator((name) => name);
+const rule$g = createRule$d({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -1867,13 +1868,13 @@ const rule$f = createRule$c({
     name: 'no-deep-imports',
 });
 
-const createRule$b = ESLintUtils.RuleCreator((name) => name);
+const createRule$c = ESLintUtils.RuleCreator((name) => name);
 const resolveCacheByOptions = new WeakMap();
 const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-var noDeepImportsToIndexedPackages = createRule$b({
+var noDeepImportsToIndexedPackages = createRule$c({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -2298,7 +2299,7 @@ const AFTER_RENDER_EFFECT_PHASES = new Map([
     ['read', 'afterRenderEffect().read'],
     ['write', 'afterRenderEffect().write'],
 ]);
-function isReactiveCallback(node) {
+function isReactiveCallback$1(node) {
     return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
         node?.type === AST_NODE_TYPES.FunctionExpression);
 }
@@ -2322,7 +2323,7 @@ function isAngularCoreCall(node, program, exportedName) {
 }
 function appendFirstArgReactiveScope(scopes, call, kind) {
     const [arg] = call.arguments;
-    if (!isReactiveCallback(arg)) {
+    if (!isReactiveCallback$1(arg)) {
         return;
     }
     scopes.push({ callback: arg, kind, owner: call, reportNode: call });
@@ -2334,7 +2335,7 @@ function appendObjectPropertyReactiveScopes(scopes, call, object, labels) {
         }
         const name = getPropertyName(property);
         const label = name ? labels.get(name) : null;
-        if (!label || !isReactiveCallback(property.value)) {
+        if (!label || !isReactiveCallback$1(property.value)) {
             continue;
         }
         scopes.push({
@@ -2396,6 +2397,16 @@ function isNodeInsideSynchronousReactiveScope(node, callback) {
     });
     return found;
 }
+function isNodeAfterAsyncBoundaryInReactiveScope(node, callback) {
+    let found = false;
+    walkAfterAsyncBoundaryAst(callback, (inner) => {
+        if (inner !== node) {
+            return;
+        }
+        found = true;
+    });
+    return found;
+}
 function findEnclosingReactiveScope(node, program) {
     for (let current = node.parent; current; current = current.parent) {
         if (current.type !== AST_NODE_TYPES.CallExpression) {
@@ -2409,6 +2420,19 @@ function findEnclosingReactiveScope(node, program) {
     }
     return null;
 }
+function findEnclosingReactiveScopeAfterAsyncBoundary(node, program) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type !== AST_NODE_TYPES.CallExpression) {
+            continue;
+        }
+        for (const scope of getReactiveScopes(current, program)) {
+            if (isNodeAfterAsyncBoundaryInReactiveScope(node, scope.callback)) {
+                return scope;
+            }
+        }
+    }
+    return null;
+}
 /**
  * Returns true when the TypeScript type at `node` is an Angular signal type.
  * Uses duck-typing: callable type whose name contains "Signal", or whose
@@ -2555,7 +2579,7 @@ function collectReadsInsideUntracked(root, checker, esTreeNodeToTSNodeMap, progr
     });
     return reads;
 }
-const rule$e = createUntrackedRule({
+const rule$f = createUntrackedRule({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
@@ -2641,8 +2665,8 @@ const config$1 = {
     },
 };
 
-const createRule$a = ESLintUtils.RuleCreator((name) => name);
-const rule$d = createRule$a({
+const createRule$b = ESLintUtils.RuleCreator((name) => name);
+const rule$e = createRule$b({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getClass(node);
@@ -2713,9 +2737,9 @@ function getClass(node) {
     return getClass(node.parent);
 }
 
-const createRule$9 = ESLintUtils.RuleCreator((name) => name);
+const createRule$a = ESLintUtils.RuleCreator((name) => name);
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$c = createRule$9({
+const rule$d = createRule$a({
     create(context) {
         return {
             Program(node) {
@@ -2753,8 +2777,8 @@ const rule$c = createRule$9({
     name: 'no-legacy-peer-deps',
 });
 
-const createRule$8 = ESLintUtils.RuleCreator((name) => name);
-const rule$b = createRule$8({
+const createRule$9 = ESLintUtils.RuleCreator((name) => name);
+const rule$c = createRule$9({
     create(context) {
         const services = ESLintUtils.getParserServices(context);
         const checker = services.program.getTypeChecker();
@@ -2919,7 +2943,7 @@ const config = {
     },
 };
 
-const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+const createRule$8 = ESLintUtils.RuleCreator((name) => name);
 function collectArrayExpressions(node) {
     const result = [];
     if (node.type === AST_NODE_TYPES.ArrayExpression) {
@@ -2945,7 +2969,7 @@ function collectArrayExpressions(node) {
     }
     return result;
 }
-const rule$a = createRule$7({
+const rule$b = createRule$8({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -3041,6 +3065,207 @@ const rule$a = createRule$7({
     name: 'no-redundant-type-annotation',
 });
 
+/**
+ * Strips TypeScript-only wrapper nodes that have no runtime meaning:
+ * `as` casts, non-null assertions (`!`), type assertions (`<T>expr`), and
+ * optional-chain wrappers. Iterates until no more wrappers are found.
+ */
+function unwrapExpression(expression) {
+    let current = expression;
+    let didUnwrap = true;
+    while (didUnwrap) {
+        didUnwrap = false;
+        switch (current.type) {
+            case AST_NODE_TYPES.ChainExpression:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+            case AST_NODE_TYPES.TSAsExpression:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+            case AST_NODE_TYPES.TSNonNullExpression:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+            case AST_NODE_TYPES.TSTypeAssertion:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+        }
+    }
+    return current;
+}
+
+const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+function isReactiveCallback(node) {
+    return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+        node?.type === AST_NODE_TYPES.FunctionExpression);
+}
+function unwrapMutationTarget(node) {
+    let current = node;
+    while (current.type === AST_NODE_TYPES.TSAsExpression ||
+        current.type === AST_NODE_TYPES.TSNonNullExpression ||
+        current.type === AST_NODE_TYPES.TSTypeAssertion) {
+        current = current.expression;
+    }
+    return current;
+}
+function collectMutationTargets(node) {
+    const current = unwrapMutationTarget(node);
+    switch (current.type) {
+        case AST_NODE_TYPES.ArrayPattern:
+            return current.elements.flatMap((element) => element ? collectMutationTargets(element) : []);
+        case AST_NODE_TYPES.AssignmentPattern:
+            return collectMutationTargets(current.left);
+        case AST_NODE_TYPES.Identifier:
+            return [current];
+        case AST_NODE_TYPES.MemberExpression:
+            return [current];
+        case AST_NODE_TYPES.ObjectPattern:
+            return current.properties.flatMap((property) => {
+                if (property.type === AST_NODE_TYPES.RestElement) {
+                    return collectMutationTargets(property.argument);
+                }
+                return collectMutationTargets(property.value);
+            });
+        case AST_NODE_TYPES.RestElement:
+            return collectMutationTargets(current.argument);
+        default:
+            return [];
+    }
+}
+function getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap) {
+    const tsNode = esTreeNodeToTSNodeMap.get(node);
+    if (!tsNode) {
+        return null;
+    }
+    return checker.getSymbolAtLocation(tsNode) ?? null;
+}
+function isLocalIdentifier(node, context) {
+    const symbol = getSymbolAtNode(node, context.checker, context.esTreeNodeToTSNodeMap);
+    if (!symbol) {
+        return false;
+    }
+    return (symbol.declarations ?? []).some((declaration) => {
+        const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
+        return (!!estreeDeclaration &&
+            isNodeInsideSynchronousReactiveScope(estreeDeclaration, context.callback));
+    });
+}
+function isLocallyCreatedExpression(node, context) {
+    const expression = unwrapExpression(node);
+    switch (expression.type) {
+        case AST_NODE_TYPES.ArrayExpression:
+        case AST_NODE_TYPES.NewExpression:
+        case AST_NODE_TYPES.ObjectExpression:
+            return true;
+        case AST_NODE_TYPES.Identifier:
+            return isLocalIdentifier(expression, context);
+        case AST_NODE_TYPES.MemberExpression:
+            return isLocallyCreatedExpression(expression.object, context);
+        default:
+            return false;
+    }
+}
+function hasObservableMutationTarget(node, context) {
+    return collectMutationTargets(node).some((target) => {
+        if (target.type === AST_NODE_TYPES.Identifier) {
+            return !isLocalIdentifier(target, context);
+        }
+        return !isLocallyCreatedExpression(target.object, context);
+    });
+}
+function reportSideEffect(node, inspectionContext, report) {
+    const key = String(node.range);
+    if (inspectionContext.reported.has(key)) {
+        return;
+    }
+    inspectionContext.reported.add(key);
+    report(node);
+}
+function inspectComputedBody(root, inspectionContext, report) {
+    walkSynchronousAst(root, (node) => {
+        if (node.type === AST_NODE_TYPES.CallExpression) {
+            if (isWritableSignalWrite(node, inspectionContext.checker, inspectionContext.esTreeNodeToTSNodeMap)) {
+                reportSideEffect(node, inspectionContext, report);
+            }
+            if (isAngularUntrackedCall(node, inspectionContext.program)) {
+                const [arg] = node.arguments;
+                if (isReactiveCallback(arg)) {
+                    inspectComputedBody(arg, inspectionContext, report);
+                }
+                return false;
+            }
+            if (node.callee.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+                node.callee.type === AST_NODE_TYPES.FunctionExpression) {
+                inspectComputedBody(node.callee, inspectionContext, report);
+                return false;
+            }
+        }
+        if (node.type === AST_NODE_TYPES.AssignmentExpression &&
+            hasObservableMutationTarget(node.left, inspectionContext)) {
+            reportSideEffect(node.left, inspectionContext, report);
+        }
+        if (node.type === AST_NODE_TYPES.UpdateExpression &&
+            hasObservableMutationTarget(node.argument, inspectionContext)) {
+            reportSideEffect(node.argument, inspectionContext, report);
+        }
+        if (node.type === AST_NODE_TYPES.UnaryExpression &&
+            node.operator === 'delete' &&
+            hasObservableMutationTarget(node.argument, inspectionContext)) {
+            reportSideEffect(node.argument, inspectionContext, report);
+        }
+        return;
+    });
+}
+const rule$a = createRule$7({
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
+        const tsNodeToESTreeNodeMap = parserServices.tsNodeToESTreeNodeMap;
+        const { sourceCode } = context;
+        const program = sourceCode.ast;
+        return {
+            CallExpression(node) {
+                for (const scope of getReactiveScopes(node, program)) {
+                    if (scope.kind !== 'computed()') {
+                        continue;
+                    }
+                    const inspectionContext = {
+                        callback: scope.callback,
+                        checker,
+                        esTreeNodeToTSNodeMap,
+                        program,
+                        reported: new Set(),
+                        tsNodeToESTreeNodeMap,
+                    };
+                    inspectComputedBody(scope.callback, inspectionContext, (reportNode) => {
+                        context.report({
+                            data: { expression: sourceCode.getText(reportNode) },
+                            messageId: 'sideEffectInComputed',
+                            node: reportNode,
+                        });
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow observable side effects inside `computed()` callbacks so derivations stay pure',
+            url: 'https://angular.dev/guide/signals',
+        },
+        messages: {
+            sideEffectInComputed: '`{{ expression }}` causes a side effect inside `computed()`. Keep computed derivations pure and move state changes to `effect()` or outside the computation.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-side-effects-in-computed',
+});
+
 const rule$9 = createUntrackedRule({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
@@ -3054,6 +3279,7 @@ const rule$9 = createUntrackedRule({
                     const reported = new Set();
                     walkAfterAsyncBoundaryAst(scope.callback, (inner) => {
                         if (inner.type !== AST_NODE_TYPES.CallExpression ||
+                            isAngularUntrackedCall(inner, program) ||
                             !isSignalReadCall(inner, checker, esTreeNodeToTSNodeMap)) {
                             return;
                         }
@@ -3077,11 +3303,11 @@ const rule$9 = createUntrackedRule({
     },
     meta: {
         docs: {
-            description: 'Disallow signal reads that occur after `await` inside reactive callbacks, because Angular no longer tracks them as dependencies',
+            description: 'Disallow bare signal reads that occur after `await` inside reactive callbacks, because Angular no longer tracks them as dependencies',
             url: ANGULAR_SIGNALS_ASYNC_GUIDE_URL,
         },
         messages: {
-            readAfterAwait: '`{{ name }}` is read after `await` inside `{{ kind }}`. Angular only tracks synchronous signal reads, so this dependency will not be tracked. Read it before `await` and store the snapshot. See Angular guide: https://angular.dev/guide/signals#reactive-context-and-async-operations',
+            readAfterAwait: '`{{ name }}` is read after `await` inside `{{ kind }}`. Angular only tracks synchronous signal reads, so this dependency will not be tracked. Read it before `await` and store the snapshot, or wrap the post-`await` read in `untracked(...)` when you intentionally need the current value at that point. See Angular guide: https://angular.dev/guide/signals#reactive-context-and-async-operations',
         },
         schema: [],
         type: 'problem',
@@ -3600,7 +3826,8 @@ const rule$7 = createUntrackedRule({
                 if (!isAngularUntrackedCall(node, program)) {
                     return;
                 }
-                if (findEnclosingReactiveScope(node, program)) {
+                if (findEnclosingReactiveScope(node, program) ||
+                    findEnclosingReactiveScopeAfterAsyncBoundary(node, program)) {
                     return;
                 }
                 if (isAllowedImperativeAngularContext(node)) {
@@ -3638,12 +3865,12 @@ const rule$7 = createUntrackedRule({
     },
     meta: {
         docs: {
-            description: 'Disallow `untracked()` outside the synchronous body of a reactive callback, except for supported imperative Angular hooks, deferred callback wrappers, and lazy DI factories that may execute under an ambient reactive context',
+            description: 'Disallow `untracked()` outside reactive callbacks, except for synchronous reactive reads, explicit post-`await` snapshot reads, and supported imperative/deferred/lazy-factory Angular escape hatches',
             url: ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL,
         },
         fixable: 'code',
         messages: {
-            outsideReactiveContext: '`untracked()` is used outside the synchronous body of a reactive callback and outside the supported imperative/deferred/lazy-factory exceptions, so it does not prevent dependency tracking and only adds noise. Remove it. See Angular guide: https://angular.dev/guide/signals#reading-without-tracking-dependencies',
+            outsideReactiveContext: '`untracked()` is used outside a reactive callback and outside the supported post-`await` / imperative / deferred / lazy-factory exceptions, so it does not prevent dependency tracking and only adds noise. Remove it. See Angular guide: https://angular.dev/guide/signals#reading-without-tracking-dependencies',
         },
         schema: [],
         type: 'problem',
@@ -3819,38 +4046,6 @@ const rule$6 = createUntrackedRule({
     name: 'no-useless-untracked',
 });
 
-/**
- * Strips TypeScript-only wrapper nodes that have no runtime meaning:
- * `as` casts, non-null assertions (`!`), type assertions (`<T>expr`), and
- * optional-chain wrappers. Iterates until no more wrappers are found.
- */
-function unwrapExpression(expression) {
-    let current = expression;
-    let didUnwrap = true;
-    while (didUnwrap) {
-        didUnwrap = false;
-        switch (current.type) {
-            case AST_NODE_TYPES.ChainExpression:
-                current = current.expression;
-                didUnwrap = true;
-                break;
-            case AST_NODE_TYPES.TSAsExpression:
-                current = current.expression;
-                didUnwrap = true;
-                break;
-            case AST_NODE_TYPES.TSNonNullExpression:
-                current = current.expression;
-                didUnwrap = true;
-                break;
-            case AST_NODE_TYPES.TSTypeAssertion:
-                current = current.expression;
-                didUnwrap = true;
-                break;
-        }
-    }
-    return current;
-}
-
 const createRule$5 = ESLintUtils.RuleCreator((name) => name);
 const rule$5 = createRule$5({
     create(context, [{ printWidth }]) {
@@ -5415,16 +5610,17 @@ const plugin = {
         'decorator-key-sort': config$3,
         'flat-exports': flatExports,
         'html-logical-properties': config$2,
-        'injection-token-description': rule$g,
-        'no-deep-imports': rule$f,
+        'injection-token-description': rule$h,
+        'no-deep-imports': rule$g,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
-        'no-fully-untracked-effect': rule$e,
+        'no-fully-untracked-effect': rule$f,
         'no-href-with-router-link': config$1,
-        'no-implicit-public': rule$d,
-        'no-legacy-peer-deps': rule$c,
-        'no-playwright-empty-fill': rule$b,
+        'no-implicit-public': rule$e,
+        'no-legacy-peer-deps': rule$d,
+        'no-playwright-empty-fill': rule$c,
         'no-project-as-in-ng-template': config,
-        'no-redundant-type-annotation': rule$a,
+        'no-redundant-type-annotation': rule$b,
+        'no-side-effects-in-computed': rule$a,
         'no-signal-reads-after-await-in-reactive-context': rule$9,
         'no-string-literal-concat': rule$8,
         'no-untracked-outside-reactive-context': rule$7,

package/package.json

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

package/rules/no-side-effects-in-computed.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const rule: ESLintUtils.RuleModule<"sideEffectInComputed", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default rule;

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

@@ -20,7 +20,9 @@ export declare function isAngularEffectCall(node: TSESTree.CallExpression, progr
 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;
+export declare function isNodeAfterAsyncBoundaryInReactiveScope(node: TSESTree.Node, callback: ReactiveCallback): boolean;
 export declare function findEnclosingReactiveScope(node: TSESTree.Node, program: TSESTree.Program): ReactiveScope | null;
+export declare function findEnclosingReactiveScopeAfterAsyncBoundary(node: TSESTree.Node, program: TSESTree.Program): ReactiveScope | null;
 /**
  * Returns true when the TypeScript type at `node` is an Angular signal type.
  * Uses duck-typing: callable type whose name contains "Signal", or whose