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

package/README.md

@@ -54,9 +54,9 @@ export default [
 | 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-signal-reads-after-await-in-reactive-context | Disallow signal reads after `await` inside reactive 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                                                             |     | 🔧  |     |
@@ -602,8 +602,9 @@ const derived = computed(() => source() + 1);
 
 <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
@@ -620,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
@@ -627,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
@@ -656,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.esm.js

@@ -2397,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) {
@@ -2410,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
@@ -3256,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;
                         }
@@ -3279,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',
@@ -3802,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)) {
@@ -3840,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',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.469.0",
+  "version": "0.470.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

@@ -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