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

package/README.md

@@ -54,12 +54,13 @@ 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           | ✅  | 🔧  |     |
 | 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-combined-if-control-flow                 | Combine consecutive `if` statements that use the same `return`, `break`, `continue`, or `throw`     | ✅  | 🔧  |     |
 | prefer-deep-imports                             | Allow deep imports of Taiga UI packages                                                             |     | 🔧  |     |
 | prefer-multi-arg-push                           | Combine consecutive `.push()` calls on the same array into a single multi-argument call             | ✅  | 🔧  |     |
 | prefer-untracked-incidental-signal-reads        | Wrap likely-incidental signal reads with `untracked()` in reactive callbacks                        | ✅  | 🔧  |     |
@@ -680,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
@@ -690,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();
 });
 ```
@@ -863,6 +869,98 @@ const x = {foo: bar};
 
 ---
 
+## prefer-combined-if-control-flow
+
+<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
+
+Combine consecutive `if` statements when they have no `else` branch and use the same `return`, `break`, `continue`, or
+`throw` statement. The autofix merges their conditions with `||`, while intentionally skipping cases with intervening
+code or comments that should remain a separate control-flow boundary.
+
+```ts
+// ❌ error
+while (true) {
+  if (a) continue;
+  if (b && c) continue;
+}
+
+// ✅ after autofix
+while (true) {
+  if (a || (b && c)) continue;
+}
+```
+
+```ts
+// ❌ error
+if (a || b) {
+  return;
+}
+
+if (c) {
+  return;
+}
+
+// ✅ after autofix
+if (a || b || c) {
+  return;
+}
+```
+
+```ts
+// ❌ error
+if (isInvalid) return result;
+
+if (isLegacy && shouldStop) return result;
+
+// ✅ after autofix
+if (isInvalid || (isLegacy && shouldStop)) return result;
+```
+
+```ts
+// ❌ error
+while (true) {
+  if (isDone) break;
+  if (hasError) break;
+}
+
+// ✅ after autofix
+while (true) {
+  if (isDone || hasError) break;
+}
+```
+
+```ts
+// ❌ error
+if (isFatal) throw error;
+
+if (isExpired && shouldAbort) throw error;
+
+// ✅ after autofix
+if (isFatal || (isExpired && shouldAbort)) throw error;
+```
+
+```ts
+// not changed — different control flow
+while (true) {
+  if (isDone) continue;
+  if (hasError) break;
+}
+```
+
+```ts
+// not changed — comment keeps branches separate
+if (a) {
+  return value;
+}
+
+// explain why this branch exists
+if (b) {
+  return value;
+}
+```
+
+---
+
 ## prefer-deep-imports
 
 <sup>`Taiga-specific`</sup> <sup>`Fixable`</sup>

package/index.d.ts

@@ -81,6 +81,9 @@ declare const plugin: {
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'prefer-combined-if-control-flow': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferCombinedIfControlFlow", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'prefer-deep-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"prefer-deep-imports", [{
             importFilter: string[] | string;
             strict?: boolean;

package/index.esm.js

@@ -914,6 +914,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-untracked-outside-reactive-context': 'error',
             '@taiga-ui/experience-next/no-useless-untracked': 'error',
             '@taiga-ui/experience-next/object-single-line': ['error', { printWidth: 90 }],
+            '@taiga-ui/experience-next/prefer-combined-if-control-flow': 'error',
             '@taiga-ui/experience-next/prefer-multi-arg-push': 'error',
             '@taiga-ui/experience-next/prefer-untracked-incidental-signal-reads': 'error',
             '@taiga-ui/experience-next/prefer-untracked-signal-getter': 'error',
@@ -1335,8 +1336,8 @@ function intersect(a, b) {
     return a.some((type) => origin.has(type));
 }
 
-const createRule$h = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$h({
+const createRule$i = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$i({
     create(context, [configs]) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1505,9 +1506,9 @@ function isExternalPureTuple(typeChecker, type) {
     return typeArgs.every((item) => isClassType(item));
 }
 
-const createRule$g = ESLintUtils.RuleCreator((name) => name);
+const createRule$h = ESLintUtils.RuleCreator((name) => name);
 const MESSAGE_ID$7 = 'spreadArrays';
-var flatExports = createRule$g({
+var flatExports = createRule$h({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1667,10 +1668,7 @@ function getDecoratorMetadata(decorator, allowedNames) {
         return null;
     }
     const callee = expr.callee;
-    if (callee.type !== AST_NODE_TYPES$1.Identifier) {
-        return null;
-    }
-    if (!allowedNames.has(callee.name)) {
+    if (callee.type !== AST_NODE_TYPES$1.Identifier || !allowedNames.has(callee.name)) {
         return null;
     }
     const arg = expr.arguments[0];
@@ -1746,8 +1744,8 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const createRule$f = ESLintUtils.RuleCreator((name) => name);
-const rule$i = createRule$f({
+const createRule$g = ESLintUtils.RuleCreator((name) => name);
+const rule$j = createRule$g({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -1842,10 +1840,8 @@ function getHostObject(metadata) {
         if (property.type !== AST_NODE_TYPES$1.Property ||
             property.kind !== 'init' ||
             property.computed ||
-            property.method) {
-            continue;
-        }
-        if (getStaticPropertyName(property.key) !== 'host') {
+            property.method ||
+            getStaticPropertyName(property.key) !== 'host') {
             continue;
         }
         return property.value.type === AST_NODE_TYPES$1.ObjectExpression
@@ -2025,7 +2021,7 @@ const config$2 = {
 const MESSAGE_ID$5 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
 const NG_DEV_MODE = 'ngDevMode';
-const createRule$e = ESLintUtils.RuleCreator((name) => name);
+const createRule$f = ESLintUtils.RuleCreator((name) => name);
 function getVariableName(node) {
     if (node.parent.type !== AST_NODE_TYPES$1.VariableDeclarator) {
         return undefined;
@@ -2096,7 +2092,7 @@ function getNgDevModeDeclarationFix(program, fixer) {
     }
     return fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
 }
-const rule$h = createRule$e({
+const rule$i = createRule$f({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -2164,8 +2160,8 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-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) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -2252,13 +2248,13 @@ const rule$g = createRule$d({
     name: 'no-deep-imports',
 });
 
-const createRule$c = ESLintUtils.RuleCreator((name) => name);
+const createRule$d = 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$c({
+var noDeepImportsToIndexedPackages = createRule$d({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -2364,13 +2360,9 @@ var noDeepImportsToIndexedPackages = createRule$c({
         return {
             ImportDeclaration(node) {
                 const importSpecifier = node.source.value;
-                if (typeof importSpecifier !== 'string') {
-                    return;
-                }
-                if (!importSpecifier.includes('/')) {
-                    return;
-                }
-                if (!isExternalModuleSpecifier(importSpecifier)) {
+                if (typeof importSpecifier !== 'string' ||
+                    !importSpecifier.includes('/') ||
+                    !isExternalModuleSpecifier(importSpecifier)) {
                     return;
                 }
                 const packageRootSpecifier = getPackageRootSpecifier(importSpecifier);
@@ -2438,10 +2430,8 @@ function getPackageRootSpecifier(importSpecifier) {
     return pathParts[0] ?? importSpecifier;
 }
 function getSubpath(importSpecifier, packageRootSpecifier) {
-    if (importSpecifier === packageRootSpecifier) {
-        return null;
-    }
-    if (!importSpecifier.startsWith(`${packageRootSpecifier}/`)) {
+    if (importSpecifier === packageRootSpecifier ||
+        !importSpecifier.startsWith(`${packageRootSpecifier}/`)) {
         return null;
     }
     return importSpecifier.slice(packageRootSpecifier.length + 1);
@@ -2516,10 +2506,8 @@ function getOrderedChildren(node) {
         ];
         return children.filter((child) => child !== undefined && child !== null);
     }
-    if (node.type === AST_NODE_TYPES.BlockStatement) {
-        return node.body;
-    }
-    if (node.type === AST_NODE_TYPES.Program) {
+    if (node.type === AST_NODE_TYPES.BlockStatement ||
+        node.type === AST_NODE_TYPES.Program) {
         return node.body;
     }
     if (node.type === AST_NODE_TYPES.IfStatement) {
@@ -2580,10 +2568,7 @@ function getOrderedChildren(node) {
 function walkSynchronousAst(root, visitor) {
     traverse(root, true);
     function traverse(node, isRoot = false) {
-        if (visitor(node) === false) {
-            return false;
-        }
-        if (!isRoot && isFunctionLike$1(node)) {
+        if (visitor(node) === false || (!isRoot && isFunctionLike$1(node))) {
             return false;
         }
         if (node.type === AST_NODE_TYPES.AwaitExpression) {
@@ -2733,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');
 }
@@ -2864,10 +2852,8 @@ function isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap) {
         return false;
     }
     const { object, property } = node.callee;
-    if (property.type !== AST_NODE_TYPES.Identifier) {
-        return false;
-    }
-    if (!SIGNAL_WRITE_METHODS.has(property.name)) {
+    if (property.type !== AST_NODE_TYPES.Identifier ||
+        !SIGNAL_WRITE_METHODS.has(property.name)) {
         return false;
     }
     return isSignalType(object, checker, esTreeNodeToTSNodeMap);
@@ -2941,10 +2927,8 @@ const createUntrackedRule = ESLintUtils.RuleCreator((name) => `${UNTRACKED_RULES
 function collectReadsInsideUntracked(root, checker, esTreeNodeToTSNodeMap, program) {
     const reads = [];
     walkSynchronousAst(root, (node) => {
-        if (node.type !== AST_NODE_TYPES.CallExpression) {
-            return;
-        }
-        if (!isAngularUntrackedCall(node, program)) {
+        if (node.type !== AST_NODE_TYPES.CallExpression ||
+            !isAngularUntrackedCall(node, program)) {
             return;
         }
         const [arg] = node.arguments;
@@ -2963,7 +2947,7 @@ function collectReadsInsideUntracked(root, checker, esTreeNodeToTSNodeMap, progr
     });
     return reads;
 }
-const rule$f = createUntrackedRule({
+const rule$g = createUntrackedRule({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
@@ -3049,15 +3033,15 @@ const config$1 = {
     },
 };
 
-const createRule$b = ESLintUtils.RuleCreator((name) => name);
-const rule$e = createRule$b({
+const createRule$c = ESLintUtils.RuleCreator((name) => name);
+const rule$f = createRule$c({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getClass(node);
-            if (!classRef || node.kind === 'constructor' || !!node?.accessibility) {
-                return;
-            }
-            if (node.key?.type === AST_NODE_TYPES.PrivateIdentifier) {
+            if (!classRef ||
+                node.kind === 'constructor' ||
+                !!node?.accessibility ||
+                node.key?.type === AST_NODE_TYPES.PrivateIdentifier) {
                 return;
             }
             const name = node?.key?.name ||
@@ -3121,9 +3105,9 @@ function getClass(node) {
     return getClass(node.parent);
 }
 
-const createRule$a = ESLintUtils.RuleCreator((name) => name);
+const createRule$b = ESLintUtils.RuleCreator((name) => name);
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$d = createRule$a({
+const rule$e = createRule$b({
     create(context) {
         return {
             Program(node) {
@@ -3161,8 +3145,8 @@ const rule$d = createRule$a({
     name: 'no-legacy-peer-deps',
 });
 
-const createRule$9 = ESLintUtils.RuleCreator((name) => name);
-const rule$c = createRule$9({
+const createRule$a = ESLintUtils.RuleCreator((name) => name);
+const rule$d = createRule$a({
     create(context) {
         const services = ESLintUtils.getParserServices(context);
         const checker = services.program.getTypeChecker();
@@ -3327,7 +3311,7 @@ const config = {
     },
 };
 
-const createRule$8 = ESLintUtils.RuleCreator((name) => name);
+const createRule$9 = ESLintUtils.RuleCreator((name) => name);
 function collectArrayExpressions(node) {
     const result = [];
     if (node.type === AST_NODE_TYPES.ArrayExpression) {
@@ -3353,7 +3337,7 @@ function collectArrayExpressions(node) {
     }
     return result;
 }
-const rule$b = createRule$8({
+const rule$c = createRule$9({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -3481,7 +3465,12 @@ function unwrapExpression(expression) {
     return current;
 }
 
-const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+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);
@@ -3526,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;
@@ -3534,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 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) {
+function isLocallyCreatedExpression(node, context, localScopes) {
     const expression = unwrapExpression(node);
     switch (expression.type) {
         case AST_NODE_TYPES.ArrayExpression:
@@ -3545,65 +3548,227 @@ 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, inspectionContext.program)) {
+            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, 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;
     });
 }
-const rule$a = createRule$7({
+const rule$b = createRule$8({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
@@ -3617,15 +3782,14 @@ const rule$a = createRule$7({
                     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',
@@ -3650,7 +3814,7 @@ const rule$a = createRule$7({
     name: 'no-side-effects-in-computed',
 });
 
-const rule$9 = createUntrackedRule({
+const rule$a = createUntrackedRule({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
@@ -3699,7 +3863,7 @@ const rule$9 = createUntrackedRule({
     name: 'no-signal-reads-after-await-in-reactive-context',
 });
 
-const createRule$6 = ESLintUtils.RuleCreator((name) => name);
+const createRule$7 = ESLintUtils.RuleCreator((name) => name);
 function isStringLiteral(node) {
     return (node.type === AST_NODE_TYPES.Literal &&
         typeof node.value === 'string');
@@ -3763,7 +3927,7 @@ function hasTemplateLiteralAncestor(node) {
     }
     return false;
 }
-const rule$8 = createRule$6({
+const rule$9 = createRule$7({
     create(context) {
         const { sourceCode } = context;
         let parserServices = null;
@@ -4183,7 +4347,7 @@ function buildReactiveCallReplacement(outerUntrackedCall, reactiveCall, sourceCo
     }
     return dedent$1(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
 }
-const rule$7 = createUntrackedRule({
+const rule$8 = createUntrackedRule({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
@@ -4207,20 +4371,12 @@ const rule$7 = createUntrackedRule({
         }
         return {
             CallExpression(node) {
-                if (!isAngularUntrackedCall(node, program)) {
-                    return;
-                }
-                if (findEnclosingReactiveScope(node, program) ||
-                    findEnclosingReactiveScopeAfterAsyncBoundary(node, program)) {
-                    return;
-                }
-                if (isAllowedImperativeAngularContext(node)) {
-                    return;
-                }
-                if (isAllowedDeferredCallbackContext(node, checker, esTreeNodeToTSNodeMap)) {
-                    return;
-                }
-                if (isAllowedLazyAngularFactoryContext(node, program)) {
+                if (!isAngularUntrackedCall(node, program) ||
+                    findEnclosingReactiveScope(node, program) ||
+                    findEnclosingReactiveScopeAfterAsyncBoundary(node, program) ||
+                    isAllowedImperativeAngularContext(node) ||
+                    isAllowedDeferredCallbackContext(node, checker, esTreeNodeToTSNodeMap) ||
+                    isAllowedLazyAngularFactoryContext(node, program)) {
                     return;
                 }
                 const reactiveCall = getFixableReactiveCall(node, program);
@@ -4327,10 +4483,8 @@ function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program
             }
             return;
         }
-        if (node.type !== AST_NODE_TYPES.CallExpression) {
-            return;
-        }
-        if (isAngularUntrackedCall(node, program) ||
+        if (node.type !== AST_NODE_TYPES.CallExpression ||
+            isAngularUntrackedCall(node, program) ||
             isSignalReadCall(node, checker, esTreeNodeToTSNodeMap) ||
             isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap)) {
             return;
@@ -4340,7 +4494,7 @@ function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program
     });
     return found;
 }
-const rule$6 = createUntrackedRule({
+const rule$7 = createUntrackedRule({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
@@ -4361,14 +4515,12 @@ const rule$6 = createUntrackedRule({
                 return;
             }
             const { reads } = collectSignalUsages(arg, checker, esTreeNodeToTSNodeMap, program);
-            if (reads.length > 0) {
+            if (reads.length > 0 ||
+                hasOpaqueSynchronousCalls(arg, checker, esTreeNodeToTSNodeMap, program)) {
                 // Snapshot reads inside reactive callbacks are a valid Angular
                 // pattern even when the snapshot later influences branching.
                 return;
             }
-            if (hasOpaqueSynchronousCalls(arg, checker, esTreeNodeToTSNodeMap, program)) {
-                return;
-            }
             // Only fix when the parent is a plain ExpressionStatement so we can
             // replace statement-for-statement without breaking surrounding structure.
             const parent = untrackedCall.parent;
@@ -4430,8 +4582,8 @@ const rule$6 = createUntrackedRule({
     name: 'no-useless-untracked',
 });
 
-const createRule$5 = ESLintUtils.RuleCreator((name) => name);
-const rule$5 = createRule$5({
+const createRule$6 = ESLintUtils.RuleCreator((name) => name);
+const rule$6 = createRule$6({
     create(context, [{ printWidth }]) {
         const sourceCode = context.sourceCode;
         const getLineEndIndex = (lineStartIndex) => {
@@ -4683,6 +4835,169 @@ const rule$5 = createRule$5({
     name: 'object-single-line',
 });
 
+const createRule$5 = ESLintUtils.RuleCreator((name) => name);
+const EMPTY_ARGUMENT = '__EMPTY_ARGUMENT__';
+function getParenthesizedInner(node) {
+    const maybeNode = node;
+    if (maybeNode.type === 'ParenthesizedExpression') {
+        return maybeNode.expression ?? null;
+    }
+    return null;
+}
+function unwrapParenthesized(node) {
+    let current = node;
+    let inner = getParenthesizedInner(current);
+    while (inner) {
+        current = inner;
+        inner = getParenthesizedInner(current);
+    }
+    return current;
+}
+function isSupportedControlFlowStatement(node) {
+    return (node.type === AST_NODE_TYPES.BreakStatement ||
+        node.type === AST_NODE_TYPES.ContinueStatement ||
+        node.type === AST_NODE_TYPES.ReturnStatement ||
+        node.type === AST_NODE_TYPES.ThrowStatement);
+}
+function getControlFlowStatement(node) {
+    if (isSupportedControlFlowStatement(node)) {
+        return node;
+    }
+    if (node.type === AST_NODE_TYPES.BlockStatement &&
+        node.body.length === 1 &&
+        isSupportedControlFlowStatement(node.body[0])) {
+        return node.body[0];
+    }
+    return null;
+}
+function getControlFlowSignature(node, sourceCode) {
+    if (node.alternate) {
+        return null;
+    }
+    const controlFlowStatement = getControlFlowStatement(node.consequent);
+    if (!controlFlowStatement) {
+        return null;
+    }
+    switch (controlFlowStatement.type) {
+        case AST_NODE_TYPES.BreakStatement:
+            return controlFlowStatement.label
+                ? `break:${sourceCode.getText(controlFlowStatement.label)}`
+                : `break:${EMPTY_ARGUMENT}`;
+        case AST_NODE_TYPES.ContinueStatement:
+            return controlFlowStatement.label
+                ? `continue:${sourceCode.getText(controlFlowStatement.label)}`
+                : `continue:${EMPTY_ARGUMENT}`;
+        case AST_NODE_TYPES.ReturnStatement:
+            return controlFlowStatement.argument
+                ? `return:${sourceCode.getText(unwrapParenthesized(controlFlowStatement.argument))}`
+                : `return:${EMPTY_ARGUMENT}`;
+        case AST_NODE_TYPES.ThrowStatement:
+            return `throw:${sourceCode.getText(unwrapParenthesized(controlFlowStatement.argument))}`;
+    }
+}
+function hasNonWhitespaceBetween(sourceCode, left, right) {
+    return sourceCode.text.slice(left.range[1], right.range[0]).trim() !== '';
+}
+function needsParenthesesInOrChain(node) {
+    if (getParenthesizedInner(node)) {
+        return false;
+    }
+    switch (node.type) {
+        case AST_NODE_TYPES.AssignmentExpression:
+        case AST_NODE_TYPES.ConditionalExpression:
+        case AST_NODE_TYPES.SequenceExpression:
+        case AST_NODE_TYPES.TSAsExpression:
+        case AST_NODE_TYPES.TSSatisfiesExpression:
+        case AST_NODE_TYPES.YieldExpression:
+            return true;
+        case AST_NODE_TYPES.LogicalExpression:
+            return node.operator !== '||';
+        default:
+            return false;
+    }
+}
+function renderTest(node, sourceCode) {
+    const text = sourceCode.getText(node);
+    return needsParenthesesInOrChain(node) ? `(${text})` : text;
+}
+const rule$5 = createRule$5({
+    create(context) {
+        const { sourceCode } = context;
+        function checkBody(statements) {
+            let i = 0;
+            while (i < statements.length) {
+                const statement = statements[i];
+                if (statement.type !== AST_NODE_TYPES.IfStatement) {
+                    i++;
+                    continue;
+                }
+                const signature = getControlFlowSignature(statement, sourceCode);
+                if (!signature) {
+                    i++;
+                    continue;
+                }
+                const group = [statement];
+                let j = i + 1;
+                while (j < statements.length) {
+                    const nextStatement = statements[j];
+                    if (nextStatement.type !== AST_NODE_TYPES.IfStatement) {
+                        break;
+                    }
+                    if (!hasNonWhitespaceBetween(sourceCode, group[group.length - 1], nextStatement) &&
+                        sourceCode.getCommentsInside(nextStatement).length === 0 &&
+                        getControlFlowSignature(nextStatement, sourceCode) === signature) {
+                        group.push(nextStatement);
+                        j++;
+                        continue;
+                    }
+                    break;
+                }
+                if (group.length > 1) {
+                    for (const [index, ifStatement] of group.entries()) {
+                        context.report({
+                            ...(index === 0
+                                ? {
+                                    fix(fixer) {
+                                        const firstIf = group[0];
+                                        const lastIf = group[group.length - 1];
+                                        const condition = group
+                                            .map((item) => renderTest(item.test, sourceCode))
+                                            .join(' || ');
+                                        return fixer.replaceTextRange([firstIf.range[0], lastIf.range[1]], `if (${condition}) ${sourceCode.getText(firstIf.consequent)}`);
+                                    },
+                                }
+                                : {}),
+                            messageId: 'preferCombinedIfControlFlow',
+                            node: ifStatement,
+                        });
+                    }
+                }
+                i = j;
+            }
+        }
+        return {
+            BlockStatement(node) {
+                checkBody(node.body);
+            },
+            Program(node) {
+                checkBody(node.body);
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Combine consecutive if statements that use the same return, break, continue, or throw statement into a single if statement.',
+        },
+        fixable: 'code',
+        messages: {
+            preferCombinedIfControlFlow: 'Combine consecutive if statements with identical return, break, continue, or throw statements.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'prefer-combined-if-control-flow',
+});
+
 const MESSAGE_ID$1 = 'prefer-deep-imports';
 const ERROR_MESSAGE = 'Import via root entry point is prohibited when nested entry points exist';
 const createRule$4 = ESLintUtils.RuleCreator(() => ERROR_MESSAGE);
@@ -4700,14 +5015,10 @@ var preferDeepImports = createRule$4({
                     return;
                 }
                 const rootPackageName = getRootPackageName(rawImportPath);
-                if (!rootPackageName) {
-                    return;
-                }
-                if (!allowedPackages.includes(rootPackageName)) {
-                    return;
-                }
-                if (!isStrictMode &&
-                    isAlreadyNestedImport(rawImportPath, rootPackageName)) {
+                if (!rootPackageName ||
+                    !allowedPackages.includes(rootPackageName) ||
+                    (!isStrictMode &&
+                        isAlreadyNestedImport(rawImportPath, rootPackageName))) {
                     return;
                 }
                 const importedSymbols = extractNamedImportedSymbols(node);
@@ -4938,10 +5249,7 @@ function mapSymbolsToEntryPointsUsingTypeChecker(importedSymbols, candidateEntry
     for (const importedSymbol of importedSymbols) {
         for (const relativeEntryDir of candidateEntryPoints) {
             const exportedNames = exportTableByEntryPoint.get(relativeEntryDir);
-            if (!exportedNames) {
-                continue;
-            }
-            if (!exportedNames.has(importedSymbol)) {
+            if (!exportedNames?.has(importedSymbol)) {
                 continue;
             }
             symbolToEntryPoint.set(importedSymbol, relativeEntryDir);
@@ -5224,10 +5532,8 @@ function isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap) {
     }
     const signature = checker.getResolvedSignature(tsNode);
     const declaration = signature?.declaration;
-    if (!declaration) {
-        return false;
-    }
-    if (!LIB_DOM_FILE_PATTERN.test(declaration.getSourceFile().fileName)) {
+    if (!declaration ||
+        !LIB_DOM_FILE_PATTERN.test(declaration.getSourceFile().fileName)) {
         return false;
     }
     const returnType = checker.typeToString(checker.getReturnTypeOfSignature(signature));
@@ -5459,18 +5765,15 @@ function getReturnedExpression(node) {
 }
 function getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap) {
     const [arg] = node.arguments;
-    if (!arg || arg.type === AST_NODE_TYPES.SpreadElement) {
-        return null;
-    }
-    if (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-        arg.type !== AST_NODE_TYPES.FunctionExpression) {
+    if (!arg ||
+        arg.type === AST_NODE_TYPES.SpreadElement ||
+        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
         return null;
     }
     const body = getReturnedExpression(arg);
-    if (body?.type !== AST_NODE_TYPES.CallExpression) {
-        return null;
-    }
-    if (!isSignalReadCall(body, checker, esTreeNodeToTSNodeMap)) {
+    if (body?.type !== AST_NODE_TYPES.CallExpression ||
+        !isSignalReadCall(body, checker, esTreeNodeToTSNodeMap)) {
         return null;
     }
     const getter = unwrapExpression(body.callee);
@@ -5943,24 +6246,25 @@ const plugin = {
         'class-property-naming': classPropertyNaming,
         'decorator-key-sort': config$3,
         'flat-exports': flatExports,
-        'host-attributes-sort': rule$i,
+        'host-attributes-sort': rule$j,
         'html-logical-properties': config$2,
-        'injection-token-description': rule$h,
-        'no-deep-imports': rule$g,
+        'injection-token-description': rule$i,
+        'no-deep-imports': rule$h,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
-        'no-fully-untracked-effect': rule$f,
+        'no-fully-untracked-effect': rule$g,
         'no-href-with-router-link': config$1,
-        'no-implicit-public': rule$e,
-        'no-legacy-peer-deps': rule$d,
-        'no-playwright-empty-fill': rule$c,
+        'no-implicit-public': rule$f,
+        'no-legacy-peer-deps': rule$e,
+        'no-playwright-empty-fill': rule$d,
         'no-project-as-in-ng-template': config,
-        '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,
-        'no-useless-untracked': rule$6,
-        'object-single-line': rule$5,
+        'no-redundant-type-annotation': rule$c,
+        'no-side-effects-in-computed': rule$b,
+        'no-signal-reads-after-await-in-reactive-context': rule$a,
+        'no-string-literal-concat': rule$9,
+        'no-untracked-outside-reactive-context': rule$8,
+        'no-useless-untracked': rule$7,
+        'object-single-line': rule$6,
+        'prefer-combined-if-control-flow': rule$5,
         'prefer-deep-imports': preferDeepImports,
         'prefer-multi-arg-push': rule$4,
         'prefer-untracked-incidental-signal-reads': rule$3,

package/package.json

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

package/rules/prefer-combined-if-control-flow.d.ts

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

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;