@taiga-ui/eslint-plugin-experience-next 0.514.0 → 0.516.0

package/README.md

@@ -96,6 +96,7 @@ from third-party plugins. The exact severities and file globs live in
 | [no-infinite-loop](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-infinite-loop.md)                                                               | Disallow `while (true)` and `for` loops without an explicit condition                               | ✅  |     |     |
 | [no-legacy-peer-deps](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-legacy-peer-deps.md)                                                         | Disallow `legacy-peer-deps=true` in `.npmrc`                                                        | ✅  |     |     |
 | [no-nested-interactive](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-nested-interactive.md)                                                     | Disallow interactive HTML elements nested inside other interactive elements                         | ✅  |     |     |
+| [no-nested-ternary-in-template](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-nested-ternary-in-template.md)                                     | Disallow nested ternary expressions in Angular 19+ templates                                        | ✅  | 🔧  |     |
 | [no-obsolete-attrs](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-obsolete-attrs.md)                                                             | Disallow obsolete HTML attributes                                                                   | ✅  |     |     |
 | [no-obsolete-tags](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-obsolete-tags.md)                                                               | Disallow obsolete HTML tags                                                                         | ✅  |     |     |
 | [no-playwright-empty-fill](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-playwright-empty-fill.md)                                               | Enforce `clear()` over `fill('')` in Playwright tests                                               | ✅  | 🔧  |     |

package/configs/utils/get-ng-version.d.ts

@@ -4,5 +4,6 @@ export declare const modernAngularRules: {
     readonly modernStyles: 17;
     readonly preferControlFlow: 17;
     readonly preferSignals: 17;
+    readonly templateLet: 19;
     readonly templateLiteral: 19;
 };

package/index.d.ts

@@ -102,6 +102,9 @@ declare const plugin: {
         'no-nested-interactive': import("eslint").Rule.RuleModule & {
             name: string;
         };
+        'no-nested-ternary-in-template': import("eslint").Rule.RuleModule & {
+            name: string;
+        };
         'no-obsolete-attrs': import("eslint").Rule.RuleModule & {
             name: string;
         };

package/index.esm.js

@@ -514,6 +514,7 @@ const modernAngularRules = {
     modernStyles: 17,
     preferControlFlow: 17,
     preferSignals: 17,
+    templateLet: 19,
     templateLiteral: 19,
 };
 
@@ -1310,6 +1311,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-duplicate-in-head': 'error',
             '@taiga-ui/experience-next/no-href-with-router-link': 'error',
             '@taiga-ui/experience-next/no-nested-interactive': 'error',
+            '@taiga-ui/experience-next/no-nested-ternary-in-template': angularVersion >= modernAngularRules.templateLet ? 'error' : 'off',
             '@taiga-ui/experience-next/no-obsolete-attrs': 'error',
             '@taiga-ui/experience-next/no-obsolete-tags': 'error',
             '@taiga-ui/experience-next/no-project-as-in-ng-template': 'error',
@@ -33246,11 +33248,6 @@ function hasElementAttribute(element, name) {
             return (details?.startsWith('attr.') === true && names.includes(details.slice(5)));
         }));
 }
-function hasOutputBinding(element, name) {
-    {
-        return element.outputs.length > 0;
-    }
-}
 function getElementAttributeLikes(element) {
     const seen = new Set();
     return [
@@ -33282,6 +33279,12 @@ function sourceSpanToLoc(span) {
         },
     };
 }
+function containsAbsoluteSourceSpan(container, child) {
+    return container.start <= child.start && child.end <= container.end;
+}
+function getAbsoluteSourceSpanText(text, span) {
+    return text.slice(span.start, span.end);
+}
 
 var dist$3 = {};
 
@@ -46269,7 +46272,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join('\n');
 }
