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

package/README.md

@@ -95,6 +95,7 @@ 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-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/index.d.ts

@@ -99,6 +99,9 @@ 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-obsolete-attrs': import("eslint").Rule.RuleModule & {
             name: string;
         };

package/index.esm.js

@@ -1309,6 +1309,7 @@ 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-obsolete-attrs': 'error',
             '@taiga-ui/experience-next/no-obsolete-tags': 'error',
             '@taiga-ui/experience-next/no-project-as-in-ng-template': 'error',
@@ -33212,9 +33213,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 [
@@ -46233,7 +46269,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join('\n');
 }
-const rule$T = createRule({
+const rule$U = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -46413,7 +46449,7 @@ function sameOrder(a, b) {
     return a.length === b.length && a.every((value, index) => value === b[index]);
 }
 
-const rule$S = createRule({
+const rule$T = createRule({
     create(context, [order]) {
         const decorators = new Set(Object.keys(order));
         return {
@@ -46525,7 +46561,7 @@ const INLINE_HTML_ELEMENTS = new Set([
     'wbr',
 ]);
 
-const MESSAGE_ID$g = 'expectAfter';
+const MESSAGE_ID$h = 'expectAfter';
 const SKIP_CHILDREN = new Set(['code', 'pre']);
 function isChildNode(node) {
     return (node instanceof dist$4.TmplAstBoundText ||
@@ -46549,7 +46585,7 @@ function getNodeLabel(node) {
     }
     return node instanceof dist$4.TmplAstBoundText ? 'binding' : 'text';
 }
-const rule$R = createRule({
+const rule$S = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
@@ -46575,7 +46611,7 @@ const rule$R = createRule({
                                 firstChild.sourceSpan.start.offset,
                             ], '\n'),
                             loc: sourceSpanToLoc(firstChild.sourceSpan),
-                            messageId: MESSAGE_ID$g,
+                            messageId: MESSAGE_ID$h,
                         });
                         return;
                     }
@@ -46593,7 +46629,7 @@ const rule$R = createRule({
                                     child.sourceSpan.end.offset,
                                 ], '\n'),
                                 loc: sourceSpanToLoc(next.sourceSpan),
-                                messageId: MESSAGE_ID$g,
+                                messageId: MESSAGE_ID$h,
                             });
                             return;
                         }
@@ -46607,7 +46643,7 @@ const rule$R = createRule({
                                 lastChild.sourceSpan.end.offset,
                             ], '\n'),
                             loc: sourceSpanToLoc(lastChild.sourceSpan),
-                            messageId: MESSAGE_ID$g,
+                            messageId: MESSAGE_ID$h,
                         });
                     }
                 },
@@ -46616,7 +46652,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$h]: 'There should be a linebreak after {{name}}.' },
             schema: [],
             type: 'layout',
         },
