npm - @taiga-ui/eslint-plugin-experience-next - Versions diffs - 0.480.0 → 0.482.0 - Mend

@taiga-ui/eslint-plugin-experience-next 0.480.0 → 0.482.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (79) hide show

package/README.md CHANGED Viewed

@@ -37,1679 +37,53 @@ export default [
 - 🔧 = fixable
 - 💡 = has suggestions
-| Rule                                            | Description                                                                                         | ✅  | 🔧  | 💡  |
-| ----------------------------------------------- | --------------------------------------------------------------------------------------------------- | --- | --- | --- |
-| array-as-const                                  | Exported array of class references should be marked with `as const`                                 |     | 🔧  |     |
-| attrs-newline                                   | Enforce one attribute per line when a start tag spans multiple lines                                |     | 🔧  |     |
-| class-property-naming                           | Enforce custom naming for class properties based on their type                                      |     | 🔧  |     |
-| decorator-key-sort                              | Sorts the keys of the object passed to the `@Component/@Injectable/@NgModule/@Pipe` decorator       | ✅  | 🔧  |     |
-| element-newline                                 | Require line breaks around block-level child nodes in HTML templates                                |     | 🔧  |     |
-| flat-exports                                    | Spread nested arrays when exporting Angular entity collections                                      |     | 🔧  |     |
-| host-attributes-sort                            | Sort Angular host metadata attributes using configurable attribute groups                           | ✅  | 🔧  |     |
-| injection-token-description                     | Require `InjectionToken` descriptions to include the token name                                     | ✅  | 🔧  |     |
-| no-commonjs-import-patterns                     | Disallow legacy CommonJS interop import patterns                                                    | ✅  |     |     |
-| no-deep-imports                                 | Disables deep imports of Taiga UI packages                                                          | ✅  | 🔧  |     |
-| no-deep-imports-to-indexed-packages             | Disallow deep imports from packages that expose an index.ts next to ng-package.json or package.json | ✅  | 🔧  |     |
-| no-duplicate-attrs                              | Disallow duplicate attributes on the same HTML element                                              |     |     |     |
-| no-duplicate-id                                 | Disallow duplicate static `id` values in HTML templates                                             |     |     |     |
-| no-duplicate-in-head                            | Disallow duplicate `title`, `base`, and key metadata tags inside `<head>`                           |     |     |     |
-| no-fully-untracked-effect                       | Disallow reactive callbacks where all signal reads are hidden inside `untracked()`                  | ✅  |     |     |
-| no-href-with-router-link                        | Do not use href and routerLink attributes together on the same element                              | ✅  | 🔧  |     |
-| no-import-assertions                            | Replace legacy `assert { ... }` import assertions with `with { ... }`                               | ✅  | 🔧  |     |
-| no-implicit-public                              | Require explicit `public` modifier for class members and parameter properties                       | ✅  | 🔧  |     |
-| no-infinite-loop                                | Disallow `while (true)` and `for` loops without an explicit condition                               | ✅  |     |     |
-| no-legacy-peer-deps                             | Disallow `legacy-peer-deps=true` in `.npmrc`                                                        | ✅  |     |     |
-| no-obsolete-attrs                               | Disallow obsolete HTML attributes                                                                   |     |     |     |
-| no-obsolete-tags                                | Disallow obsolete HTML tags                                                                         |     |     |     |
-| no-playwright-empty-fill                        | Enforce `clear()` over `fill('')` in Playwright tests                                               | ✅  | 🔧  |     |
-| no-project-as-in-ng-template                    | `ngProjectAs` has no effect inside `<ng-template>` or dynamic outlets                               | ✅  |     |     |
-| no-restricted-attr-values                       | Disallow configured attribute values in Angular templates                                           |     |     |     |
-| no-redundant-type-annotation                    | Disallow redundant type annotations when the type is already inferred from the initializer          | ✅  | 🔧  |     |
-| no-side-effects-in-computed                     | Disallow side effects and effectful helper calls inside Angular `computed()` callbacks              | ✅  |     |     |
-| no-signal-reads-after-await-in-reactive-context | Disallow bare signal reads after `await` inside reactive callbacks                                  | ✅  |     |     |
-| no-string-literal-concat                        | Disallow string literal concatenation; merge adjacent literals into one                             | ✅  | 🔧  |     |
-| no-untracked-outside-reactive-context           | Disallow `untracked()` outside reactive callbacks, except explicit post-`await` snapshots           | ✅  | 🔧  |     |
-| no-useless-untracked                            | Disallow provably useless `untracked()` wrappers in reactive callbacks                              | ✅  | 🔧  |     |
-| object-single-line                              | Enforce single-line formatting for single-property objects when it fits `printWidth`                | ✅  | 🔧  |     |
-| prefer-combined-if-control-flow                 | Combine consecutive `if` statements that use the same `return`, `break`, `continue`, or `throw`     | ✅  | 🔧  |     |
-| prefer-deep-imports                             | Allow deep imports of Taiga UI packages                                                             |     | 🔧  |     |
-| prefer-multi-arg-push                           | Combine consecutive `.push()` calls on the same array into a single multi-argument call             | ✅  | 🔧  |     |
-| prefer-namespace-keyword                        | Replace `module Foo {}` with `namespace Foo {}` for TypeScript namespace declarations               | ✅  | 🔧  |     |
-| prefer-untracked-incidental-signal-reads        | Wrap likely-incidental signal reads with `untracked()` in reactive callbacks                        | ✅  | 🔧  |     |
-| prefer-untracked-signal-getter                  | Prefer `untracked(signalGetter)` over `untracked(() => signalGetter())` for a single signal getter  | ✅  | 🔧  |     |
-| quotes                                          | Enforce double quotes around HTML attribute values                                                  |     | 🔧  |     |
-| require-doctype                                 | Require `<!DOCTYPE html>` at the top of HTML documents                                              |     | 🔧  |     |
-| require-img-alt                                 | Require `alt` on `<img>` elements, including Angular attribute bindings                             |     |     |     |
-| require-lang                                    | Require a non-empty `lang` attribute on `<html>`                                                    |     |     |     |
-| require-li-container                            | Require `<li>` to be nested inside `<ul>`, `<ol>`, or `<menu>`                                      |     |     |     |
-| require-title                                   | Require a non-empty `<title>` inside `<head>`                                                       |     |     |     |
-| short-tui-imports                               | Shorten TuiXxxComponent / TuiYyyDirective in Angular metadata                                       | ✅  | 🔧  |     |
-| single-line-class-property-spacing              | Group consecutive single-line class properties and separate multiline ones with a blank line        | ✅  | 🔧  |     |
-| standalone-imports-sort                         | Auto sort names inside Angular decorators                                                           | ✅  | 🔧  |     |
-| strict-tui-doc-example                          | If you use the addon-doc, there will be a hint that you are importing something incorrectly         |     | 🔧  |     |
----
-## array-as-const
-<sup>`Taiga-specific`</sup> <sup>`Fixable`</sup>
-Exported arrays containing only class references must be marked with `as const` to preserve the tuple type and enable
-proper type inference.
-```ts
-// ❌ error
-export const PROVIDERS = [FooService, BarService];
-// ✅ after autofix
-export const PROVIDERS = [FooService, BarService] as const;
-```
----
-## attrs-newline
-<sup>`Fixable`</sup>
-Requires line breaks between attributes when a start tag has more than two attributes. This keeps larger HTML tags
-readable and makes attribute diffs much easier to scan in Angular templates.
-```html
-<!-- ❌ error -->
-<div
-  class="b"
-  id="a"
-  title="c"
-></div>
-<!-- ✅ after autofix -->
-<div
-  class="b"
-  id="a"
-  title="c"
-></div>
-```
----
-## class-property-naming
-<sup>`Taiga-specific`</sup> <sup>`Fixable`</sup>
-Enforce custom naming conventions for class properties based on their TypeScript type. Useful for enforcing project-wide
-patterns (e.g. all `Subject` fields must be called `destroy$`).
-Requires explicit configuration — not enabled in `recommended` by default.
-```json
-{
-  "@taiga-ui/experience-next/class-property-naming": [
-    "error",
-    [
-      {
-        "fieldNames": ["sub", "subscription"],
-        "newFieldName": "destroy$",
-        "withTypesSpecifier": ["Subject", "Subscription"]
-      }
-    ]
-  ]
-}
-```
-```ts
-// ❌ error
-class MyComponent {
-  sub = new Subject<void>();
-}
-// ✅ after autofix
-class MyComponent {
-  destroy$ = new Subject<void>();
-}
-```
----
-## decorator-key-sort
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Enforces a consistent key order inside Angular decorator objects (`@Component`, `@Directive`, `@NgModule`, `@Pipe`,
-`@Injectable`). The expected order is passed as configuration.
-```json
-{
-  "@taiga-ui/experience-next/decorator-key-sort": [
-    "error",
-    {
-      "Component": ["standalone", "selector", "imports", "templateUrl", "styleUrl", "changeDetection"],
-      "Pipe": ["standalone", "name", "pure"]
-    }
-  ]
-}
-```
-```ts
-// ❌ error
-@Component({
-    templateUrl: './app.component.html',
-    selector: 'app-root',
-    standalone: true,
-})
-// ✅ after autofix
-@Component({
-    standalone: true,
-    selector: 'app-root',
-    templateUrl: './app.component.html',
-})
-```
----
-## element-newline
-<sup>`Fixable`</sup>
-Requires line breaks around block-level child nodes. Inline text and inline elements can stay on one line, but block
-content should be visually separated from its container.
-```html
-<!-- ❌ error -->
-<div><section>Content</section></div>
-<!-- ✅ after autofix -->
-<div>
-  <section>Content</section>
-</div>
-```
----
-## flat-exports
-<sup>`Taiga-specific`</sup> <sup>`Fixable`</sup>
-When an exported `as const` tuple contains another exported `as const` tuple of Angular classes, it should be spread
-rather than nested. This keeps entity collections flat and avoids double-wrapping.
-```ts
-// ❌ error
-export const TuiTextfield = [TuiTextfieldDirective] as const;
-export const TuiInput = [TuiTextfield, TuiInputDirective] as const;
-// ✅ after autofix
-export const TuiTextfield = [TuiTextfieldDirective] as const;
-export const TuiInput = [...TuiTextfield, TuiInputDirective] as const;
-```
----
-## host-attributes-sort
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Sorts Angular `host` metadata entries in `@Component` and `@Directive` using configurable attribute groups, matching the
-same grouping model used for template attributes in Prettier. The recommended config enables the rule with a default
-group order that places `id` before plain attributes, `class`, animation bindings, inputs, two-way bindings, and
-outputs.
-```ts
-// ❌ error
-@Component({
-  host: {
-    '(click)': 'handleClick()',
-    '[value]': 'value()',
-    class: 'cmp',
-    id: 'cmp-id',
-  },
-})
-// ✅ after autofix
-@Component({
-  host: {
-    id: 'cmp-id',
-    class: 'cmp',
-    '[value]': 'value()',
-    '(click)': 'handleClick()',
-  },
-})
-```
-The rule understands the same preset names as `prettier-plugin-organize-attributes`. You can use aggregate presets such
-as `$ANGULAR`, `$HTML`, and `$CODE_GUIDE`, or compose atomic presets such as `$CLASS`, `$ID`, `$ARIA`, `$ANGULAR_INPUT`,
-`$ANGULAR_TWO_WAY_BINDING`, and `$ANGULAR_OUTPUT`.
-```json
-{
-  "@taiga-ui/experience-next/host-attributes-sort": [
-    "error",
-    {
-      "attributeGroups": ["$ANGULAR"]
-    }
-  ]
-}
-```
-Use `$ANGULAR` when `host` should follow the familiar Angular template-style order:
-`class -> id -> #ref -> *directive -> @animation -> [@animation] -> [(model)] -> [input] -> (output)`.
-```json
-{
-  "@taiga-ui/experience-next/host-attributes-sort": [
-    "error",
-    {
-      "attributeGroups": ["$HTML"]
-    }
-  ]
-}
-```
-Use `$HTML` when only `class` and `id` should be pulled to the front, and everything else can stay in the trailing
-default group.
-```json
-{
-  "@taiga-ui/experience-next/host-attributes-sort": [
-    "error",
-    {
-      "attributeGroups": ["$CODE_GUIDE"]
-    }
-  ]
-}
-```
-Use `$CODE_GUIDE` for a wider HTML-oriented order: `class`, `id`, `name`, `data-*`, `src`, `for`, `type`, `href`,
-`value`, `title`, `alt`, `role`, `aria-*`.
-```json
-{
-  "@taiga-ui/experience-next/host-attributes-sort": [
-    "error",
-    {
-      "attributeGroups": ["$ID", "$DEFAULT", "$ARIA", "$ANGULAR_OUTPUT"]
-    }
-  ]
-}
-```
-Use atomic presets when you want a custom order instead of one of the bundled aliases.
-| Option                | Type                        | Description                                                       |
-| --------------------- | --------------------------- | ----------------------------------------------------------------- |
-| `attributeGroups`     | `string[]`                  | Group order. Supports the same preset tokens as Prettier plugins. |
-| `attributeIgnoreCase` | `boolean`                   | Ignore case when matching custom regexp groups.                   |
-| `attributeSort`       | `'ASC' \| 'DESC' \| 'NONE'` | Sort order inside each matched group.                             |
-| `decorators`          | `string[]`                  | Decorator names whose `host` metadata should be checked.          |
----
-## injection-token-description
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-The description passed to `new InjectionToken(...)` must contain the name of the variable it is assigned to. The rule
-accepts both direct string descriptions and Angular's `ngDevMode ? '...' : ''` pattern, and the autofix rewrites invalid
-descriptions to the dev-only form. If `ngDevMode` is not declared in the file, the autofix inserts
-`declare const ngDevMode: boolean;` after imports.
-```ts
-// ❌ error
-import {InjectionToken} from '@angular/core';
-export const TUI_MY_TOKEN = new InjectionToken<string>('some description');
-// ✅ after autofix
-import {InjectionToken} from '@angular/core';
-declare const ngDevMode: boolean;
-export const TUI_MY_TOKEN = new InjectionToken<string>(ngDevMode ? '[TUI_MY_TOKEN]: some description' : '');
-```
----
-## no-commonjs-import-patterns
-<sup>`✅ Recommended`</sup>
-Disallows legacy CommonJS interop import patterns that are brittle under modern ESM-oriented toolchains. It reports
-`import foo = require('foo')` and namespace imports that are used as callable values, constructors, or tag functions.
-```ts
-// ❌ error
-import toolkit = require('@taiga-ui/cdk');
-import * as createClient from 'legacy-client';
-createClient();
-// ✅ ok
-import toolkit from '@taiga-ui/cdk';
-import createClient from 'legacy-client';
-createClient();
-```
----
-## no-deep-imports
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Disallows deep path imports from Taiga UI packages — imports must go through the package root. Works for any
-`@taiga-ui/*` package by default. Autofix strips the deep path.
-```ts
-// ❌ error
-import {TuiButton} from '@taiga-ui/core/components/button';
-// ✅ after autofix
-import {TuiButton} from '@taiga-ui/core';
-```
-```json
-{
-  "@taiga-ui/experience-next/no-deep-imports": [
-    "error",
-    {
-      "currentProject": "(?<=projects/)([\\w-]+)",
-      "ignoreImports": ["\\?raw", "@taiga-ui/testing/cypress"]
-    }
-  ]
-}
-```
-| Option              | Type       | Description                                                                |
-| ------------------- | ---------- | -------------------------------------------------------------------------- |
-| `currentProject`    | `string`   | RegExp to extract the current project name from the file path              |
-| `deepImport`        | `string`   | RegExp to detect the deep import segment (default: `@taiga-ui/` sub-paths) |
-| `importDeclaration` | `string`   | RegExp to match import declarations the rule applies to                    |
-| `ignoreImports`     | `string[]` | RegExp patterns for imports to ignore                                      |
-| `projectName`       | `string`   | RegExp to extract the package name from the import source                  |
----
-## no-deep-imports-to-indexed-packages
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Disallows deep imports from any external package whose root `index.ts` (or `index.d.ts`) re-exports the same subpath and
-is co-located with a `package.json` or `ng-package.json`. Does not require explicit package lists — resolves via
-TypeScript.
-```ts
-// ❌ error — @my-lib/index.ts already re-exports this subpath
-import {Foo} from '@my-lib/internal/foo';
-// ✅
-import {Foo} from '@my-lib/internal';
-```
----
-## no-duplicate-attrs
-Disallows repeated attributes on the same element. The rule works on Angular template AST and catches duplicate plain
-HTML attributes before they become ambiguous or silently override one another.
-```html
-<!-- ❌ error -->
-<div
-  class="a"
-  class="b"
-></div>
-<!-- ✅ ok -->
-<div
-  class="a"
-  id="b"
-></div>
-```
----
-## no-duplicate-id
-Disallows duplicate static `id` values within the same HTML template. This helps keep selectors, label associations, and
-accessibility relationships deterministic.
-```html
-<!-- ❌ error -->
-<label for="name"></label>
-<input id="name" />
-<div id="name"></div>
-<!-- ✅ ok -->
-<label for="name"></label>
-<input id="name" />
-<div id="description"></div>
-```
----
-## no-duplicate-in-head
-Disallows duplicate singleton tags inside `<head>`, including `<title>`, `<base>`, `meta[charset]`,
-`meta[name="viewport"]`, and `link[rel="canonical"]`. Multiple copies of these tags make document metadata unreliable.
-```html
-<!-- ❌ error -->
-<head>
-  <title>One</title>
-  <title>Two</title>
-</head>
-<!-- ✅ ok -->
-<head>
-  <title>One</title>
-</head>
-```
----
-## no-fully-untracked-effect
-<sup>`✅ Recommended`</sup>
-Reports a reactive callback whose signal reads are all wrapped in `untracked()`. That leaves the callback without
-tracked dependencies, so Angular will not re-run it when those signals change.
-Applies to `effect()`, `computed()`, `linkedSignal()`, `resource()` callbacks, and `afterRenderEffect()` phases.
-```ts
-// ❌ error — no tracked reads, effect never re-runs
-effect(() => {
-  const value = untracked(() => this.count());
-  this.log(value);
-});
-// ✅ ok — count() is read outside untracked, creates a reactive dependency
-effect(() => {
-  const value = this.count();
-  untracked(() => this.log(value));
-});
-```
-```ts
-// ❌ error — computed() also loses its dependency
-const doubled = computed(() => untracked(() => this.count() * 2));
-// ✅ ok
-const doubled = computed(() => this.count() * 2);
-```
----
-## no-href-with-router-link
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-> ✅ Included in `recommended` — processed by the angular-eslint template parser (`**/*.html`).
-Disallows using both `href` and `routerLink` on the same `<a>` element in Angular templates. Autofix removes the `href`
-attribute.
-```html
-<!-- ❌ error -->
-<a
-  href="/home"
-  routerLink="/home"
->
-  Home
-</a>
-<!-- ✅ after autofix -->
-<a routerLink="/home">Home</a>
-```
----
-## no-import-assertions
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Disallows legacy `assert { ... }` import assertions and rewrites them to `with { ... }` import attributes.
-```ts
-// ❌ error
-import data from './file.json' assert {type: 'json'};
-// ✅ after autofix
-import data from './file.json' with {type: 'json'};
-```
----
-## no-implicit-public
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Requires an explicit `public` modifier on all class members and constructor parameter properties that are public.
-Constructors are excluded.
-```ts
-// ❌ error
-class MyService {
-  value = 42;
-  doSomething(): void {}
-}
-// ✅ after autofix
-class MyService {
-  public value = 42;
-  public doSomething(): void {}
-}
-```
----
-## no-infinite-loop
-<sup>`✅ Recommended`</sup>
-Disallows the two loop forms banned by this project: `while (true)` and `for` loops without a condition, including the
-canonical `for (;;)` form. These loops hide the real exit condition inside the body, which makes control flow harder to
-scan and review.
-```ts
-// ❌ error
-while (true) {
-  if (isDone) {
-    break;
-  }
-  process();
-}
-// ✅ ok
-while (!isDone) {
-  process();
-}
-```
-```ts
-// ❌ error
-for (;;) {
-  if (queue.length === 0) {
-    break;
-  }
-  flush(queue.shift());
-}
-// ✅ ok
-for (; queue.length > 0; ) {
-  flush(queue.shift());
-}
-```
----
-## no-legacy-peer-deps
-<sup>`✅ Recommended`</sup>
-> ✅ Included in `recommended` — applied to `**/.npmrc`.
-Disallows `legacy-peer-deps=true` in `.npmrc`. This npm option bypasses peer dependency resolution and can hide real
-version conflicts in the dependency graph. The preferred fix is to align incompatible package versions instead of
-disabling the resolver.
-```ini
-# ❌ error
-legacy-peer-deps=true
-# ✅ ok
-strict-peer-deps=true
-```
-Comments and empty lines are ignored, so the rule only reports an active `legacy-peer-deps=true` entry.
----
-## no-obsolete-attrs
-Disallows obsolete HTML attributes such as presentational or deprecated legacy attributes that should be replaced with
-modern HTML or CSS.
-```html
-<!-- ❌ error -->
-<table border="1"></table>
-<!-- ✅ ok -->
-<table class="with-border"></table>
-```
----
-## no-obsolete-tags
-Disallows obsolete HTML tags that should no longer appear in modern markup. This keeps templates aligned with current
-HTML standards and avoids legacy presentational elements.
-```html
-<!-- ❌ error -->
-<center>Title</center>
-<!-- ✅ ok -->
-<div class="centered">Title</div>
-```
----
-## no-playwright-empty-fill
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-In Playwright tests, calling `.fill('')` on a locator should be replaced with `.clear()` — it is the idiomatic way to
-empty a field and communicates intent more clearly.
-```ts
-// ❌ error
-await page.getByLabel('Name').fill('');
-// ✅ after autofix
-await page.getByLabel('Name').clear();
-```
----
-## no-project-as-in-ng-template
-<sup>`✅ Recommended`</sup>
-`ngProjectAs` has no effect when the element is inside an `<ng-template>`, `*ngTemplateOutlet`, `*ngComponentOutlet`, or
-`*polymorpheusOutlet`. Content instantiated through these dynamic outlets does not participate in Angular's static
-content projection, so the attribute is silently ignored at runtime.
-```html
-<!-- ❌ error — inside <ng-template> -->
-<ng-template #tpl>
-  <div ngProjectAs="[someSlot]">content</div>
-</ng-template>
-<!-- ❌ error — on the outlet host itself -->
-<ng-container
-  *ngTemplateOutlet="tpl"
-  ngProjectAs="[someSlot]"
-></ng-container>
-<!-- ❌ error — polymorpheusOutlet -->
-<ng-container
-  *polymorpheusOutlet="content"
-  ngProjectAs="someSlot"
-></ng-container>
-<!-- ✅ ok — static content projection -->
-<div ngProjectAs="[someSlot]">content</div>
-```
----
-## no-restricted-attr-values
-<sup>`Taiga-specific`</sup>
-Disallows configured string values for Angular template attributes, including both plain HTML attributes and literal
-string bindings like `[icon]="'@tui.x'"`. This is useful when a project wants to ban hardcoded design-system tokens in
-markup and require them to come from component inputs or options objects instead.
-```json
-{
-  "@taiga-ui/experience-next/no-restricted-attr-values": [
-    "error",
-    {
-      "attrPatterns": ["iconStart", "iconEnd", "icon"],
-      "attrValuePatterns": ["@tui"],
-      "message": "Icons must be configured"
-    }
-  ]
-}
-```
-```html
-<!-- ❌ error -->
-<button iconStart="@tui.x"></button>
-<tui-icon [icon]="'@tui.chevron-down'"></tui-icon>
-<!-- ✅ ok -->
-<button [iconStart]="options.iconStart"></button>
-<tui-icon [icon]="options.icon"></tui-icon>
-```
----
-## no-string-literal-concat
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Disallows concatenating string literals with `+`. Adjacent string literals are always mergeable into one — splitting
-them with `+` adds noise without benefit, and multi-line splits are especially easy to miss.
-Replaces the built-in `no-useless-concat` rule, which only catches same-line concatenation.
-```ts
-// ❌ error
-const msg = 'Hello, ' + 'world!';
-// ✅ after autofix
-const msg = 'Hello, world!';
-```
-```ts
-// ❌ error — also caught across lines
-it(
-    'returns the last day of month when' +
-        ' the result month has fewer days',
-    () => { ... },
-);
-// ✅ after autofix
-it('returns the last day of month when the result month has fewer days', () => {
-    ...
-});
-```
-```ts
-// ❌ error — string variables concatenated with +
-const a = 'hello';
-const b = 'world';
-const c = a + b;
-// ✅ after autofix
-const c = `${a}${b}`;
-```
-When the concatenation is a **direct expression inside a template literal**, the parts are inlined into the outer
-template instead of producing a nested template literal:
-```ts
-// ❌ error
-const url = `${base}${path + query}`;
-// ✅ after autofix — inlined, no nesting
-const url = `${base}${path}${query}`;
-```
-```ts
-// ❌ error — literal concat inside template
-const mask = `${'HH' + ':MM'}`;
-// ✅ after autofix
-const mask = `HH:MM`;
-```
-When the concatenation appears **inside a method call or other expression** within a template literal, the rule skips it
-to avoid creating unreadable nested template literals like `` `${`${a}${b}`.method()}` ``.
-The rule also **flattens already-nested template literals** produced by earlier autofixes or written by hand:
-```ts
-// ❌ error
-const s = `${`${dateMode}${dateTimeSeparator}`}HH:MM`;
-// ✅ after autofix
-const s = `${dateMode}${dateTimeSeparator}HH:MM`;
-```
-Concatenation that uses **inline comments between parts** is intentionally left untouched, as the comments serve as
-documentation:
-```ts
-// ✅ not flagged — comments are preserved
-const urlRegex =
-  String.raw`^([a-zA-Z]+:\/\/)?` + // protocol
-  String.raw`([\w-]+\.)+[\w]{2,}` + // domain
-  String.raw`(\/\S*)?$`; // path
-```
-> For mixed concatenation (`'prefix' + variable`) use the standard `prefer-template` rule, which is already enabled in
-> `recommended`. Template literals (`` `foo` + `bar` ``) and tagged templates are not flagged by this rule.
----
-## no-useless-untracked
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Inside a reactive callback, `untracked()` is only meaningful when its inner function reads signals or intentionally
-wraps opaque external code that may read signals. It can also be a valid escape hatch when a reactive callback needs to
-create another reactive owner such as `effect()` without inheriting the ambient reactive context. Wrapping code with no
-signal reads and no such escape-hatch purpose in `untracked()` is noise. Autofix unwraps the callback in-place when that
-is structurally safe and removes the `untracked` import when it is no longer used elsewhere. Snapshot reads that later
-influence branching are still valid and are not reported, because Angular allows incidental reads inside `effect()` and
-similar reactive callbacks.
-```ts
-// ❌ error — no signal reads inside untracked, wrapper is pointless
-effect(() => {
-  untracked(() => {
-    this.count.set(0);
-  });
-});
-// ✅ after autofix
-effect(() => {
-  this.count.set(0);
-});
-```
-```ts
-// ✅ ok — snapshot reads may influence control flow without becoming dependencies
-effect(() => {
-  const value = untracked(() => this.value());
-  if (this.showAdjacent() && value !== null) {
-    this.month.set(value);
-  }
-});
-```
-```ts
-// ✅ ok — linkedSignal fallback may intentionally read a snapshot
-const activeYear = linkedSignal(() => {
-  const year = this.year();
-  if (year) {
-    return year;
-  }
-  const value = untracked(() => this.value());
-  return value ?? TODAY;
-});
-```
-```ts
-// ✅ ok — wrapping external code is a valid Angular use-case
-effect(() => {
-  const user = this.user();
-  untracked(() => this.logger.log(user));
-});
-```
-```ts
-// ✅ ok — creating a nested effect() may need to escape the current reactive context
-const doubled = computed(() => {
-  untracked(() => {
-    effect(() => {
-      console.log(this.count());
-    });
-  });
-  return this.count() * 2;
-});
-```
----
-## no-side-effects-in-computed
-<sup>`✅ Recommended`</sup>
-`computed()` should only derive a value from its inputs. This rule reports observable side effects inside Angular
-`computed()` callbacks, including signal writes (`.set()`, `.update()`, `.mutate()`), `effect()`, `inject()`,
-assignments to captured state, `++/--`, `delete`, property mutations on objects that were not created inside the
-computation itself, and calls to local helper functions or methods when their bodies perform those operations.
-```ts
-// ❌ error
-import {computed, signal} from '@angular/core';
-const source = signal(0);
-const target = signal(0);
-function syncTarget(): void {
-  target.set(source() + 1);
-}
-const derived = computed(() => {
-  syncTarget();
-  return target();
-});
-```
-```ts
-// ✅ ok
-import {computed, signal} from '@angular/core';
-const source = signal(0);
-const derived = computed(() => source() + 1);
-```
----
-## no-signal-reads-after-await-in-reactive-context
-<sup>`✅ Recommended`</sup>
-Angular tracks signal reads only in synchronous code. If a reactive callback crosses an async boundary, any bare signal
-read after `await` will not become a dependency. Snapshot before `await` when you need the earlier value, or make an
-intentional post-`await` current-value read explicit with `untracked(...)`.
-```ts
-// ❌ error
-effect(async () => {
-  await this.fetchUser();
-  console.log(this.theme());
-});
-// ✅ ok
-effect(async () => {
-  const theme = this.theme();
-  await this.fetchUser();
-  console.log(theme);
-});
-```
-```ts
-// ✅ ok — explicit current-value read after await
-effect(async () => {
-  await this.fetchUser();
-  console.log(untracked(this.theme));
-});
-```
----
-## no-untracked-outside-reactive-context
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-`untracked()` usually only affects signal reads that happen inside the synchronous body of a reactive callback. In
-ordinary non-reactive code or nested callbacks it usually does not prevent dependency tracking and only adds noise. This
-rule reports those cases, but intentionally allows a few explicit escape hatches: post-`await` reads inside a reactive
-callback when `untracked()` is used to document an intentional current-value snapshot, imperative Angular hooks such as
-`@Pipe().transform`, `ControlValueAccessor.writeValue`, `registerOnChange` including patched accessors such as
-`accessor.writeValue = (...) => {}`, callback-form wrappers used inside deferred scheduler / event-handler callbacks,
-and narrow lazy DI factory wrappers like `InjectionToken({factory})` / `useFactory` when they guard creation of a
-reactive owner such as `effect()` against an accidental ambient reactive context. For the narrow case
-`untracked(() => effect(...))` and similar outer wrappers around a reactive call in ordinary code, autofix removes only
-the useless outer `untracked()` wrapper.
-```ts
-// ❌ error
-const snapshot = untracked(this.user);
-effect(() => {
-  button.addEventListener('click', () => {
-    console.log(untracked(this.user));
-  });
-});
-```
-```ts
-// ✅ ok
-effect(() => {
-  console.log(untracked(this.user));
-});
-const snapshot = computed(() => untracked(this.user));
-```
-```ts
-// ✅ ok — after await, untracked can mark an intentional current snapshot
-effect(async () => {
-  await this.refresh();
-  if (untracked(this.user) !== previousUser) {
-    console.log('changed');
-  }
-});
-```
-```ts
-// ❌ error
-untracked(() => {
-  effect(() => {
-    console.log(this.user());
-  });
-});
-// ✅ after autofix
-effect(() => {
-  console.log(this.user());
-});
-```
-```ts
-// ✅ ok — imperative Angular hooks may still need untracked
-@Pipe({name: 'demo', pure: false})
-export class DemoPipe implements PipeTransform {
-  private readonly value = signal('');
-  transform(next: string): string {
-    untracked(() => this.value.set(next));
-    return this.value();
-  }
-}
-```
-```ts
-// ✅ ok — deferred callback wrappers may execute under reactive control later
-const update = (): void => untracked(() => value.set(input.value));
-input.addEventListener('input', update, {capture: true});
-```
-```ts
-// ✅ ok — lazy DI factories may first execute from an ambient reactive context
-export const TOKEN = new InjectionToken<void>('TOKEN', {
-  factory: () => {
-    untracked(() => {
-      effect(() => {
-        console.log(count());
-      });
-    });
-  },
-});
-```
----
-## object-single-line
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Single-property object literals that fit within `printWidth` characters on one line are collapsed to a single line.
-Compatible with Prettier formatting.
-```ts
-// ❌ error
-const x = {
-  foo: bar,
-};
-// ✅ after autofix
-const x = {foo: bar};
-```
-```json
-{
-  "@taiga-ui/experience-next/object-single-line": ["error", {"printWidth": 90}]
-}
-```
-| Option       | Type     | Default | Description                           |
-| ------------ | -------- | ------- | ------------------------------------- |
-| `printWidth` | `number` | `90`    | Maximum line length to allow inlining |
----
-## prefer-combined-if-control-flow
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Combine consecutive `if` statements when they have no `else` branch and use the same `return`, `break`, `continue`, or
-`throw` statement. The autofix merges their conditions with `||`, while intentionally skipping cases with intervening
-code or comments that should remain a separate control-flow boundary.
-```ts
-// ❌ error
-while (true) {
-  if (a) continue;
-  if (b && c) continue;
-}
-// ✅ after autofix
-while (true) {
-  if (a || (b && c)) continue;
-}
-```
-```ts
-// ❌ error
-if (a || b) {
-  return;
-}
-if (c) {
-  return;
-}
-// ✅ after autofix
-if (a || b || c) {
-  return;
-}
-```
-```ts
-// ❌ error
-if (isInvalid) return result;
-if (isLegacy && shouldStop) return result;
-// ✅ after autofix
-if (isInvalid || (isLegacy && shouldStop)) return result;
-```
-```ts
-// ❌ error
-while (true) {
-  if (isDone) break;
-  if (hasError) break;
-}
-// ✅ after autofix
-while (true) {
-  if (isDone || hasError) break;
-}
-```
-```ts
-// ❌ error
-if (isFatal) throw error;
-if (isExpired && shouldAbort) throw error;
-// ✅ after autofix
-if (isFatal || (isExpired && shouldAbort)) throw error;
-```
-```ts
-// not changed — different control flow
-while (true) {
-  if (isDone) continue;
-  if (hasError) break;
-}
-```
-```ts
-// not changed — comment keeps branches separate
-if (a) {
-  return value;
-}
-// explain why this branch exists
-if (b) {
-  return value;
-}
-```
----
-## prefer-deep-imports
-<sup>`Taiga-specific`</sup> <sup>`Fixable`</sup>
-Enforce imports from the deepest available entry point of Taiga UI packages.
-```json
-{
-  "@taiga-ui/experience-next/prefer-deep-imports": [
-    "error",
-    {
-      "importFilter": ["@taiga-ui/core", "@taiga-ui/kit"],
-      "strict": true
-    }
-  ]
-}
-```
-Use `strict` to forbid imports from intermediate entry points when deeper ones exist (recommended for CI).
----
-## prefer-multi-arg-push
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Combine consecutive `.push()` calls on the same array into a single multi-argument call.
-```ts
-// ❌ error
-output.push('# Getting Started');
-output.push('');
-// ✅ after autofix
-output.push('# Getting Started', '');
-```
----
-## prefer-namespace-keyword
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Prefers `namespace Foo {}` over the older `module Foo {}` syntax for TypeScript namespace declarations. External module
-augmentations such as `declare module 'pkg' {}` are ignored.
-```ts
-// ❌ error
-module Foo.Bar {
-  export type Value = string;
-}
-// ✅ after autofix
-namespace Foo.Bar {
-  export type Value = string;
-}
-```
----
-## prefer-untracked-incidental-signal-reads
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Inside a reactive callback, flags direct signal reads that look like snapshot-only values passed into writable-signal
-writes such as `.set()` or into DOM side-effect calls such as `requestFullscreen(...)`. These reads are likely
-incidental and should usually not create their own dependency. The rule only reports when the callback already has
-another tracked dependency outside the flagged consumer call, and autofix wraps the incidental read with `untracked()`
-while adding the import if needed. If the read is intentionally reactive, disable the rule for that line.
-```ts
-// ❌ error
-effect(() => {
-  if (this.options().length) {
-    this.input.value.set(this.stringified());
-  }
-});
-// ✅ after autofix
-effect(() => {
-  if (this.options().length) {
-    this.input.value.set(untracked(() => this.stringified()));
-  }
-});
-```
-```ts
-// ❌ error
-effect(() => {
-  if (this.options().length) {
-    const value = this.stringified();
-    this.input.value.set(value);
-  }
-});
-// ✅ after autofix
-effect(() => {
-  if (this.options().length) {
-    const value = untracked(() => this.stringified());
-    this.input.value.set(value);
-  }
-});
-```
-```ts
-// ❌ error
-effect(async () => {
-  if (this.tuiFullscreen()) {
-    await this.root()?.requestFullscreen(this.options());
-  }
-});
-// ✅ after autofix
-effect(async () => {
-  if (this.tuiFullscreen()) {
-    await this.root()?.requestFullscreen(untracked(() => this.options()));
-  }
-});
-```
----
-## prefer-untracked-signal-getter
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-When `untracked()` wraps only a single signal getter, prefer passing that getter directly. This keeps the code shorter
-while preserving the same untracked signal read semantics. The rule intentionally skips real TypeScript getters, because
-property access would happen before `untracked()` starts.
-```ts
-// ❌ error
-const snapshot = untracked(() => this.counter());
-// ✅ after autofix
-const snapshot = untracked(this.counter);
-```
----
-## quotes
-<sup>`Fixable`</sup>
-Enforces double quotes around HTML attribute values, including Angular template bindings written in markup. It also adds
-missing quotes when the attribute value is currently unquoted.
-```html
-<!-- ❌ error -->
-<div
-  class="foo"
-  title="bar"
-></div>
-<!-- ✅ after autofix -->
-<div
-  class="foo"
-  title="bar"
-></div>
-```
----
-## require-doctype
-<sup>`Fixable`</sup>
-Requires `<!DOCTYPE html>` at the beginning of HTML documents. Even though Angular's template parser does not expose
-doctype nodes directly, the rule still validates and autofixes the source text.
-```html
-<!-- ❌ error -->
-<html lang="en"></html>
-<!-- ✅ after autofix -->
-<!DOCTYPE html>
-<html lang="en"></html>
-```
----
-## require-img-alt
-Requires an accessible text alternative on `<img>` elements. The rule accepts plain `alt`, `[alt]`, and `[attr.alt]` so
-it works naturally with Angular bindings.
-```html
-<!-- ❌ error -->
-<img src="avatar.png" />
-<!-- ✅ ok -->
-<img
-  src="avatar.png"
-  alt="Profile"
-/>
-<img
-  [src]="avatar"
-  [attr.alt]="description"
-/>
-```
----
-## require-lang
-Requires a non-empty `lang` attribute on the root `<html>` element. Bound Angular forms such as `[attr.lang]` are also
-accepted.
-```html
-<!-- ❌ error -->
-<html>
-  <body></body>
-</html>
-<!-- ✅ ok -->
-<html lang="en">
-  <body></body>
-</html>
-<html [attr.lang]="locale()">
-  <body></body>
-</html>
-```
----
-## require-li-container
-Requires `<li>` elements to appear inside `<ul>`, `<ol>`, or `<menu>`. This prevents structurally invalid list markup in
-Angular templates.
-```html
-<!-- ❌ error -->
-<div><li>Item</li></div>
-<!-- ✅ ok -->
-<ul>
-  <li>Item</li>
-</ul>
-```
----
-## require-title
-Requires a non-empty `<title>` inside `<head>`. Plain text and Angular interpolation are both treated as valid title
-content.
-```html
-<!-- ❌ error -->
-<html lang="en">
-  <head></head>
-  <body></body>
-</html>
-<!-- ✅ ok -->
-<html lang="en">
-  <head>
-    <title>Page</title>
-  </head>
-  <body></body>
-</html>
-<html lang="en">
-  <head>
-    <title>{{ pageTitle }}</title>
-  </head>
-  <body></body>
-</html>
-```
----
-## short-tui-imports
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-In Angular decorator `imports` arrays, replaces full `TuiXxxComponent` / `TuiYyyDirective` names with their shorthand
-aliases (e.g. `TuiButton`). Also updates the corresponding `import` statement.
-```ts
-// ❌ error
-import {TuiButtonDirective} from '@taiga-ui/core';
-@Component({
-    imports: [TuiButtonDirective],
-})
-// ✅ after autofix
-import {TuiButton} from '@taiga-ui/core';
-@Component({
-    imports: [TuiButton],
-})
-```
-```json
-{
-  "@taiga-ui/experience-next/short-tui-imports": [
-    "error",
-    {
-      "decorators": ["Component", "Directive", "NgModule", "Pipe"],
-      "exceptions": [{"from": "TuiTextfieldOptionsDirective", "to": "TuiTextfield"}]
-    }
-  ]
-}
-```
-| Option       | Type                           | Description                                                |
-| ------------ | ------------------------------ | ---------------------------------------------------------- |
-| `decorators` | `string[]`                     | Decorator names to inspect (default: all Angular ones)     |
-| `exceptions` | `{from: string, to: string}[]` | Explicit rename mappings that override the default pattern |
----
-## single-line-class-property-spacing
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Keeps consecutive single-line field-like class members visually grouped, including `abstract` fields. A multiline field
-must be separated from neighboring field-like members with a blank line before it and, when another field follows, a
-blank line after it. `get` and `set` accessors always act as visual boundaries and must be separated from surrounding
-fields by a blank line. This removes noisy empty lines inside simple field groups without flattening longer, wrapped
-initializers or blending fields into accessors.
-```ts
-// ❌ error
-class TuiEditorStarter {
-  protected readonly template = import('./import/template.md?raw');
-  protected readonly component = import('./import/component.md?raw');
-  protected readonly exampleIcons =
-    import('./import/angular-to-long-long-long-long-long-long-long-text-for-prettier.json.md?raw');
-  protected readonly isE2E = inject(TUI_IS_E2E);
-}
-// ✅ after autofix
-class TuiEditorStarter {
-  protected readonly template = import('./import/template.md?raw');
-  protected readonly component = import('./import/component.md?raw');
-  protected readonly exampleIcons =
-    import('./import/angular-to-long-long-long-long-long-long-long-text-for-prettier.json.md?raw');
-  protected readonly isE2E = inject(TUI_IS_E2E);
-}
-```
-```ts
-// ❌ error
-abstract class Example {
-  protected readonly template = import('./template.md?raw');
-  get component() {
-    return this.template;
-  }
-  public abstract markdown: string;
-}
-// ✅ after autofix
-abstract class Example {
-  protected readonly template = import('./template.md?raw');
-  get component() {
-    return this.template;
-  }
-  public abstract markdown: string;
-}
-```
----
-## standalone-imports-sort
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Sorts the `imports` array inside Angular decorators (`@Component`, `@Directive`, `@NgModule`, `@Pipe`) alphabetically.
-Spread elements are placed after named identifiers.
-```ts
-// ❌ error
-@Component({
-    imports: [TuiButton, CommonModule, AsyncPipe],
-})
-// ✅ after autofix
-@Component({
-    imports: [AsyncPipe, CommonModule, TuiButton],
-})
-```
-```json
-{
-  "@taiga-ui/experience-next/standalone-imports-sort": [
-    "error",
-    {"decorators": ["Component", "Directive", "NgModule", "Pipe"]}
-  ]
-}
-```
----
-## no-redundant-type-annotation
-<sup>`✅ Recommended`</sup> <sup>`Fixable`</sup>
-Disallow explicit type annotations on class properties and variable declarations when TypeScript can already infer the
-same type from the initializer. Requires type information (`parserOptions.project`).
-Works well in combination with `unused-imports/no-unused-imports` or `@typescript-eslint/no-unused-vars`, which will
-then clean up any import that is no longer referenced after the annotation is removed.
-```ts
-// ❌ error — type is already inferred from inject()
-private readonly options: TuiInputNumberOptions = inject(TUI_INPUT_NUMBER_OPTIONS);
-// ✅ after autofix
-private readonly options = inject(TUI_INPUT_NUMBER_OPTIONS);
-```
-```ts
-// ❌ error — variable declaration
-const service: MyService = inject(MyService);
-// ✅ after autofix
-const service = inject(MyService);
-```
-The rule does **not** report when the annotation intentionally widens or changes the type:
-```ts
-// ✅ ok — annotation widens Dog to Animal
-x: Animal = new Dog();
-// ✅ ok — annotation adds null to the union
-x: MyService | null = inject(MyService);
-```
-The rule does **not** report when the annotation provides contextual typing that narrows an array literal to a tuple.
-Without the annotation TypeScript would infer `number[]` instead of the required tuple type, widening the type and
-breaking compilation:
-```ts
-type SelectionRange = readonly [from: number, to: number];
-interface ElementState {
-  readonly value: string;
-  readonly selection: SelectionRange;
-}
-// ✅ ok — [0, 0] is inferred as SelectionRange only because of the annotation;
-//         removing it would widen the type to ElementState | {value: string; selection: number[]}
-const state: ElementState = flag ? {value: '', selection: [0, 0]} : existingState;
-```
-```json
-{
-  "@taiga-ui/experience-next/no-redundant-type-annotation": ["error", {"ignoreTupleContextualTyping": true}]
-}
-```
-| Option                        | Type      | Default | Description                                                                                            |
-| ----------------------------- | --------- | ------- | ------------------------------------------------------------------------------------------------------ |
-| `ignoreTupleContextualTyping` | `boolean` | `true`  | Preserve annotations when they provide contextual typing that narrows an array literal to a tuple type |
----
-## strict-tui-doc-example
-<sup>`Taiga-specific`</sup> <sup>`Fixable`</sup>
-Validates that properties of a `TuiDocExample`-typed object have keys matching known file-type names (`TypeScript`,
-`HTML`, `CSS`, `LESS`, `JavaScript`) and that the import path extension matches the key. Autofix corrects the import
-extension.
-```ts
-// ❌ error — key says "TypeScript" but path has .html extension
-readonly example: TuiDocExample = {
-    TypeScript: import('./example/index.html?raw'),
-};
-// ✅ after autofix
-readonly example: TuiDocExample = {
-    TypeScript: import('./example/index.ts?raw'),
-};
-```
+| Rule                                                                                                                                                                                                | Description                                                                                         | ✅  | 🔧  | 💡  |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- | --- | --- | --- |
+| [array-as-const](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/array-as-const.md)                                                                   | Exported array of class references should be marked with `as const`                                 |     | 🔧  |     |
+| [attrs-newline](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/attrs-newline.md)                                                                     | Enforce one attribute per line when a start tag spans multiple lines                                |     | 🔧  |     |
+| [class-property-naming](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/class-property-naming.md)                                                     | Enforce custom naming for class properties based on their type                                      |     | 🔧  |     |
+| [decorator-key-sort](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/decorator-key-sort.md)                                                           | Sorts the keys of the object passed to the `@Component/@Injectable/@NgModule/@Pipe` decorator       | ✅  | 🔧  |     |
+| [element-newline](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/element-newline.md)                                                                 | Require line breaks around block-level child nodes in HTML templates                                |     | 🔧  |     |
+| [flat-exports](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/flat-exports.md)                                                                       | Spread nested arrays when exporting Angular entity collections                                      |     | 🔧  |     |
+| [host-attributes-sort](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/host-attributes-sort.md)                                                       | Sort Angular host metadata attributes using configurable attribute groups                           | ✅  | 🔧  |     |
+| [injection-token-description](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/injection-token-description.md)                                         | Require `InjectionToken` descriptions to include the token name                                     | ✅  | 🔧  |     |
+| [no-commonjs-import-patterns](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-commonjs-import-patterns.md)                                         | Disallow legacy CommonJS interop import patterns                                                    | ✅  |     |     |
+| [no-deep-imports](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-deep-imports.md)                                                                 | Disables deep imports of Taiga UI packages                                                          | ✅  | 🔧  |     |
+| [no-deep-imports-to-indexed-packages](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-deep-imports-to-indexed-packages.md)                         | Disallow deep imports from packages that expose an index.ts next to ng-package.json or package.json | ✅  | 🔧  |     |
+| [no-duplicate-attrs](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-duplicate-attrs.md)                                                           | Disallow duplicate attributes on the same HTML element                                              |     |     |     |
+| [no-duplicate-id](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-duplicate-id.md)                                                                 | Disallow duplicate static `id` values in HTML templates                                             |     |     |     |
+| [no-duplicate-in-head](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-duplicate-in-head.md)                                                       | Disallow duplicate `title`, `base`, and key metadata tags inside `<head>`                           |     |     |     |
+| [no-fully-untracked-effect](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-fully-untracked-effect.md)                                             | Disallow reactive callbacks where all signal reads are hidden inside `untracked()`                  | ✅  |     |     |
+| [no-href-with-router-link](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-href-with-router-link.md)                                               | Do not use href and routerLink attributes together on the same element                              | ✅  | 🔧  |     |
+| [no-import-assertions](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-import-assertions.md)                                                       | Replace legacy `assert { ... }` import assertions with `with { ... }`                               | ✅  | 🔧  |     |
+| [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-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                                               | ✅  | 🔧  |     |
+| [no-project-as-in-ng-template](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-project-as-in-ng-template.md)                                       | `ngProjectAs` has no effect inside `<ng-template>` or dynamic outlets                               | ✅  |     |     |
+| [no-restricted-attr-values](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-restricted-attr-values.md)                                             | Disallow configured attribute values in Angular templates                                           |     |     |     |
+| [no-redundant-type-annotation](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-redundant-type-annotation.md)                                       | Disallow redundant type annotations when the type is already inferred from the initializer          | ✅  | 🔧  |     |
+| [no-side-effects-in-computed](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-side-effects-in-computed.md)                                         | Disallow side effects and effectful helper calls inside Angular `computed()` callbacks              | ✅  |     |     |
+| [no-signal-reads-after-await-in-reactive-context](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-signal-reads-after-await-in-reactive-context.md) | Disallow bare signal reads after `await` inside reactive callbacks                                  | ✅  |     |     |
+| [no-string-literal-concat](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-string-literal-concat.md)                                               | Disallow string literal concatenation; merge adjacent literals into one                             | ✅  | 🔧  |     |
+| [no-untracked-outside-reactive-context](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-untracked-outside-reactive-context.md)                     | Disallow `untracked()` outside reactive callbacks, except explicit post-`await` snapshots           | ✅  | 🔧  |     |
+| [no-useless-untracked](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-useless-untracked.md)                                                       | Disallow provably useless `untracked()` wrappers in reactive callbacks                              | ✅  | 🔧  |     |
+| [object-single-line](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/object-single-line.md)                                                           | Enforce single-line formatting for single-property objects when it fits `printWidth`                | ✅  | 🔧  |     |
+| [prefer-combined-if-control-flow](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-combined-if-control-flow.md)                                 | Combine consecutive `if` statements that use the same `return`, `break`, `continue`, or `throw`     | ✅  | 🔧  |     |
+| [prefer-deep-imports](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-deep-imports.md)                                                         | Allow deep imports of Taiga UI packages                                                             |     | 🔧  |     |
+| [prefer-multi-arg-push](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-multi-arg-push.md)                                                     | Combine consecutive `.push()` calls on the same array into a single multi-argument call             | ✅  | 🔧  |     |
+| [prefer-namespace-keyword](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-namespace-keyword.md)                                               | Replace `module Foo {}` with `namespace Foo {}` for TypeScript namespace declarations               | ✅  | 🔧  |     |
+| [prefer-untracked-incidental-signal-reads](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-untracked-incidental-signal-reads.md)               | Wrap likely-incidental signal reads with `untracked()` in reactive callbacks                        | ✅  | 🔧  |     |
+| [prefer-untracked-signal-getter](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/prefer-untracked-signal-getter.md)                                   | Prefer `untracked(signalGetter)` over `untracked(() => signalGetter())` for a single signal getter  | ✅  | 🔧  |     |
+| [quotes](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/quotes.md)                                                                                   | Enforce double quotes around HTML attribute values                                                  |     | 🔧  |     |
+| [require-doctype](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/require-doctype.md)                                                                 | Require `<!DOCTYPE html>` at the top of HTML documents                                              |     | 🔧  |     |
+| [require-img-alt](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/require-img-alt.md)                                                                 | Require `alt` on `<img>` elements, including Angular attribute bindings                             |     |     |     |
+| [require-lang](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/require-lang.md)                                                                       | Require a non-empty `lang` attribute on `<html>`                                                    |     |     |     |
+| [require-li-container](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/require-li-container.md)                                                       | Require `<li>` to be nested inside `<ul>`, `<ol>`, or `<menu>`                                      |     |     |     |
+| [require-title](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/require-title.md)                                                                     | Require a non-empty `<title>` inside `<head>`                                                       |     |     |     |
+| [short-tui-imports](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/short-tui-imports.md)                                                             | Shorten TuiXxxComponent / TuiYyyDirective in Angular metadata                                       | ✅  | 🔧  |     |
+| [single-line-class-property-spacing](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/single-line-class-property-spacing.md)                           | Group consecutive single-line class properties and separate multiline ones with a blank line        | ✅  | 🔧  |     |
+| [standalone-imports-sort](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/standalone-imports-sort.md)                                                 | Auto sort names inside Angular decorators                                                           | ✅  | 🔧  |     |
+| [strict-tui-doc-example](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/strict-tui-doc-example.md)                                                   | If you use the addon-doc, there will be a hint that you are importing something incorrectly         |     | 🔧  |     |