@taiga-ui/eslint-plugin-experience-next 0.513.0 → 0.515.0

package/README.md

@@ -95,6 +95,8 @@ from third-party plugins. The exact severities and file globs live in
 | [no-implicit-public](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-implicit-public.md)                                                           | Require explicit `public` modifier for class members and parameter properties                       | ✅  | 🔧  |     |
 | [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

@@ -99,6 +99,12 @@ declare const plugin: {
         'no-legacy-peer-deps': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLegacyPeerDeps", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        '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,
 };
 
@@ -1309,6 +1310,8 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-duplicate-id': 'error',
             '@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',
@@ -33212,9 +33215,44 @@ __name(compileHmrUpdateCallback, "compileHmrUpdateCallback");
 var VERSION = new Version("20.3.12");
 publishFacade(_global);
 
+function getAttributeNames(name) {
+    return typeof name === 'string'
+        ? [name.toLowerCase()]
+        : name.map((item) => item.toLowerCase());
+}
+function isMatchingAttributeName(name, names) {
+    return names.includes(name.toLowerCase());
+}
 function getAttributeValueSpan(attr) {
     return attr instanceof dist$4.TmplAstBoundEvent ? attr.handlerSpan : attr.valueSpan;
 }
+function getStaticAttribute(element, name) {
+    const attrName = name.toLowerCase();
+    return element.attributes.find((attr) => attr.name.toLowerCase() === attrName);
+}
+function getStaticAttributeValue(element, name) {
+    return getStaticAttribute(element, name)?.value;
+}
+function hasInputBinding(element, name) {
+    const names = getAttributeNames(name);
+    return element.inputs.some((input) => isMatchingAttributeName(input.name, names));
+}
+function hasElementAttribute(element, name) {
+    const names = getAttributeNames(name);
+    return (element.attributes.some((attr) => isMatchingAttributeName(attr.name, names)) ||
+        element.inputs.some((input) => {
+            if (isMatchingAttributeName(input.name, names)) {
+                return true;
+            }
+            const details = input.keySpan.details?.toLowerCase();
+            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 [
@@ -33246,6 +33284,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 = {};
 
@@ -46233,7 +46277,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join('\n');
 }
-const rule$T = createRule({
+const rule$V = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -46413,7 +46457,7 @@ function sameOrder(a, b) {
     return a.length === b.length && a.every((value, index) => value === b[index]);
 }
 
-const rule$S = createRule({
+const rule$U = createRule({
     create(context, [order]) {
         const decorators = new Set(Object.keys(order));
         return {
@@ -46525,7 +46569,7 @@ const INLINE_HTML_ELEMENTS = new Set([
     'wbr',
 ]);
 
-const MESSAGE_ID$g = 'expectAfter';
+const MESSAGE_ID$i = 'expectAfter';
 const SKIP_CHILDREN = new Set(['code', 'pre']);
 function isChildNode(node) {
     return (node instanceof dist$4.TmplAstBoundText ||
@@ -46549,7 +46593,7 @@ function getNodeLabel(node) {
     }
     return node instanceof dist$4.TmplAstBoundText ? 'binding' : 'text';
 }
-const rule$R = createRule({
+const rule$T = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
@@ -46575,7 +46619,7 @@ const rule$R = createRule({
                                 firstChild.sourceSpan.start.offset,
                             ], '\n'),
                             loc: sourceSpanToLoc(firstChild.sourceSpan),
-                            messageId: MESSAGE_ID$g,
+                            messageId: MESSAGE_ID$i,
                         });
                         return;
                     }
@@ -46593,7 +46637,7 @@ const rule$R = createRule({
                                     child.sourceSpan.end.offset,
                                 ], '\n'),
                                 loc: sourceSpanToLoc(next.sourceSpan),
-                                messageId: MESSAGE_ID$g,
+                                messageId: MESSAGE_ID$i,
                             });
                             return;
                         }
@@ -46607,7 +46651,7 @@ const rule$R = createRule({
                                 lastChild.sourceSpan.end.offset,
                             ], '\n'),
                             loc: sourceSpanToLoc(lastChild.sourceSpan),
-                            messageId: MESSAGE_ID$g,
+                            messageId: MESSAGE_ID$i,
                         });
                     }
                 },
@@ -46616,7 +46660,7 @@ const rule$R = createRule({
         meta: {
             docs: { description: 'Enforce line breaks between block-level child nodes' },
             fixable: 'code',
-            messages: { [MESSAGE_ID$g]: 'There should be a linebreak after {{name}}.' },
+            messages: { [MESSAGE_ID$i]: 'There should be a linebreak after {{name}}.' },
             schema: [],
             type: 'layout',
         },
@@ -46688,7 +46732,7 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const rule$Q = createRule({
+const rule$S = createRule({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -46968,8 +47012,8 @@ const DIRECTIONAL_TO_LOGICAL = {
     top: 'inset-block-start',
 };
 const STYLE_PREFIX = 'style.';
-const MESSAGE_ID$f = '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
@@ -47006,20 +47050,20 @@ const config$4 = {
                 context.report({
                     fix: (fixer) => fixer.replaceTextRange([propertyStart, propertyEnd], logicalProperty),
                     loc: sourceSpanToLoc(keySpan),
-                    messageId: MESSAGE_ID$f,
+                    messageId: MESSAGE_ID$h,
                 });
             },
         };
     },
     meta: {
-        docs: { description: MESSAGE },
+        docs: { description: MESSAGE$1 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$f]: MESSAGE },
+        messages: { [MESSAGE_ID$h]: MESSAGE$1 },
         schema: [],
         type: 'suggestion',
     },
 };
-const rule$P = createRule({
+const rule$R = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
@@ -248261,7 +248305,7 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     }
     return hasSafeRuntimeUsage;
 }
-const rule$O = createRule({
+const rule$Q = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
         const checkCycles = context.options[0]?.checkCycles ?? true;
@@ -248923,7 +248967,7 @@ const rule$O = createRule({
     name: 'import-integrity',
 });
 
-const MESSAGE_ID$e = '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) {
@@ -248986,7 +249030,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$N = createRule({
+const rule$P = createRule({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -249018,7 +249062,7 @@ const rule$N = createRule({
                             }
                             return fixes;
                         },
-                        messageId: MESSAGE_ID$e,
+                        messageId: MESSAGE_ID$g,
                         node: description,
                     });
                 }
@@ -249028,14 +249072,14 @@ const rule$N = createRule({
     meta: {
         docs: { description: ERROR_MESSAGE$3 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$e]: ERROR_MESSAGE$3 },
+        messages: { [MESSAGE_ID$g]: ERROR_MESSAGE$3 },
         schema: [],
         type: 'problem',
     },
     name: 'injection-token-description',
 });
 
-const rule$M = createRule({
+const rule$O = createRule({
     create(context) {
         const { sourceCode } = context;
         const namespaceImports = new Map();
@@ -249111,7 +249155,7 @@ const rule$M = createRule({
     name: 'no-commonjs-import-patterns',
 });
 
-const MESSAGE_ID$d = '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',
@@ -249130,7 +249174,7 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const rule$L = createRule({
+const rule$N = createRule({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -249172,7 +249216,7 @@ const rule$L = createRule({
                         const [start, end] = node.source.range;
                         return fixer.replaceTextRange([start + 1, end - 1], importSource.replaceAll(new RegExp(deepImport, 'g'), ''));
                     },
-                    messageId: MESSAGE_ID$d,
+                    messageId: MESSAGE_ID$f,
                     node: node.source,
                 });
             },
@@ -249182,7 +249226,7 @@ const rule$L = createRule({
         defaultOptions: [DEFAULT_OPTIONS],
         docs: { description: ERROR_MESSAGE$2 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$d]: ERROR_MESSAGE$2 },
+        messages: { [MESSAGE_ID$f]: ERROR_MESSAGE$2 },
         schema: [
             {
                 additionalProperties: false,
@@ -249222,7 +249266,7 @@ const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-const rule$K = createRule({
+const rule$M = createRule({
     create(context) {
         const parserServices = dist$3.ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -249416,13 +249460,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$J = createRule({
+const rule$L = createRule({
     name: 'no-duplicate-attrs',
     rule: noDuplicateAttributesRule,
 });
 
-const MESSAGE_ID$c = 'duplicateId';
-const rule$I = createRule({
+const MESSAGE_ID$e = 'duplicateId';
+const rule$K = createRule({
     name: 'no-duplicate-id',
     rule: {
         create(context) {
@@ -249445,7 +249489,7 @@ const rule$I = createRule({
                             context.report({
                                 data: { id },
                                 loc: sourceSpanToLoc(attr.sourceSpan),
-                                messageId: MESSAGE_ID$c,
+                                messageId: MESSAGE_ID$e,
                             });
                         }
                     }
@@ -249454,36 +249498,33 @@ const rule$I = createRule({
         },
         meta: {
             docs: { description: 'Disallow duplicate static id attributes' },
-            messages: { [MESSAGE_ID$c]: "The id '{{id}}' is duplicated." },
+            messages: { [MESSAGE_ID$e]: "The id '{{id}}' is duplicated." },
             schema: [],
             type: 'problem',
         },
     },
 });
 
-const MESSAGE_ID$b = 'duplicateTag';
-function findAttr(node, attrName) {
-    return node.attributes.find((attr) => attr.name === attrName);
-}
+const MESSAGE_ID$d = 'duplicateTag';
 function getTrackingKey(node) {
     if (node.name === 'title' || node.name === 'base') {
         return node.name;
     }
     if (node.name === 'meta') {
-        if (findAttr(node, 'charset')) {
+        if (getStaticAttribute(node, 'charset')) {
             return 'meta[charset]';
         }
-        if (findAttr(node, 'name')?.value === 'viewport') {
+        if (getStaticAttribute(node, 'name')?.value === 'viewport') {
             return 'meta[name=viewport]';
         }
     }
     return node.name === 'link' &&
-        findAttr(node, 'rel')?.value === 'canonical' &&
-        findAttr(node, 'href')
+        getStaticAttribute(node, 'rel')?.value === 'canonical' &&
+        getStaticAttribute(node, 'href')
         ? 'link[rel=canonical]'
         : null;
 }
-const rule$H = createRule({
+const rule$J = createRule({
     name: 'no-duplicate-in-head',
     rule: {
         create(context) {
@@ -249520,7 +249561,7 @@ const rule$H = createRule({
                             context.report({
                                 data: { tag },
                                 loc: sourceSpanToLoc(duplicate.startSourceSpan),
-                                messageId: MESSAGE_ID$b,
+                                messageId: MESSAGE_ID$d,
                             });
                         }
                     }
@@ -249531,7 +249572,7 @@ const rule$H = createRule({
             docs: {
                 description: 'Disallow duplicate title/base/meta/link tags inside head',
             },
-            messages: { [MESSAGE_ID$b]: 'Duplicate <{{tag}}> tag in <head>.' },
+            messages: { [MESSAGE_ID$d]: 'Duplicate <{{tag}}> tag in <head>.' },
             schema: [],
             type: 'problem',
         },
@@ -249539,7 +249580,7 @@ const rule$H = createRule({
 });
 
 const COMPONENT_DECORATORS = new Set(['Component']);
-const rule$G = createRule({
+const rule$I = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -250187,7 +250228,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$F = createUntrackedRule({
+const rule$H = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250225,7 +250266,7 @@ const rule$F = createUntrackedRule({
     name: 'no-fully-untracked-effect',
 });
 
-const MESSAGE_ID$a = '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) {
@@ -250235,9 +250276,9 @@ const config$3 = {
                 if (node.name !== 'a') {
                     return;
                 }
-                const hrefAttr = node.attributes.find((attr) => attr.name === 'href');
-                const hasRouterLink = node.attributes.some((attr) => attr.name.toLowerCase() === 'routerlink') ||
-                    node.inputs.some((input) => input.name.toLowerCase() === 'routerlink');
+                const hrefAttr = getStaticAttribute(node, 'href');
+                const hasRouterLink = Boolean(getStaticAttribute(node, 'routerlink')) ||
+                    hasInputBinding(node, 'routerlink');
                 if (!hrefAttr || !hasRouterLink) {
                     return;
                 }
@@ -250247,7 +250288,7 @@ const config$3 = {
                         hrefAttr.sourceSpan.end.offset,
                     ]),
                     loc: sourceSpanToLoc(hrefAttr.sourceSpan),
-                    messageId: MESSAGE_ID$a,
+                    messageId: MESSAGE_ID$c,
                 });
             },
         };
@@ -250255,12 +250296,12 @@ const config$3 = {
     meta: {
         docs: { description: ERROR_MESSAGE$1 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$a]: ERROR_MESSAGE$1 },
+        messages: { [MESSAGE_ID$c]: ERROR_MESSAGE$1 },
         schema: [],
         type: 'problem',
     },
 };
-const rule$E = createRule({
+const rule$G = createRule({
     name: 'no-href-with-router-link',
     rule: config$3,
 });
@@ -250321,7 +250362,7 @@ function getScopeRoot(node) {
     return (findAncestor(node, (ancestor) => ancestor.type === dist$3.AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
 }
 
-const rule$D = createRule({
+const rule$F = createRule({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getEnclosingClass(node);
@@ -250383,7 +250424,7 @@ const rule$D = createRule({
     name: 'no-implicit-public',
 });
 
-const rule$C = createRule({
+const rule$E = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -250439,7 +250480,7 @@ function isInfiniteLoopLiteral(node) {
 function isInfiniteLoopTest(test) {
     return test == null || isInfiniteLoopLiteral(test);
 }
-const rule$B = createRule({
+const rule$D = createRule({
     create(context) {
         return {
             DoWhileStatement(node) {
@@ -250484,7 +250525,7 @@ const rule$B = createRule({
 });
 
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$A = createRule({
+const rule$C = createRule({
     create(context) {
         return {
             Program(node) {
@@ -250522,6 +250563,395 @@ const rule$A = createRule({
     name: 'no-legacy-peer-deps',
 });
 
+function isInteractiveElement(node) {
+    const tagName = node.name.toLowerCase();
+    if (hasElementAttribute(node, 'tabindex') || hasOutputBinding(node)) {
+        return true;
+    }
+    switch (tagName) {
+        case 'a':
+            return hasElementAttribute(node, ['href', 'routerLink']);
+        case 'area':
+            return hasElementAttribute(node, 'href');
+        case 'audio':
+            return hasElementAttribute(node, 'controls');
+        case 'button':
+            return true;
+        case 'details':
+            return true;
+        case 'embed':
+            return true;
+        case 'iframe':
+            return true;
+        case 'img':
+            return hasElementAttribute(node, 'usemap');
+        case 'input':
+            return (getStaticAttributeValue(node, 'type')?.trim().toLowerCase() !== 'hidden');
+        case 'label':
+            return true;
+        case 'select':
+            return true;
+        case 'summary':
+            return true;
+        case 'textarea':
+            return true;
+        case 'video':
+            return hasElementAttribute(node, 'controls');
+        default:
+            return false;
+    }
+}
+
+const MESSAGE_ID$b = 'noNestedInteractive';
+function getAvailableLabelParent(stack, node, labelsWithControl) {
+    const parent = stack[stack.length - 1];
+    return stack.length === 1 &&
+        parent?.name.toLowerCase() === 'label' &&
+        node.name.toLowerCase() !== 'label' &&
+        !labelsWithControl.has(parent)
+        ? parent
+        : null;
+}
+const rule$B = createRule({
+    name: 'no-nested-interactive',
+    rule: {
+        create(context) {
+            const interactiveStack = [];
+            const labelsWithControl = new WeakSet();
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    if (!isInteractiveElement(node)) {
+                        return;
+                    }
+                    const parent = interactiveStack[interactiveStack.length - 1];
+                    const availableLabelParent = getAvailableLabelParent(interactiveStack, node, labelsWithControl);
+                    if (availableLabelParent) {
+                        labelsWithControl.add(availableLabelParent);
+                    }
+                    else if (parent) {
+                        context.report({
+                            data: { tag: parent.name },
+                            loc: sourceSpanToLoc(node.startSourceSpan),
+                            messageId: MESSAGE_ID$b,
+                        });
+                    }
+                    interactiveStack.push(node);
+                },
+                'Element:exit'(rawNode) {
+                    const node = rawNode;
+                    if (interactiveStack[interactiveStack.length - 1] === node) {
+                        interactiveStack.pop();
+                    }
+                },
+            };
+        },
+        meta: {
+            docs: { description: 'Disallow nested interactive elements' },
+            messages: {
+                [MESSAGE_ID$b]: 'Unexpected interactive element nested inside interactive <{{tag}}>.',
+            },
+            schema: [],
+            type: 'problem',
+        },
+    },
+});
+
+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: [
         {
@@ -254048,10 +254478,6 @@ const rule$e = createRule({
 });
 
 const MESSAGE_ID$5 = 'missingAlt';
-function hasAlt(node) {
-    return (node.attributes.some((attr) => attr.name === 'alt') ||
-        node.inputs.some((input) => input.name === 'alt' || input.keySpan.details === 'attr.alt'));
-}
 const rule$d = createRule({
     name: 'require-img-alt',
     rule: {
@@ -254059,7 +254485,7 @@ const rule$d = createRule({
             return {
                 Element(rawNode) {
                     const node = rawNode;
-                    if (node.name !== 'img' || hasAlt(node)) {
+                    if (node.name !== 'img' || hasElementAttribute(node, 'alt')) {
                         return;
                     }
                     context.report({
@@ -254092,16 +254518,14 @@ const rule$c = createRule({
                     if (node.name !== 'html') {
                         return;
                     }
-                    const langAttr = node.attributes.find((attr) => attr.name === 'lang');
-                    const hasBoundLang = node.inputs.some((input) => input.name === 'lang' ||
-                        input.keySpan.details === 'attr.lang');
-                    if (!langAttr && !hasBoundLang) {
+                    if (!hasElementAttribute(node, 'lang')) {
                         context.report({
                             loc: sourceSpanToLoc(node.startSourceSpan),
                             messageId: MESSAGE_IDS$1.MISSING,
                         });
                         return;
                     }
+                    const langAttr = getStaticAttribute(node, 'lang');
                     if (langAttr?.value.trim().length === 0) {
                         context.report({
                             loc: sourceSpanToLoc(langAttr.sourceSpan),
@@ -254430,49 +254854,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);
@@ -255707,28 +256088,30 @@ const plugin = {
     },
     rules: {
         'array-as-const': rule$5,
-        'attrs-newline': rule$T,
+        'attrs-newline': rule$V,
         'class-property-naming': rule$4,
-        'decorator-key-sort': rule$S,
-        'element-newline': rule$R,
+        'decorator-key-sort': rule$U,
+        'element-newline': rule$T,
         'flat-exports': rule$3,
-        'host-attributes-sort': rule$Q,
-        'html-logical-properties': rule$P,
-        'import-integrity': rule$O,
-        'injection-token-description': rule$N,
-        'no-commonjs-import-patterns': rule$M,
-        'no-deep-imports': rule$L,
-        'no-deep-imports-to-indexed-packages': rule$K,
-        'no-duplicate-attrs': rule$J,
-        'no-duplicate-id': rule$I,
-        'no-duplicate-in-head': rule$H,
-        'no-empty-style-metadata': rule$G,
-        'no-fully-untracked-effect': rule$F,
-        'no-href-with-router-link': rule$E,
-        'no-implicit-public': rule$D,
-        'no-import-assertions': rule$C,
-        'no-infinite-loop': rule$B,
-        'no-legacy-peer-deps': 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,7 +1,11 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.513.0",
+  "version": "0.515.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
+  "homepage": "https://github.com/taiga-family/toolkit#readme",
+  "bugs": {
+    "url": "https://github.com/taiga-family/toolkit/issues"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/taiga-family/toolkit.git"

package/rules/recommended/no-nested-interactive.d.ts

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

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/element-attributes.d.ts

@@ -1,4 +1,11 @@
 import { type ParseSourceSpan, type TmplAstBoundAttribute, TmplAstBoundEvent, type TmplAstElement, type TmplAstReference, type TmplAstTextAttribute } from '@angular-eslint/bundled-angular-compiler';
 export type ElementAttributeLike = TmplAstBoundAttribute | TmplAstBoundEvent | TmplAstReference | TmplAstTextAttribute;
+export type ElementAttributeName = string | readonly string[];
 export declare function getAttributeValueSpan(attr: ElementAttributeLike): ParseSourceSpan | undefined;
+export declare function getStaticAttribute(element: TmplAstElement, name: string): TmplAstTextAttribute | undefined;
+export declare function getStaticAttributeValue(element: TmplAstElement, name: string): string | undefined;
+export declare function hasInputBinding(element: TmplAstElement, name: ElementAttributeName): boolean;
+export declare function hasAttributeBinding(element: TmplAstElement, name: ElementAttributeName): boolean;
+export declare function hasElementAttribute(element: TmplAstElement, name: ElementAttributeName): boolean;
+export declare function hasOutputBinding(element: TmplAstElement, name?: ElementAttributeName): boolean;
 export declare function getElementAttributeLikes(element: TmplAstElement): ElementAttributeLike[];

package/rules/utils/angular/interactive-elements.d.ts

@@ -0,0 +1,2 @@
+import { type TmplAstElement } from '@angular-eslint/bundled-angular-compiler';
+export declare function isInteractiveElement(node: TmplAstElement): boolean;

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;