@@ -46688,7 +46724,7 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const rule$Q = createRule({
+const rule$R = createRule({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -46968,7 +47004,7 @@ const DIRECTIONAL_TO_LOGICAL = {
     top: 'inset-block-start',
 };
 const STYLE_PREFIX = 'style.';
-const MESSAGE_ID$f = 'html-logical-properties';
+const MESSAGE_ID$g = 'html-logical-properties';
 const MESSAGE = `
 Use logical CSS properties instead of directional properties. Replace:
 • left → inset-inline-start
@@ -47006,7 +47042,7 @@ const config$4 = {
                 context.report({
                     fix: (fixer) => fixer.replaceTextRange([propertyStart, propertyEnd], logicalProperty),
                     loc: sourceSpanToLoc(keySpan),
-                    messageId: MESSAGE_ID$f,
+                    messageId: MESSAGE_ID$g,
                 });
             },
         };
@@ -47014,12 +47050,12 @@ const config$4 = {
     meta: {
         docs: { description: MESSAGE },
         fixable: 'code',
-        messages: { [MESSAGE_ID$f]: MESSAGE },
+        messages: { [MESSAGE_ID$g]: MESSAGE },
         schema: [],
         type: 'suggestion',
     },
 };
-const rule$P = createRule({
+const rule$Q = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
@@ -248261,7 +248297,7 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     }
     return hasSafeRuntimeUsage;
 }
-const rule$O = createRule({
+const rule$P = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
         const checkCycles = context.options[0]?.checkCycles ?? true;
@@ -248923,7 +248959,7 @@ const rule$O = createRule({
     name: 'import-integrity',
 });
 
-const MESSAGE_ID$e = 'invalid-injection-token-description';
+const MESSAGE_ID$f = '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 +249022,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$O = createRule({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -249018,7 +249054,7 @@ const rule$N = createRule({
                             }
                             return fixes;
                         },
-                        messageId: MESSAGE_ID$e,
+                        messageId: MESSAGE_ID$f,
                         node: description,
                     });
                 }
@@ -249028,14 +249064,14 @@ const rule$N = createRule({
     meta: {
         docs: { description: ERROR_MESSAGE$3 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$e]: ERROR_MESSAGE$3 },
+        messages: { [MESSAGE_ID$f]: ERROR_MESSAGE$3 },
         schema: [],
         type: 'problem',
     },
     name: 'injection-token-description',
 });
 
-const rule$M = createRule({
+const rule$N = createRule({
     create(context) {
         const { sourceCode } = context;
         const namespaceImports = new Map();
@@ -249111,7 +249147,7 @@ const rule$M = createRule({
     name: 'no-commonjs-import-patterns',
 });
 
-const MESSAGE_ID$d = 'no-deep-imports';
+const MESSAGE_ID$e = 'no-deep-imports';
 const ERROR_MESSAGE$2 = 'Deep imports of Taiga UI packages are prohibited';
 const CODE_EXTENSIONS = new Set([
     '.cjs',
@@ -249130,7 +249166,7 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const rule$L = createRule({
+const rule$M = createRule({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -249172,7 +249208,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$e,
                     node: node.source,
                 });
             },
@@ -249182,7 +249218,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$e]: ERROR_MESSAGE$2 },
         schema: [
             {
                 additionalProperties: false,
@@ -249222,7 +249258,7 @@ const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-const rule$K = createRule({
+const rule$L = createRule({
     create(context) {
         const parserServices = dist$3.ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -249416,13 +249452,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$K = createRule({
     name: 'no-duplicate-attrs',
     rule: noDuplicateAttributesRule,
 });
 
-const MESSAGE_ID$c = 'duplicateId';
-const rule$I = createRule({
+const MESSAGE_ID$d = 'duplicateId';
+const rule$J = createRule({
     name: 'no-duplicate-id',
     rule: {
         create(context) {
@@ -249445,7 +249481,7 @@ const rule$I = createRule({
                             context.report({
                                 data: { id },
                                 loc: sourceSpanToLoc(attr.sourceSpan),
-                                messageId: MESSAGE_ID$c,
+                                messageId: MESSAGE_ID$d,
                             });
                         }
                     }
@@ -249454,36 +249490,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$d]: "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$c = '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$I = createRule({
     name: 'no-duplicate-in-head',
     rule: {
         create(context) {
@@ -249520,7 +249553,7 @@ const rule$H = createRule({
                             context.report({
                                 data: { tag },
                                 loc: sourceSpanToLoc(duplicate.startSourceSpan),
-                                messageId: MESSAGE_ID$b,
+                                messageId: MESSAGE_ID$c,
                             });
                         }
                     }
@@ -249531,7 +249564,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$c]: 'Duplicate <{{tag}}> tag in <head>.' },
             schema: [],
             type: 'problem',
         },
@@ -249539,7 +249572,7 @@ const rule$H = createRule({
 });
 
 const COMPONENT_DECORATORS = new Set(['Component']);
-const rule$G = createRule({
+const rule$H = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -250187,7 +250220,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$G = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250225,7 +250258,7 @@ const rule$F = createUntrackedRule({
     name: 'no-fully-untracked-effect',
 });
 
-const MESSAGE_ID$a = 'no-href-with-router-link';
+const MESSAGE_ID$b = '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 +250268,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 +250280,7 @@ const config$3 = {
                         hrefAttr.sourceSpan.end.offset,
                     ]),
                     loc: sourceSpanToLoc(hrefAttr.sourceSpan),
-                    messageId: MESSAGE_ID$a,
+                    messageId: MESSAGE_ID$b,
                 });
             },
         };
@@ -250255,12 +250288,12 @@ const config$3 = {
     meta: {
         docs: { description: ERROR_MESSAGE$1 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$a]: ERROR_MESSAGE$1 },
+        messages: { [MESSAGE_ID$b]: ERROR_MESSAGE$1 },
         schema: [],
         type: 'problem',
     },
 };
-const rule$E = createRule({
+const rule$F = createRule({
     name: 'no-href-with-router-link',
     rule: config$3,
 });
@@ -250321,7 +250354,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$E = createRule({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getEnclosingClass(node);
@@ -250383,7 +250416,7 @@ const rule$D = createRule({
     name: 'no-implicit-public',
 });
 
-const rule$C = createRule({
+const rule$D = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -250439,7 +250472,7 @@ function isInfiniteLoopLiteral(node) {
 function isInfiniteLoopTest(test) {
     return test == null || isInfiniteLoopLiteral(test);
 }
-const rule$B = createRule({
+const rule$C = createRule({
     create(context) {
         return {
             DoWhileStatement(node) {
@@ -250484,7 +250517,7 @@ const rule$B = createRule({
 });
 
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$A = createRule({
+const rule$B = createRule({
     create(context) {
         return {
             Program(node) {
@@ -250522,6 +250555,100 @@ 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$a = '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$A = 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$a,
+                        });
+                    }
+                    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$a]: 'Unexpected interactive element nested inside interactive <{{tag}}>.',
+            },
+            schema: [],
+            type: 'problem',
+        },
+    },
+});
+
 const OBSOLETE_HTML_ATTRS = {
     abbr: [
         {
@@ -254048,10 +254175,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 +254182,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 +254215,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),
@@ -255707,28 +255828,29 @@ const plugin = {
     },
     rules: {
         'array-as-const': rule$5,
-        'attrs-newline': rule$T,
+        'attrs-newline': rule$U,
         'class-property-naming': rule$4,
-        'decorator-key-sort': rule$S,
-        'element-newline': rule$R,
+        'decorator-key-sort': rule$T,
+        'element-newline': rule$S,
         '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$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,
         '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.512.0",
+  "version": "0.514.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/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;