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

package/README.md

@@ -60,6 +60,7 @@ export default [
 | 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                        | ✅  | 🔧  |     |
@@ -863,6 +864,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) {
@@ -2864,10 +2849,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 +2924,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 +2944,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 +3030,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 +3102,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 +3142,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 +3308,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 +3334,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 +3462,7 @@ function unwrapExpression(expression) {
     return current;
 }
 
-const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+const createRule$8 = ESLintUtils.RuleCreator((name) => name);
 function isReactiveCallback(node) {
     return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
         node?.type === AST_NODE_TYPES.FunctionExpression);
@@ -3603,7 +3584,7 @@ function inspectComputedBody(root, inspectionContext, report) {
         return;
     });
 }
-const rule$a = createRule$7({
+const rule$b = createRule$8({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
@@ -3650,7 +3631,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 +3680,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 +3744,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 +4164,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 +4188,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 +4300,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 +4311,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 +4332,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 +4399,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 +4652,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 +4832,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 +5066,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 +5349,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 +5582,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 +6063,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.473.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;