-const rule$U = createRule({
+const rule$V = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -46449,7 +46452,7 @@ function sameOrder(a, b) {
     return a.length === b.length && a.every((value, index) => value === b[index]);
 }
 
-const rule$T = createRule({
+const rule$U = createRule({
     create(context, [order]) {
         const decorators = new Set(Object.keys(order));
         return {
@@ -46561,7 +46564,7 @@ const INLINE_HTML_ELEMENTS = new Set([
     'wbr',
 ]);
 
-const MESSAGE_ID$h = 'expectAfter';
+const MESSAGE_ID$i = 'expectAfter';
 const SKIP_CHILDREN = new Set(['code', 'pre']);
 function isChildNode(node) {
     return (node instanceof dist$4.TmplAstBoundText ||
@@ -46585,7 +46588,7 @@ function getNodeLabel(node) {
     }
     return node instanceof dist$4.TmplAstBoundText ? 'binding' : 'text';
 }
-const rule$S = createRule({
+const rule$T = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
@@ -46611,7 +46614,7 @@ const rule$S = createRule({
                                 firstChild.sourceSpan.start.offset,
                             ], '\n'),
                             loc: sourceSpanToLoc(firstChild.sourceSpan),
-                            messageId: MESSAGE_ID$h,
+                            messageId: MESSAGE_ID$i,
                         });
                         return;
                     }
@@ -46629,7 +46632,7 @@ const rule$S = createRule({
                                     child.sourceSpan.end.offset,
                                 ], '\n'),
                                 loc: sourceSpanToLoc(next.sourceSpan),
-                                messageId: MESSAGE_ID$h,
+                                messageId: MESSAGE_ID$i,
                             });
                             return;
                         }
@@ -46643,7 +46646,7 @@ const rule$S = createRule({
                                 lastChild.sourceSpan.end.offset,
                             ], '\n'),
                             loc: sourceSpanToLoc(lastChild.sourceSpan),
-                            messageId: MESSAGE_ID$h,
+                            messageId: MESSAGE_ID$i,
                         });
                     }
                 },
@@ -46652,7 +46655,7 @@ const rule$S = createRule({
         meta: {
             docs: { description: 'Enforce line breaks between block-level child nodes' },
             fixable: 'code',
-            messages: { [MESSAGE_ID$h]: 'There should be a linebreak after {{name}}.' },
+            messages: { [MESSAGE_ID$i]: 'There should be a linebreak after {{name}}.' },
             schema: [],
             type: 'layout',
         },
@@ -46724,7 +46727,7 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const rule$R = createRule({
+const rule$S = createRule({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -47004,8 +47007,8 @@ const DIRECTIONAL_TO_LOGICAL = {
     top: 'inset-block-start',
 };
 const STYLE_PREFIX = 'style.';
-const MESSAGE_ID$g = 'html-logical-properties';
-const MESSAGE = `
+const MESSAGE_ID$h = 'html-logical-properties';
+const MESSAGE$1 = `
 Use logical CSS properties instead of directional properties. Replace:
 • left → inset-inline-start
 • right → inset-inline-end
@@ -47042,20 +47045,20 @@ const config$4 = {
                 context.report({
                     fix: (fixer) => fixer.replaceTextRange([propertyStart, propertyEnd], logicalProperty),
                     loc: sourceSpanToLoc(keySpan),
-                    messageId: MESSAGE_ID$g,
+                    messageId: MESSAGE_ID$h,
                 });
             },
         };
     },
     meta: {
-        docs: { description: MESSAGE },
+        docs: { description: MESSAGE$1 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$g]: MESSAGE },
+        messages: { [MESSAGE_ID$h]: MESSAGE$1 },
         schema: [],
         type: 'suggestion',
     },
 };
-const rule$Q = createRule({
+const rule$R = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
@@ -248297,7 +248300,7 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     }
     return hasSafeRuntimeUsage;
 }
-const rule$P = createRule({
+const rule$Q = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
         const checkCycles = context.options[0]?.checkCycles ?? true;
@@ -248959,7 +248962,7 @@ const rule$P = createRule({
     name: 'import-integrity',
 });
 
-const MESSAGE_ID$f = 'invalid-injection-token-description';
+const MESSAGE_ID$g = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
 const NG_DEV_MODE = 'ngDevMode';
 function getVariableName(node) {
@@ -249022,7 +249025,7 @@ function getNgDevModeDeclarationFix(program, fixer) {
         ? fixer.insertTextBefore(firstStatement, 'declare const ngDevMode: boolean;\n\n')
         : fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
 }
-const rule$O = createRule({
+const rule$P = createRule({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -249054,7 +249057,7 @@ const rule$O = createRule({
                             }
                             return fixes;
                         },
-                        messageId: MESSAGE_ID$f,
+                        messageId: MESSAGE_ID$g,
                         node: description,
                     });
                 }
@@ -249064,14 +249067,14 @@ const rule$O = createRule({
     meta: {
         docs: { description: ERROR_MESSAGE$3 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$f]: ERROR_MESSAGE$3 },
+        messages: { [MESSAGE_ID$g]: ERROR_MESSAGE$3 },
         schema: [],
         type: 'problem',
     },
     name: 'injection-token-description',
 });
 
-const rule$N = createRule({
+const rule$O = createRule({
     create(context) {
         const { sourceCode } = context;
         const namespaceImports = new Map();
@@ -249147,7 +249150,7 @@ const rule$N = createRule({
     name: 'no-commonjs-import-patterns',
 });
 
-const MESSAGE_ID$e = 'no-deep-imports';
+const MESSAGE_ID$f = 'no-deep-imports';
 const ERROR_MESSAGE$2 = 'Deep imports of Taiga UI packages are prohibited';
 const CODE_EXTENSIONS = new Set([
     '.cjs',
@@ -249166,7 +249169,7 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const rule$M = createRule({
+const rule$N = createRule({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -249208,7 +249211,7 @@ const rule$M = createRule({
                         const [start, end] = node.source.range;
                         return fixer.replaceTextRange([start + 1, end - 1], importSource.replaceAll(new RegExp(deepImport, 'g'), ''));
                     },
-                    messageId: MESSAGE_ID$e,
+                    messageId: MESSAGE_ID$f,
                     node: node.source,
                 });
             },
@@ -249218,7 +249221,7 @@ const rule$M = createRule({
         defaultOptions: [DEFAULT_OPTIONS],
         docs: { description: ERROR_MESSAGE$2 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$e]: ERROR_MESSAGE$2 },
+        messages: { [MESSAGE_ID$f]: ERROR_MESSAGE$2 },
         schema: [
             {
                 additionalProperties: false,
@@ -249258,7 +249261,7 @@ const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-const rule$L = createRule({
+const rule$M = createRule({
     create(context) {
         const parserServices = dist$3.ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -249452,13 +249455,13 @@ const noDuplicateAttributesRule = angular.templatePlugin.rules?.['no-duplicate-a
 if (!noDuplicateAttributesRule) {
     throw new Error('angular-eslint template rule "no-duplicate-attributes" is not available');
 }
-const rule$K = createRule({
+const rule$L = createRule({
     name: 'no-duplicate-attrs',
     rule: noDuplicateAttributesRule,
 });
 
-const MESSAGE_ID$d = 'duplicateId';
-const rule$J = createRule({
+const MESSAGE_ID$e = 'duplicateId';
+const rule$K = createRule({
     name: 'no-duplicate-id',
     rule: {
         create(context) {
@@ -249481,7 +249484,7 @@ const rule$J = createRule({
                             context.report({
                                 data: { id },
                                 loc: sourceSpanToLoc(attr.sourceSpan),
-                                messageId: MESSAGE_ID$d,
+                                messageId: MESSAGE_ID$e,
                             });
                         }
                     }
@@ -249490,14 +249493,14 @@ const rule$J = createRule({
         },
         meta: {
             docs: { description: 'Disallow duplicate static id attributes' },
-            messages: { [MESSAGE_ID$d]: "The id '{{id}}' is duplicated." },
+            messages: { [MESSAGE_ID$e]: "The id '{{id}}' is duplicated." },
             schema: [],
             type: 'problem',
         },
     },
 });
 
-const MESSAGE_ID$c = 'duplicateTag';
+const MESSAGE_ID$d = 'duplicateTag';
 function getTrackingKey(node) {
     if (node.name === 'title' || node.name === 'base') {
         return node.name;
@@ -249516,7 +249519,7 @@ function getTrackingKey(node) {
         ? 'link[rel=canonical]'
         : null;
 }
-const rule$I = createRule({
+const rule$J = createRule({
     name: 'no-duplicate-in-head',
     rule: {
         create(context) {
@@ -249553,7 +249556,7 @@ const rule$I = createRule({
                             context.report({
                                 data: { tag },
                                 loc: sourceSpanToLoc(duplicate.startSourceSpan),
-                                messageId: MESSAGE_ID$c,
+                                messageId: MESSAGE_ID$d,
                             });
                         }
                     }
@@ -249564,7 +249567,7 @@ const rule$I = createRule({
             docs: {
                 description: 'Disallow duplicate title/base/meta/link tags inside head',
             },
-            messages: { [MESSAGE_ID$c]: 'Duplicate <{{tag}}> tag in <head>.' },
+            messages: { [MESSAGE_ID$d]: 'Duplicate <{{tag}}> tag in <head>.' },
             schema: [],
             type: 'problem',
         },
@@ -249572,7 +249575,7 @@ const rule$I = createRule({
 });
 
 const COMPONENT_DECORATORS = new Set(['Component']);
-const rule$H = createRule({
+const rule$I = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -250220,7 +250223,7 @@ const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#r
 const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
 const createUntrackedRule = createRule;
 
-const rule$G = createUntrackedRule({
+const rule$H = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250258,7 +250261,7 @@ const rule$G = createUntrackedRule({
     name: 'no-fully-untracked-effect',
 });
 
-const MESSAGE_ID$b = 'no-href-with-router-link';
+const MESSAGE_ID$c = 'no-href-with-router-link';
 const ERROR_MESSAGE$1 = 'Do not use href and routerLink attributes together on the same element';
 const config$3 = {
     create(context) {
@@ -250280,7 +250283,7 @@ const config$3 = {
                         hrefAttr.sourceSpan.end.offset,
                     ]),
                     loc: sourceSpanToLoc(hrefAttr.sourceSpan),
-                    messageId: MESSAGE_ID$b,
+                    messageId: MESSAGE_ID$c,
                 });
             },
         };
@@ -250288,12 +250291,12 @@ const config$3 = {
     meta: {
         docs: { description: ERROR_MESSAGE$1 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$b]: ERROR_MESSAGE$1 },
+        messages: { [MESSAGE_ID$c]: ERROR_MESSAGE$1 },
         schema: [],
         type: 'problem',
     },
 };
-const rule$F = createRule({
+const rule$G = createRule({
     name: 'no-href-with-router-link',
     rule: config$3,
 });
@@ -250354,7 +250357,7 @@ function getScopeRoot(node) {
     return (findAncestor(node, (ancestor) => ancestor.type === dist$3.AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
 }
 
-const rule$E = createRule({
+const rule$F = createRule({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getEnclosingClass(node);
@@ -250416,7 +250419,7 @@ const rule$E = createRule({
     name: 'no-implicit-public',
 });
 
-const rule$D = createRule({
+const rule$E = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -250472,7 +250475,7 @@ function isInfiniteLoopLiteral(node) {
 function isInfiniteLoopTest(test) {
     return test == null || isInfiniteLoopLiteral(test);
 }
-const rule$C = createRule({
+const rule$D = createRule({
     create(context) {
         return {
             DoWhileStatement(node) {
@@ -250517,7 +250520,7 @@ const rule$C = createRule({
 });
 
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$B = createRule({
+const rule$C = createRule({
     create(context) {
         return {
             Program(node) {
@@ -250557,7 +250560,7 @@ const rule$B = createRule({
 
 function isInteractiveElement(node) {
     const tagName = node.name.toLowerCase();
-    if (hasElementAttribute(node, 'tabindex') || hasOutputBinding(node)) {
+    if (hasElementAttribute(node, 'tabindex')) {
         return true;
     }
     switch (tagName) {
@@ -250594,7 +250597,7 @@ function isInteractiveElement(node) {
     }
 }
 
-const MESSAGE_ID$a = 'noNestedInteractive';
+const MESSAGE_ID$b = 'noNestedInteractive';
 function getAvailableLabelParent(stack, node, labelsWithControl) {
     const parent = stack[stack.length - 1];
     return stack.length === 1 &&
@@ -250604,7 +250607,7 @@ function getAvailableLabelParent(stack, node, labelsWithControl) {
         ? parent
         : null;
 }
-const rule$A = createRule({
+const rule$B = createRule({
     name: 'no-nested-interactive',
     rule: {
         create(context) {
@@ -250625,7 +250628,7 @@ const rule$A = createRule({
                         context.report({
                             data: { tag: parent.name },
                             loc: sourceSpanToLoc(node.startSourceSpan),
-                            messageId: MESSAGE_ID$a,
+                            messageId: MESSAGE_ID$b,
                         });
                     }
                     interactiveStack.push(node);
@@ -250641,7 +250644,7 @@ const rule$A = createRule({
         meta: {
             docs: { description: 'Disallow nested interactive elements' },
             messages: {
-                [MESSAGE_ID$a]: 'Unexpected interactive element nested inside interactive <{{tag}}>.',
+                [MESSAGE_ID$b]: 'Unexpected interactive element nested inside interactive <{{tag}}>.',
             },
             schema: [],
             type: 'problem',
@@ -250649,6 +250652,301 @@ const rule$A = createRule({
     },
 });
 
+function isBoundAttribute(node) {
+    return node instanceof dist$4.TmplAstBoundAttribute;
+}
+function getBoundAttributes(container) {
+    return container instanceof dist$4.TmplAstTemplate
+        ? [...container.inputs, ...container.templateAttrs.filter(isBoundAttribute)]
+        : container.inputs;
+}
+function getContainingBoundAttribute(container, node) {
+    return container
+        ? (getBoundAttributes(container).find((attribute) => containsAbsoluteSourceSpan(attribute.value.sourceSpan, node.sourceSpan)) ?? null)
+        : null;
+}
+
+function isConditional(node) {
+    return 'condition' in node && 'trueExp' in node && 'falseExp' in node;
+}
+
+class TemplateIdentifierCollector extends dist$4.TmplAstRecursiveVisitor {
+    constructor(names) {
+        super();
+        this.names = names;
+    }
+    visitLetDeclaration(node) {
+        this.names.add(node.name);
+    }
+    visitReference(node) {
+        this.names.add(node.name);
+    }
+    visitVariable(node) {
+        this.names.add(node.name);
+    }
+}
+function getTemplateNodes(ast) {
+    if (!ast || typeof ast !== 'object' || !('templateNodes' in ast)) {
+        return [];
+    }
+    const { templateNodes } = ast;
+    return Array.isArray(templateNodes) ? templateNodes : [];
+}
+function collectTemplateIdentifiers(ast) {
+    const names = new Set();
+    dist$4.tmplAstVisitAll(new TemplateIdentifierCollector(names), [...getTemplateNodes(ast)]);
+    return names;
+}
+
+const IDENTIFIER = /^[A-Z_$][\w$]*$/i;
+const RESERVED_IDENTIFIERS = new Set([
+    'arguments',
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+]);
+function isIdentifier(name) {
+    return IDENTIFIER.test(name) && !RESERVED_IDENTIFIERS.has(name);
+}
+function getAvailableIdentifier(baseName, unavailableNames) {
+    if (!isIdentifier(baseName)) {
+        throw new Error(`Expected a valid identifier, got "${baseName}"`);
+    }
+    if (!unavailableNames.has(baseName)) {
+        return baseName;
+    }
+    let suffix = 2;
+    let name = `${baseName}${suffix}`;
+    while (unavailableNames.has(name)) {
+        suffix++;
+        name = `${baseName}${suffix}`;
+    }
+    return name;
+}
+
+function isSingleLineNode(node) {
+    return node.loc.start.line === node.loc.end.line;
+}
+function hasCommentLikeText(text) {
+    return text.includes('//') || text.includes('/*');
+}
+function hasBlankLine(text) {
+    let lineBreaks = 0;
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (char === '\n') {
+            lineBreaks++;
+        }
+        else if (char === '\r') {
+            lineBreaks++;
+            if (text[index + 1] === '\n') {
+                index++;
+            }
+        }
+        if (lineBreaks > 1) {
+            return true;
+        }
+    }
+    return false;
+}
+function getLineBreak(text) {
+    if (text.includes('\r\n')) {
+        return '\r\n';
+    }
+    return text.includes('\r') ? '\r' : '\n';
+}
+function getLeadingIndentation(text) {
+    let index = 0;
+    while (index < text.length && (text[index] === ' ' || text[index] === '\t')) {
+        index++;
+    }
+    return text.slice(0, index);
+}
+function getIndentAtOffset(text, offset) {
+    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
+    const indent = text.slice(lineStart, offset);
+    return indent.trim() === '' ? indent : '';
+}
+function getSpacingReplacement(sourceCode, betweenText, nextLine, blankLineCount) {
+    const indentation = getLeadingIndentation(sourceCode.lines[nextLine - 1] ?? '');
+    return `${getLineBreak(betweenText).repeat(blankLineCount + 1)}${indentation}`;
+}
+
+const MESSAGE_ID$a = 'noNestedTernaryInTemplate';
+const MESSAGE = 'Avoid nested ternary expressions in Angular templates. Move the nested branch into an @let declaration.';
+function createLetFixes(node, baseName, unavailableNames, text) {
+    const name = getAvailableIdentifier(baseName, unavailableNames);
+    unavailableNames.add(name);
+    const nestedLets = [];
+    const render = (child) => {
+        if (isConditional(child)) {
+            const result = createLetFixes(child, baseName, unavailableNames, text);
+            nestedLets.push(...result.lets);
+            return result.reference;
+        }
+        return getAbsoluteSourceSpanText(text, child.sourceSpan);
+    };
+    const condition = render(node.condition);
+    const trueExp = render(node.trueExp);
+    const falseExp = render(node.falseExp);
+    return {
+        lets: [
+            ...nestedLets,
+            {
+                expression: `${condition} ? ${trueExp} : ${falseExp}`,
+                name,
+            },
+        ],
+        reference: name,
+    };
+}
+const rule$A = createRule({
+    name: 'no-nested-ternary-in-template',
+    rule: {
+        create(context) {
+            const { sourceCode } = context;
+            const conditionalStack = [];
+            const containerStack = [];
+            const letNames = collectTemplateIdentifiers(sourceCode.ast);
+            let boundEventDepth = 0;
+            let letDeclarationDepth = 0;
+            function reportNestedConditional(node, options) {
+                const container = containerStack[containerStack.length - 1];
+                const attribute = getContainingBoundAttribute(container, node);
+                const baseName = attribute?.name;
+                const fixable = options.allowFix &&
+                    boundEventDepth === 0 &&
+                    letDeclarationDepth === 0 &&
+                    baseName &&
+                    isIdentifier(baseName);
+                context.report({
+                    ...(fixable
+                        ? {
+                            fix(fixer) {
+                                const result = createLetFixes(node, baseName, letNames, sourceCode.text);
+                                const insertOffset = container?.startSourceSpan.start.offset;
+                                if (insertOffset === undefined) {
+                                    return null;
+                                }
+                                const indent = getIndentAtOffset(sourceCode.text, insertOffset);
+                                const declarations = result.lets
+                                    .map(({ expression, name }, index) => `${index === 0 ? '' : indent}@let ${name} = ${expression};`)
+                                    .join('\n');
+                                return [
+                                    fixer.insertTextBeforeRange([insertOffset, insertOffset], `${declarations}\n${indent}`),
+                                    fixer.replaceTextRange([node.sourceSpan.start, node.sourceSpan.end], result.reference),
+                                ];
+                            },
+                        }
+                        : {}),
+                    loc: {
+                        end: sourceCode.getLocFromIndex(node.sourceSpan.end),
+                        start: sourceCode.getLocFromIndex(node.sourceSpan.start),
+                    },
+                    messageId: MESSAGE_ID$a,
+                });
+            }
+            return {
+                BoundEvent() {
+                    boundEventDepth++;
+                },
+                'BoundEvent:exit'() {
+                    boundEventDepth--;
+                },
+                Conditional(rawNode) {
+                    const node = rawNode;
+                    if (conditionalStack.length > 0) {
+                        reportNestedConditional(node, {
+                            allowFix: conditionalStack.length === 1,
+                        });
+                    }
+                    conditionalStack.push(node);
+                },
+                'Conditional:exit'(rawNode) {
+                    const node = rawNode;
+                    if (conditionalStack[conditionalStack.length - 1] === node) {
+                        conditionalStack.pop();
+                    }
+                },
+                Element(rawNode) {
+                    containerStack.push(rawNode);
+                },
+                'Element:exit'(rawNode) {
+                    if (containerStack[containerStack.length - 1] === rawNode) {
+                        containerStack.pop();
+                    }
+                },
+                LetDeclaration() {
+                    letDeclarationDepth++;
+                },
+                'LetDeclaration:exit'() {
+                    letDeclarationDepth--;
+                },
+                Template(rawNode) {
+                    containerStack.push(rawNode);
+                },
+                'Template:exit'(rawNode) {
+                    if (containerStack[containerStack.length - 1] === rawNode) {
+                        containerStack.pop();
+                    }
+                },
+            };
+        },
+        meta: {
+            docs: { description: MESSAGE },
+            fixable: 'code',
+            messages: { [MESSAGE_ID$a]: MESSAGE },
+            schema: [],
+            type: 'suggestion',
+        },
+    },
+});
+
 const OBSOLETE_HTML_ATTRS = {
     abbr: [
         {
@@ -254551,49 +254849,6 @@ const rule$9 = createRule({
     name: 'short-tui-imports',
 });
 
-function isSingleLineNode(node) {
-    return node.loc.start.line === node.loc.end.line;
-}
-function hasCommentLikeText(text) {
-    return text.includes('//') || text.includes('/*');
-}
-function hasBlankLine(text) {
-    let lineBreaks = 0;
-    for (let index = 0; index < text.length; index++) {
-        const char = text[index];
-        if (char === '\n') {
-            lineBreaks++;
-        }
-        else if (char === '\r') {
-            lineBreaks++;
-            if (text[index + 1] === '\n') {
-                index++;
-            }
-        }
-        if (lineBreaks > 1) {
-            return true;
-        }
-    }
-    return false;
-}
-function getLineBreak(text) {
-    if (text.includes('\r\n')) {
-        return '\r\n';
-    }
-    return text.includes('\r') ? '\r' : '\n';
-}
-function getLeadingIndentation(text) {
-    let index = 0;
-    while (index < text.length && (text[index] === ' ' || text[index] === '\t')) {
-        index++;
-    }
-    return text.slice(0, index);
-}
-function getSpacingReplacement(sourceCode, betweenText, nextLine, blankLineCount) {
-    const indentation = getLeadingIndentation(sourceCode.lines[nextLine - 1] ?? '');
-    return `${getLineBreak(betweenText).repeat(blankLineCount + 1)}${indentation}`;
-}
-
 function isFieldLikeMember(member) {
     return (member.type === dist$3.AST_NODE_TYPES.PropertyDefinition ||
         member.type === dist$3.AST_NODE_TYPES.TSAbstractPropertyDefinition);
@@ -255828,29 +256083,30 @@ const plugin = {
     },
     rules: {
         'array-as-const': rule$5,
-        'attrs-newline': rule$U,
+        'attrs-newline': rule$V,
         'class-property-naming': rule$4,
-        'decorator-key-sort': rule$T,
-        'element-newline': rule$S,
+        'decorator-key-sort': rule$U,
+        'element-newline': rule$T,
         'flat-exports': rule$3,
-        'host-attributes-sort': rule$R,
-        'html-logical-properties': rule$Q,
-        'import-integrity': rule$P,
-        'injection-token-description': rule$O,
-        'no-commonjs-import-patterns': rule$N,
-        'no-deep-imports': rule$M,
-        'no-deep-imports-to-indexed-packages': rule$L,
-        'no-duplicate-attrs': rule$K,
-        'no-duplicate-id': rule$J,
-        'no-duplicate-in-head': rule$I,
-        'no-empty-style-metadata': rule$H,
-        'no-fully-untracked-effect': rule$G,
-        'no-href-with-router-link': rule$F,
-        'no-implicit-public': rule$E,
-        'no-import-assertions': rule$D,
-        'no-infinite-loop': rule$C,
-        'no-legacy-peer-deps': rule$B,
-        'no-nested-interactive': rule$A,
+        'host-attributes-sort': rule$S,
+        'html-logical-properties': rule$R,
+        'import-integrity': rule$Q,
+        'injection-token-description': rule$P,
+        'no-commonjs-import-patterns': rule$O,
+        'no-deep-imports': rule$N,
+        'no-deep-imports-to-indexed-packages': rule$M,
+        'no-duplicate-attrs': rule$L,
+        'no-duplicate-id': rule$K,
+        'no-duplicate-in-head': rule$J,
+        'no-empty-style-metadata': rule$I,
+        'no-fully-untracked-effect': rule$H,
+        'no-href-with-router-link': rule$G,
+        'no-implicit-public': rule$F,
+        'no-import-assertions': rule$E,
+        'no-infinite-loop': rule$D,
+        'no-legacy-peer-deps': rule$C,
+        'no-nested-interactive': rule$B,
+        'no-nested-ternary-in-template': rule$A,
         'no-obsolete-attrs': rule$z,
         'no-obsolete-tags': rule$y,
         'no-playwright-empty-fill': rule$x,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.514.0",
+  "version": "0.516.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "homepage": "https://github.com/taiga-family/toolkit#readme",
   "bugs": {

package/rules/recommended/no-nested-ternary-in-template.d.ts

@@ -0,0 +1,5 @@
+import { type Rule } from 'eslint';
+export declare const rule: Rule.RuleModule & {
+    name: string;
+};
+export default rule;

package/rules/utils/angular/source-span.d.ts

@@ -1,3 +1,5 @@
-import { type ParseSourceSpan } from '@angular-eslint/bundled-angular-compiler';
+import { type AbsoluteSourceSpan, type ParseSourceSpan } from '@angular-eslint/bundled-angular-compiler';
 import { type SourceLocation } from 'estree';
 export declare function sourceSpanToLoc(span: ParseSourceSpan): SourceLocation;
+export declare function containsAbsoluteSourceSpan(container: AbsoluteSourceSpan, child: AbsoluteSourceSpan): boolean;
+export declare function getAbsoluteSourceSpanText(text: string, span: AbsoluteSourceSpan): string;

package/rules/utils/angular/template-attributes.d.ts

@@ -0,0 +1,5 @@
+import { type AST, TmplAstBoundAttribute, type TmplAstElement, TmplAstTemplate } from '@angular-eslint/bundled-angular-compiler';
+export type TemplateAttributeContainer = TmplAstElement | TmplAstTemplate;
+export declare function isBoundAttribute(node: unknown): node is TmplAstBoundAttribute;
+export declare function getBoundAttributes(container: TemplateAttributeContainer): readonly TmplAstBoundAttribute[];
+export declare function getContainingBoundAttribute(container: TemplateAttributeContainer | undefined, node: AST): TmplAstBoundAttribute | null;

package/rules/utils/angular/template-expressions.d.ts

@@ -0,0 +1,4 @@
+import { type AST, type ASTWithSource, type Conditional } from '@angular-eslint/bundled-angular-compiler';
+export declare function isAstWithSource(node: AST): node is ASTWithSource;
+export declare function unwrapAstWithSource(node: AST): AST;
+export declare function isConditional(node: AST): node is Conditional;

package/rules/utils/angular/template-identifiers.d.ts

@@ -0,0 +1,10 @@
+import { type TmplAstLetDeclaration, type TmplAstNode, TmplAstRecursiveVisitor, type TmplAstReference, type TmplAstVariable } from '@angular-eslint/bundled-angular-compiler';
+export declare class TemplateIdentifierCollector extends TmplAstRecursiveVisitor {
+    private readonly names;
+    constructor(names: Set<string>);
+    visitLetDeclaration(node: TmplAstLetDeclaration): void;
+    visitReference(node: TmplAstReference): void;
+    visitVariable(node: TmplAstVariable): void;
+}
+export declare function getTemplateNodes(ast: unknown): readonly TmplAstNode[];
+export declare function collectTemplateIdentifiers(ast: unknown): Set<string>;

package/rules/utils/ast/identifiers.d.ts

@@ -0,0 +1,2 @@
+export declare function isIdentifier(name: string): boolean;
+export declare function getAvailableIdentifier(baseName: string, unavailableNames: ReadonlySet<string>): string;

package/rules/utils/ast/spacing.d.ts

@@ -4,4 +4,5 @@ export declare function hasCommentLikeText(text: string): boolean;
 export declare function hasBlankLine(text: string): boolean;
 export declare function getLineBreak(text: string): string;
 export declare function getLeadingIndentation(text: string): string;
+export declare function getIndentAtOffset(text: string, offset: number): string;
 export declare function getSpacingReplacement(sourceCode: Readonly<TSESLint.SourceCode>, betweenText: string, nextLine: number, blankLineCount: number): string;