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

package/README.md

@@ -44,7 +44,7 @@ export default [
 | decorator-key-sort                              | Sorts the keys of the object passed to the `@Component/@Injectable/@NgModule/@Pipe` decorator       | ✅  | 🔧  |     |
 | flat-exports                                    | Spread nested arrays when exporting Angular entity collections                                      |     | 🔧  |     |
 | host-attributes-sort                            | Sort Angular host metadata attributes using configurable attribute groups                           | ✅  | 🔧  |     |
-| injection-token-description                     | They are required to provide a description for `InjectionToken`                                     | ✅  |     |     |
+| injection-token-description                     | Require `InjectionToken` descriptions to include the token name                                     | ✅  | 🔧  |     |
 | no-deep-imports                                 | Disables deep imports of Taiga UI packages                                                          | ✅  | 🔧  |     |
 | no-deep-imports-to-indexed-packages             | Disallow deep imports from packages that expose an index.ts next to ng-package.json or package.json | ✅  | 🔧  |     |
 | no-fully-untracked-effect                       | Disallow reactive callbacks where all signal reads are hidden inside `untracked()`                  | ✅  |     |     |
@@ -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                        | ✅  | 🔧  |     |
@@ -282,17 +283,25 @@ Use atomic presets when you want a custom order instead of one of the bundled al
 
 ## injection-token-description
 
-<sup>`✅ Recommended`</sup>
+<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
 
-The description string passed to `new InjectionToken(...)` must contain the name of the variable it is assigned to. This
-makes token names visible in Angular DevTools and error messages.
+The description passed to `new InjectionToken(...)` must contain the name of the variable it is assigned to. The rule
+accepts both direct string descriptions and Angular's `ngDevMode ? '...' : ''` pattern, and the autofix rewrites invalid
+descriptions to the dev-only form. If `ngDevMode` is not declared in the file, the autofix inserts
+`declare const ngDevMode: boolean;` after imports.
 
 ```ts
-// ❌ error — description does not mention TUI_MY_TOKEN
-const TUI_MY_TOKEN = new InjectionToken<string>('some description');
+// ❌ error
+import {InjectionToken} from '@angular/core';
+
+export const TUI_MY_TOKEN = new InjectionToken<string>('some description');
 
 // ✅ after autofix
-const TUI_MY_TOKEN = new InjectionToken<string>('[TUI_MY_TOKEN]: some description');
+import {InjectionToken} from '@angular/core';
+
+declare const ngDevMode: boolean;
+
+export const TUI_MY_TOKEN = new InjectionToken<string>(ngDevMode ? '[TUI_MY_TOKEN]: some description' : '');
 ```
 
 ---
@@ -855,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
@@ -2024,37 +2020,109 @@ const config$2 = {
 
 const MESSAGE_ID$5 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
-const createRule$e = ESLintUtils.RuleCreator((name) => name);
-const rule$h = createRule$e({
+const NG_DEV_MODE = 'ngDevMode';
+const createRule$f = ESLintUtils.RuleCreator((name) => name);
+function getVariableName(node) {
+    if (node.parent.type !== AST_NODE_TYPES$1.VariableDeclarator) {
+        return undefined;
+    }
+    const { id } = node.parent;
+    return id.type === AST_NODE_TYPES$1.Identifier ? id.name : undefined;
+}
+function isStringLiteral$1(node) {
+    return node.type === AST_NODE_TYPES$1.Literal && typeof node.value === 'string';
+}
+function isStringLike(node) {
+    return isStringLiteral$1(node) || node.type === AST_NODE_TYPES$1.TemplateLiteral;
+}
+function getStringValue(node) {
+    if (isStringLiteral$1(node)) {
+        return node.value;
+    }
+    return node.quasis[0]?.value.raw || '';
+}
+function isEmptyString$1(node) {
+    return (getStringValue(node) === '' &&
+        (!('expressions' in node) || !node.expressions.length));
+}
+function isNgDevModeConditional(node) {
+    return (node.type === AST_NODE_TYPES$1.ConditionalExpression &&
+        node.test.type === AST_NODE_TYPES$1.Identifier &&
+        node.test.name === NG_DEV_MODE &&
+        isStringLike(node.consequent) &&
+        isStringLike(node.alternate) &&
+        isEmptyString$1(node.alternate));
+}
+function getDescriptionValue(node) {
+    if (isStringLike(node)) {
+        return getStringValue(node);
+    }
+    if (isNgDevModeConditional(node)) {
+        return getStringValue(node.consequent);
+    }
+    return undefined;
+}
+function getDescriptionNode(node) {
+    if (isStringLike(node)) {
+        return node;
+    }
+    return isNgDevModeConditional(node) ? node.consequent : undefined;
+}
+function prependTokenName(text, name) {
+    return `${text.slice(0, 1)}[${name}]: ${text.slice(1)}`;
+}
+function isNgDevModeVisible(sourceCode, node) {
+    for (let scope = sourceCode.getScope(node); scope !== null; scope = scope.upper) {
+        if (scope.variables.some((variable) => variable.name === NG_DEV_MODE)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getNgDevModeDeclarationFix(program, fixer) {
+    const lastImport = [...program.body]
+        .reverse()
+        .find((statement) => statement.type === AST_NODE_TYPES$1.ImportDeclaration);
+    if (lastImport) {
+        return fixer.insertTextAfter(lastImport, '\n\ndeclare const ngDevMode: boolean;');
+    }
+    const [firstStatement] = program.body;
+    if (firstStatement) {
+        return fixer.insertTextBefore(firstStatement, 'declare const ngDevMode: boolean;\n\n');
+    }
+    return fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
+}
+const rule$i = createRule$f({
     create(context) {
+        const { sourceCode } = context;
+        const program = sourceCode.ast;
+        let shouldAddNgDevModeDeclaration = true;
         return {
             'NewExpression[callee.name="InjectionToken"]'(node) {
-                let token;
-                let name;
-                const [description] = node?.arguments ?? [];
-                if (!description) {
+                const [description] = node.arguments;
+                if (!description || description.type === AST_NODE_TYPES$1.SpreadElement) {
                     return;
                 }
-                const isLiteral = description.type === AST_NODE_TYPES$1.Literal &&
-                    typeof description.value === 'string';
-                if (isLiteral) {
-                    token = description.value;
-                }
-                if (description.type === AST_NODE_TYPES$1.TemplateLiteral) {
-                    token = description.quasis[0]?.value.raw || '';
-                }
-                if (node?.parent.type === AST_NODE_TYPES$1.VariableDeclarator) {
-                    const id = node.parent.id;
-                    if (id.type === AST_NODE_TYPES$1.Identifier) {
-                        name = id.name;
-                    }
-                }
+                const name = getVariableName(node);
+                const token = getDescriptionValue(description);
+                const fixedDescription = getDescriptionNode(description);
                 const report = name && token && !token.includes(name);
-                if (report) {
+                if (report && fixedDescription) {
                     context.report({
                         fix: (fixer) => {
-                            const [start, end] = description.range;
-                            return fixer.insertTextBeforeRange([start + 1, end], `[${name}]: `);
+                            const isNgDevModeGuarded = isNgDevModeConditional(description);
+                            const fixes = [
+                                fixer.replaceText(isNgDevModeGuarded ? fixedDescription : description, isNgDevModeGuarded
+                                    ? prependTokenName(sourceCode.getText(fixedDescription), name)
+                                    : `${NG_DEV_MODE} ? ${prependTokenName(sourceCode.getText(fixedDescription), name)} : ''`),
+                            ];
+                            if (!isNgDevModeGuarded &&
+                                shouldAddNgDevModeDeclaration &&
+                                !isNgDevModeVisible(sourceCode, description)) {
+                                shouldAddNgDevModeDeclaration = false;
+                                fixes.unshift(getNgDevModeDeclarationFix(program, fixer));
+                            }
+                            return fixes;
                         },
                         messageId: MESSAGE_ID$5,
                         node: description,
@@ -2092,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) => {
@@ -2180,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;
@@ -2292,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);
@@ -2366,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);
@@ -2444,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) {
@@ -2508,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) {
@@ -2792,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);
@@ -2869,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;
@@ -2891,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();
@@ -2977,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 ||
@@ -3049,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) {
@@ -3089,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();
@@ -3255,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) {
@@ -3281,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();
@@ -3409,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);
@@ -3531,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();
@@ -3578,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();
@@ -3627,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');
@@ -3691,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;
@@ -4111,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();
@@ -4135,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);
@@ -4255,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;
@@ -4268,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();
@@ -4289,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;
@@ -4358,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) => {
@@ -4611,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);
@@ -4628,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);
@@ -4866,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);
@@ -5152,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));
@@ -5387,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);
@@ -5871,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.471.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;