npm - @taiga-ui/eslint-plugin-experience-next - Versions diffs - 0.507.0 → 0.508.0 - Mend

@taiga-ui/eslint-plugin-experience-next 0.507.0 → 0.508.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 (9) hide show

package/README.md +23 -0
package/index.d.ts +4 -1
package/index.esm.js +327 -183
package/package.json +1 -1
package/rules/recommended/decorator-key-sort.d.ts +2 -2
package/rules/recommended/no-empty-style-metadata.d.ts +5 -0
package/rules/utils/angular/get-decorator-metadata.d.ts +8 -2
package/rules/utils/angular/is-imports-array-property.d.ts +1 -1
package/rules/utils/sorting/get-sorted-names.d.ts +2 -2

package/README.md CHANGED Viewed

@@ -88,6 +88,7 @@ from third-party plugins. The exact severities and file globs live in
 | [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-empty-style-metadata](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-empty-style-metadata.md)                                                 | Remove empty Angular component style metadata                                                       | ✅  | 🔧  |     |
 | [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 { ... }`                               | ✅  | 🔧  |     |
@@ -127,6 +128,28 @@ from third-party plugins. The exact severities and file globs live in
 | [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         |     | 🔧  |     |
+## no-empty-style-metadata
+Disallows empty Angular component style metadata. The rule reports empty string and empty template literal values for
+`styles` and `styleUrl`, plus `styleUrls: []`, because they do not add component styles and can be safely removed.
+```ts
+// ❌ error
+@Component({
+  selector: 'app-root',
+  templateUrl: './app.component.html',
+  styles: ``,
+  styleUrl: '',
+  styleUrls: [],
+})
+// ✅ after autofix
+@Component({
+  selector: 'app-root',
+  templateUrl: './app.component.html',
+})
+```
 ## prefer-conditional-return
 Prefer a single conditional return when an `if` statement returns one expression and the immediately following statement

package/index.d.ts CHANGED Viewed

@@ -18,7 +18,7 @@ declare const plugin: {
         'class-property-naming': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidName", [import("./rules/taiga-specific/class-property-naming").RuleConfig[]], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'decorator-key-sort': import("eslint").Rule.RuleModule & {
+        'decorator-key-sort': import("@typescript-eslint/utils/ts-eslint").RuleModule<"incorrectOrder", [Record<string, readonly string[]>], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         'element-newline': import("eslint").Rule.RuleModule & {
@@ -78,6 +78,9 @@ declare const plugin: {
         'no-duplicate-in-head': import("eslint").Rule.RuleModule & {
             name: string;
         };
+        'no-empty-style-metadata': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noEmptyStyleMetadata", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'no-fully-untracked-effect': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noTrackedReads", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/index.esm.js CHANGED Viewed

@@ -1201,6 +1201,7 @@ var recommended = defineConfig([
                 },
             ],
             '@taiga-ui/experience-next/no-deep-imports-to-indexed-packages': 'error',
+            '@taiga-ui/experience-next/no-empty-style-metadata': 'error',
             '@taiga-ui/experience-next/no-fully-untracked-effect': 'error',
             '@taiga-ui/experience-next/no-implicit-public': 'error',
             '@taiga-ui/experience-next/no-import-assertions': 'error',
@@ -46222,7 +46223,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join('\n');
 }
-const rule$R = createRule({
+const rule$S = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -46308,54 +46309,151 @@ const rule$R = createRule({
     },
 });
+function isObject(node) {
+    return node?.type === dist$2.AST_NODE_TYPES.ObjectExpression;
+}
+/**
+ * Extracts the metadata object from a class decorator such as
+ * `@Component()`, `@Directive()`, `@NgModule()`, or `@Pipe()`.
+ *
+ * Returns the first argument of the decorator call *if and only if*
+ * it is an `ObjectExpression`.
+ *
+ * @example
+ * // Given:
+ * @Component({
+ *   selector: 'x',
+ *   imports: [A, B],
+ * })
+ * class MyCmp {}
+ *
+ * // In the AST for @Component(...)
+ * getDecoratorMetadata(decorator, allowed) returns
+ *    ObjectExpression({ selector: ..., imports: ... })
+ *
+ * @param decorator - The decorator node attached to a class declaration.
+ * @param allowedNames - A set of decorator names to consider
+ *                       (e.g., Component, Directive, NgModule, Pipe).
+ *
+ * @returns The metadata `ObjectExpression` if present and valid,
+ *          otherwise `null`.
+ */
+function getDecoratorMetadata(decorator, allowedNames) {
+    return getDecoratorMetadataWithName(decorator, allowedNames)?.metadata ?? null;
+}
+function getDecoratorMetadataWithName(decorator, allowedNames) {
+    const expr = decorator.expression;
+    if (expr.type !== dist$2.AST_NODE_TYPES.CallExpression) {
+        return null;
+    }
+    const callee = expr.callee;
+    if (callee.type !== dist$2.AST_NODE_TYPES.Identifier || !allowedNames.has(callee.name)) {
+        return null;
+    }
+    const arg = expr.arguments[0];
+    return isObject(arg) ? { expression: expr, metadata: arg, name: callee.name } : null;
+}
+function isStringLiteral(node) {
+    return node?.type === dist$3.AST_NODE_TYPES.Literal && typeof node.value === 'string';
+}
+function isStaticTemplateLiteral(node) {
+    return (node?.type === dist$3.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1);
+}
+function getStaticStringValue(node) {
+    if (isStringLiteral(node)) {
+        return node.value;
+    }
+    return isStaticTemplateLiteral(node)
+        ? (node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? '')
+        : null;
+}
+function isEmptyStaticString(node) {
+    return getStaticStringValue(node) === '';
+}
+function getStaticPropertyName(key) {
+    if (key.type === dist$3.AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    return key.type === dist$3.AST_NODE_TYPES.Literal &&
+        (typeof key.value === 'string' || typeof key.value === 'number')
+        ? String(key.value)
+        : getStaticStringValue(key);
+}
+function getObjectPropertyName(node) {
+    return node.computed ? null : getStaticPropertyName(node.key);
+}
+function getMemberExpressionPropertyName(node) {
+    if (!node.computed && node.property.type === dist$3.AST_NODE_TYPES.Identifier) {
+        return node.property.name;
+    }
+    return node.computed ? getStaticStringValue(node.property) : null;
+}
+function getClassMemberName(member) {
+    return member.key.type === dist$3.AST_NODE_TYPES.PrivateIdentifier
+        ? null
+        : getStaticPropertyName(member.key);
+}
 function sameOrder(a, b) {
     return a.length === b.length && a.every((value, index) => value === b[index]);
 }
-const config$5 = {
-    create(context) {
-        const order = context.options[0] || {};
+const rule$R = createRule({
+    create(context, [order]) {
+        const decorators = new Set(Object.keys(order));
         return {
             ClassDeclaration(node) {
-                const decorators = Array.from(node.decorators ?? []);
-                for (const decorator of decorators) {
-                    const { expression } = decorator;
-                    const decoratorName = expression.callee?.name ?? '';
-                    if (decoratorName in (order || {})) {
-                        const orderList = order[decoratorName];
-                        const decoratorArguments = Array.from(expression.arguments ?? []);
-                        for (const argument of decoratorArguments) {
-                            const properties = Array.from(argument.properties ?? []);
-                            const current = properties
-                                .map((prop) => prop.key?.name)
-                                .filter(Boolean);
-                            const correct = getCorrectOrderRelative(orderList, current);
-                            if (!sameOrder(correct, current.filter((item) => correct.includes(item)))) {
-                                context.report({
-                                    fix: (fixer) => {
-                                        const fileContent = context.sourceCode.text;
-                                        const forgottenProps = current.filter((key) => !orderList.includes(key));
-                                        const sortedDecoratorProperties = [
-                                            ...correct,
-                                            ...forgottenProps,
-                                        ].map((key) => properties.find((prop) => prop.key.name === key));
-                                        const newDecoratorArgument = `{${sortedDecoratorProperties
-                                            .map(({ range }) => fileContent.slice(...range))
-                                            .toString()}}`;
-                                        return fixer.replaceTextRange(argument.range, newDecoratorArgument);
-                                    },
-                                    message: `Incorrect order keys in @${decoratorName} decorator, please sort by [${correct.join(' -> ')}]`,
-                                    node: expression,
-                                });
-                            }
-                        }
+                for (const decorator of node?.decorators ?? []) {
+                    const metadata = getDecoratorMetadataWithName(decorator, decorators);
+                    if (!metadata) {
+                        continue;
+                    }
+                    const orderList = order[metadata.name] ?? [];
+                    const properties = getDecoratorProperties(metadata.metadata);
+                    if (!properties) {
+                        continue;
+                    }
+                    const current = properties.map(({ name }) => name);
+                    const correct = getCorrectOrderRelative(orderList, current);
+                    const sortableCurrent = current.filter((item) => correct.includes(item));
+                    if (sameOrder(correct, sortableCurrent)) {
+                        continue;
                     }
+                    context.report({
+                        data: {
+                            decorator: metadata.name,
+                            order: correct.join(' -> '),
+                        },
+                        fix: (fixer) => {
+                            const forgottenProps = properties.filter(({ name }) => !orderList.includes(name));
+                            const sortedDecoratorProperties = [
+                                ...correct.flatMap((key) => properties.filter(({ name }) => name === key)),
+                                ...forgottenProps,
+                            ];
+                            const newDecoratorArgument = `{${sortedDecoratorProperties
+                                .map(({ node }) => context.sourceCode.text.slice(...node.range))
+                                .join(',')}}`;
+                            return fixer.replaceTextRange(metadata.metadata.range, newDecoratorArgument);
+                        },
+                        messageId: 'incorrectOrder',
+                        node: metadata.expression,
+                    });
                 }
             },
         };
     },
     meta: {
+        defaultOptions: [{}],
+        docs: { description: 'Sorts keys of Angular decorator metadata.' },
         fixable: 'code',
+        messages: {
+            incorrectOrder: 'Incorrect order keys in @{{decorator}} decorator, please sort by [{{order}}]',
+        },
         schema: [
             {
                 additionalProperties: true,
@@ -46365,14 +46463,25 @@ const config$5 = {
         ],
         type: 'problem',
     },
-};
+    name: 'decorator-key-sort',
+});
 function getCorrectOrderRelative(correct, current) {
     return correct.filter((item) => current.includes(item));
 }
-const rule$Q = createRule({
-    name: 'decorator-key-sort',
-    rule: config$5,
-});
+function getDecoratorProperties(metadata) {
+    const properties = [];
+    for (const property of metadata.properties) {
+        if (property.type !== dist$3.AST_NODE_TYPES.Property) {
+            return null;
+        }
+        const name = getObjectPropertyName(property);
+        if (!name) {
+            return null;
+        }
+        properties.push({ name, node: property });
+    }
+    return properties;
+}
 const INLINE_HTML_ELEMENTS = new Set([
     'a',
@@ -46430,7 +46539,7 @@ function getNodeLabel(node) {
     }
     return node instanceof dist$4.TmplAstBoundText ? 'binding' : 'text';
 }
-const rule$P = createRule({
+const rule$Q = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
@@ -46504,93 +46613,6 @@ const rule$P = createRule({
     },
 });
-function isObject(node) {
-    return node?.type === dist$2.AST_NODE_TYPES.ObjectExpression;
-}
-/**
- * Extracts the metadata object from a class decorator such as
- * `@Component()`, `@Directive()`, `@NgModule()`, or `@Pipe()`.
- *
- * Returns the first argument of the decorator call *if and only if*
- * it is an `ObjectExpression`.
- *
- * @example
- * // Given:
- * @Component({
- *   selector: 'x',
- *   imports: [A, B],
- * })
- * class MyCmp {}
- *
- * // In the AST for @Component(...)
- * getDecoratorMetadata(decorator, allowed) →
- *    ObjectExpression({ selector: ..., imports: ... })
- *
- * @param decorator - The decorator node attached to a class declaration.
- * @param allowedNames - A set of decorator names to consider
- *                       (e.g., Component, Directive, NgModule, Pipe).
- *
- * @returns The metadata `ObjectExpression` if present and valid,
- *          otherwise `null`.
- */
-function getDecoratorMetadata(decorator, allowedNames) {
-    const expr = decorator.expression;
-    if (expr.type !== dist$2.AST_NODE_TYPES.CallExpression) {
-        return null;
-    }
-    const callee = expr.callee;
-    if (callee.type !== dist$2.AST_NODE_TYPES.Identifier || !allowedNames.has(callee.name)) {
-        return null;
-    }
-    const arg = expr.arguments[0];
-    return isObject(arg) ? arg : null;
-}
-function isStringLiteral(node) {
-    return node?.type === dist$3.AST_NODE_TYPES.Literal && typeof node.value === 'string';
-}
-function isStaticTemplateLiteral(node) {
-    return (node?.type === dist$3.AST_NODE_TYPES.TemplateLiteral &&
-        node.expressions.length === 0 &&
-        node.quasis.length === 1);
-}
-function getStaticStringValue(node) {
-    if (isStringLiteral(node)) {
-        return node.value;
-    }
-    return isStaticTemplateLiteral(node)
-        ? (node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? '')
-        : null;
-}
-function isEmptyStaticString(node) {
-    return getStaticStringValue(node) === '';
-}
-function getStaticPropertyName(key) {
-    if (key.type === dist$3.AST_NODE_TYPES.Identifier) {
-        return key.name;
-    }
-    return key.type === dist$3.AST_NODE_TYPES.Literal &&
-        (typeof key.value === 'string' || typeof key.value === 'number')
-        ? String(key.value)
-        : getStaticStringValue(key);
-}
-function getObjectPropertyName(node) {
-    return node.computed ? null : getStaticPropertyName(node.key);
-}
-function getMemberExpressionPropertyName(node) {
-    if (!node.computed && node.property.type === dist$3.AST_NODE_TYPES.Identifier) {
-        return node.property.name;
-    }
-    return node.computed ? getStaticStringValue(node.property) : null;
-}
-function getClassMemberName(member) {
-    return member.key.type === dist$3.AST_NODE_TYPES.PrivateIdentifier
-        ? null
-        : getStaticPropertyName(member.key);
-}
 const DEFAULT_GROUP = '$DEFAULT';
 const DEFAULT_ATTRIBUTE_GROUPS = [
     '$ANGULAR_STRUCTURAL_DIRECTIVE',
@@ -46656,7 +46678,7 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const rule$O = createRule({
+const rule$P = createRule({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -46987,7 +47009,7 @@ const config$4 = {
         type: 'suggestion',
     },
 };
-const rule$N = createRule({
+const rule$O = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
@@ -248226,7 +248248,7 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     }
     return hasSafeRuntimeUsage;
 }
-const rule$M = createRule({
+const rule$N = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
         const checkCycles = context.options[0]?.checkCycles ?? true;
@@ -248944,7 +248966,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$L = createRule({
+const rule$M = createRule({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -248993,7 +249015,7 @@ const rule$L = createRule({
     name: 'injection-token-description',
 });
-const rule$K = createRule({
+const rule$L = createRule({
     create(context) {
         const { sourceCode } = context;
         const namespaceImports = new Map();
@@ -249088,7 +249110,7 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const rule$J = createRule({
+const rule$K = createRule({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -249180,7 +249202,7 @@ const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-const rule$I = createRule({
+const rule$J = createRule({
     create(context) {
         const parserServices = dist$3.ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -249374,13 +249396,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$H = createRule({
+const rule$I = createRule({
     name: 'no-duplicate-attrs',
     rule: noDuplicateAttributesRule,
 });
 const MESSAGE_ID$c = 'duplicateId';
-const rule$G = createRule({
+const rule$H = createRule({
     name: 'no-duplicate-id',
     rule: {
         create(context) {
@@ -249441,7 +249463,7 @@ function getTrackingKey(node) {
         ? 'link[rel=canonical]'
         : null;
 }
-const rule$F = createRule({
+const rule$G = createRule({
     name: 'no-duplicate-in-head',
     rule: {
         create(context) {
@@ -249496,6 +249518,133 @@ const rule$F = createRule({
     },
 });
+const COMPONENT_DECORATORS = new Set(['Component']);
+const rule$F = createRule({
+    create(context) {
+        const { sourceCode } = context;
+        return {
+            ClassDeclaration(node) {
+                for (const decorator of node?.decorators ?? []) {
+                    const metadata = getDecoratorMetadata(decorator, COMPONENT_DECORATORS);
+                    if (!metadata) {
+                        continue;
+                    }
+                    const emptyProperties = metadata.properties.filter((property) => property.type === dist$3.AST_NODE_TYPES.Property &&
+                        isEmptyStyleMetadata(getObjectPropertyName(property), property, sourceCode));
+                    if (emptyProperties.length === 0) {
+                        continue;
+                    }
+                    const [firstEmptyProperty] = emptyProperties;
+                    if (!firstEmptyProperty) {
+                        continue;
+                    }
+                    context.report({
+                        fix: (fixer) => {
+                            const ranges = emptyProperties.map((property) => getPropertyRemovalRange(sourceCode, property));
+                            return ranges.some((range) => hasCommentsInRange(sourceCode, range))
+                                ? null
+                                : fixer.replaceTextRange(metadata.range, removeRanges(sourceCode.text.slice(...metadata.range), ranges.map(([start, end]) => [
+                                    start - metadata.range[0],
+                                    end - metadata.range[0],
+                                ])));
+                        },
+                        messageId: 'noEmptyStyleMetadata',
+                        node: firstEmptyProperty,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow empty `styles`, `styleUrl`, and `styleUrls` metadata in Angular components.',
+        },
+        fixable: 'code',
+        messages: {
+            noEmptyStyleMetadata: 'Empty style metadata should be removed from @Component decorator.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-empty-style-metadata',
+});
+function isEmptyStyleMetadata(name, property, sourceCode) {
+    return (((name === 'styles' || name === 'styleUrl') &&
+        isEmptyStringExpression(property.value)) ||
+        (name === 'styleUrls' &&
+            property.value.type === dist$3.AST_NODE_TYPES.ArrayExpression &&
+            property.value.elements.length === 0 &&
+            sourceCode.getText(property.value).replaceAll(/\s/g, '') === '[]'));
+}
+function isEmptyStringExpression(node) {
+    if (node.type === dist$3.AST_NODE_TYPES.Literal) {
+        return node.value === '';
+    }
+    if (node.type !== dist$3.AST_NODE_TYPES.TemplateLiteral || node.expressions.length > 0) {
+        return false;
+    }
+    const [quasi] = node.quasis;
+    return quasi?.value.raw === '';
+}
+function getPropertyRemovalRange(sourceCode, property) {
+    const nextToken = sourceCode.getTokenAfter(property);
+    if (nextToken?.value === ',') {
+        return getRangeWithFollowingComma(sourceCode.text, property, nextToken.range);
+    }
+    const previousToken = sourceCode.getTokenBefore(property);
+    return previousToken?.value === ','
+        ? [previousToken.range[0], property.range[1]]
+        : getSinglePropertyRange(sourceCode.text, property);
+}
+function getRangeWithFollowingComma(text, property, commaRange) {
+    const lineStart = getLineStart(text, property.range[0]);
+    const nextLineStart = getNextLineStart(text, commaRange[1]);
+    return text.slice(lineStart, property.range[0]).trim() === '' &&
+        text.slice(commaRange[1], nextLineStart).trim() === '' &&
+        nextLineStart > commaRange[1]
+        ? [lineStart, nextLineStart]
+        : [property.range[0], commaRange[1]];
+}
+function getSinglePropertyRange(text, property) {
+    const lineStart = getLineStart(text, property.range[0]);
+    const nextLineStart = getNextLineStart(text, property.range[1]);
+    return text.slice(lineStart, property.range[0]).trim() === '' &&
+        text.slice(property.range[1], nextLineStart).trim() === '' &&
+        nextLineStart > property.range[1]
+        ? [lineStart, nextLineStart]
+        : [property.range[0], property.range[1]];
+}
+function getLineStart(text, index) {
+    return text.lastIndexOf('\n', index - 1) + 1;
+}
+function getNextLineStart(text, index) {
+    const lineEnd = text.indexOf('\n', index);
+    return lineEnd === -1 ? index : lineEnd + 1;
+}
+function hasCommentsInRange(sourceCode, [start, end]) {
+    return sourceCode
+        .getAllComments()
+        .some((comment) => comment.range[0] >= start && comment.range[1] <= end);
+}
+function removeRanges(text, ranges) {
+    return mergeRanges(ranges)
+        .sort((left, right) => right[0] - left[0])
+        .reduce((result, [start, end]) => `${result.slice(0, start)}${result.slice(end)}`, text);
+}
+function mergeRanges(ranges) {
+    const sorted = [...ranges].sort((left, right) => left[0] - right[0]);
+    const merged = [];
+    for (const range of sorted) {
+        const last = merged[merged.length - 1];
+        if (!last || range[0] > last[1]) {
+            merged.push([...range]);
+            continue;
+        }
+        last[1] = Math.max(last[1], range[1]);
+    }
+    return merged;
+}
 function isFunctionLike(node) {
     return (node.type === dist$3.AST_NODE_TYPES.ArrowFunctionExpression ||
         node.type === dist$3.AST_NODE_TYPES.FunctionDeclaration ||
@@ -253819,10 +253968,17 @@ function isArray(node) {
 }
 function isImportsArrayProperty(property) {
-    const isProperty = property?.type === dist$3.AST_NODE_TYPES.Property;
-    const hasIdentifierKey = property?.key.type === dist$3.AST_NODE_TYPES.Identifier &&
+    if (property?.type !== dist$3.AST_NODE_TYPES.Property) {
+        return false;
+    }
+    const hasIdentifierKey = property.key.type === dist$3.AST_NODE_TYPES.Identifier &&
         property.key.name === 'imports';
-    return isProperty && hasIdentifierKey && isArray(property.value);
+    return hasIdentifierKey && isArray(property.value);
+}
+function getImportsArray(meta) {
+    const property = meta.properties.find(isImportsArrayProperty);
+    return property?.value ?? null;
 }
 function getImportedName$1(spec) {
@@ -253843,28 +253999,19 @@ const DEFAULT_EXCEPTIONS = [
 const rule$9 = createRule({
     create(context, [{ decorators = DEFAULT_DECORATORS, exceptions = DEFAULT_EXCEPTIONS }]) {
         const sourceCode = context.getSourceCode();
+        const allowedDecorators = new Set(decorators);
         const importedFromTaiga = {};
-        const decoratorSelector = `Decorator[expression.callee.name=/^(${decorators.join('|')})$/]`;
         return {
-            [decoratorSelector](decorator) {
-                const expression = decorator.expression;
-                const isInvalidExpression = expression.type !== dist$3.AST_NODE_TYPES.CallExpression ||
-                    expression.arguments.length === 0;
-                if (isInvalidExpression) {
-                    return;
-                }
-                const [arg] = expression.arguments;
-                const isNotObject = arg?.type !== dist$3.AST_NODE_TYPES.ObjectExpression;
-                if (isNotObject) {
+            Decorator(decorator) {
+                const metadata = getDecoratorMetadata(decorator, allowedDecorators);
+                if (!metadata) {
                     return;
                 }
-                const importsProperty = arg.properties
-                    .filter((literal) => literal.type === dist$3.AST_NODE_TYPES.Property)
-                    .find((literal) => isImportsArrayProperty(literal));
-                if (!importsProperty) {
+                const importsArray = getImportsArray(metadata);
+                if (!importsArray) {
                     return;
                 }
-                const imports = importsProperty.value.elements.filter((el) => {
+                const imports = importsArray.elements.filter((el) => {
                     const isIdentifier = el?.type === dist$3.AST_NODE_TYPES.Identifier;
                     return Boolean(el && isIdentifier);
                 });
@@ -254275,14 +254422,6 @@ const rule$7 = createRule({
     name: 'single-line-variable-spacing',
 });
-function getImportsArray(meta) {
-    const property = meta.properties.find((literal) => literal.type === dist$2.AST_NODE_TYPES.Property &&
-        literal.key.type === dist$2.AST_NODE_TYPES.Identifier &&
-        literal.key.name === 'imports' &&
-        isArray(literal.value));
-    return property ? property.value : null;
-}
 function isSpread(node) {
     return node.type === dist$2.AST_NODE_TYPES.SpreadElement;
 }
@@ -254322,11 +254461,12 @@ function nameOf(node, source) {
     return source.getText(node);
 }
+const IMPORT_NAME_COLLATOR = new Intl.Collator('en', { numeric: true });
 /**
- * Sorts Angular standalone import elements into a deterministic, alphabetical order.
+ * Sorts Angular standalone import elements into a deterministic, natural order.
  *
  * The sorting rules:
- * 1. Regular elements (Identifiers, MemberExpressions, etc.) are sorted alphabetically.
+ * 1. Regular elements (Identifiers, MemberExpressions, etc.) are sorted naturally.
  * 2. Spread elements (e.g. `...A`) are sorted separately and placed after regular ones.
  * 3. Sorting is based on the string value returned by `nameOf()`.
  *
@@ -254345,10 +254485,13 @@ function nameOf(node, source) {
 function getSortedNames(elements, source) {
     const regular = elements.filter((e) => !isSpread(e));
     const spreads = elements.filter((e) => isSpread(e));
-    const sortedRegular = [...regular].sort((a, b) => nameOf(a, source).localeCompare(nameOf(b, source)));
-    const sortedSpreads = [...spreads].sort((a, b) => nameOf(a.argument, source).localeCompare(nameOf(b.argument, source)));
+    const sortedRegular = [...regular].sort((a, b) => compareImportNames(nameOf(a, source), nameOf(b, source)));
+    const sortedSpreads = [...spreads].sort((a, b) => compareImportNames(nameOf(a.argument, source), nameOf(b.argument, source)));
     return [...sortedRegular, ...sortedSpreads].map((n) => nameOf(n, source));
 }
+function compareImportNames(x, y) {
+    return IMPORT_NAME_COLLATOR.compare(x, y);
+}
 const rule$6 = createRule({
     create(context, [options]) {
@@ -255277,21 +255420,22 @@ const plugin = {
     },
     rules: {
         'array-as-const': rule$5,
-        'attrs-newline': rule$R,
+        'attrs-newline': rule$S,
         'class-property-naming': rule$4,
-        'decorator-key-sort': rule$Q,
-        'element-newline': rule$P,
+        'decorator-key-sort': rule$R,
+        'element-newline': rule$Q,
         'flat-exports': rule$3,
-        'host-attributes-sort': rule$O,
-        'html-logical-properties': rule$N,
-        'import-integrity': rule$M,
-        'injection-token-description': rule$L,
-        'no-commonjs-import-patterns': rule$K,
-        'no-deep-imports': rule$J,
-        'no-deep-imports-to-indexed-packages': rule$I,
-        'no-duplicate-attrs': rule$H,
-        'no-duplicate-id': rule$G,
-        'no-duplicate-in-head': rule$F,
+        'host-attributes-sort': rule$P,
+        'html-logical-properties': rule$O,
+        'import-integrity': rule$N,
+        'injection-token-description': rule$M,
+        'no-commonjs-import-patterns': rule$L,
+        'no-deep-imports': rule$K,
+        'no-deep-imports-to-indexed-packages': rule$J,
+        'no-duplicate-attrs': rule$I,
+        'no-duplicate-id': rule$H,
+        'no-duplicate-in-head': rule$G,
+        'no-empty-style-metadata': rule$F,
         'no-fully-untracked-effect': rule$E,
         'no-href-with-router-link': rule$D,
         'no-implicit-public': rule$C,

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.507.0",
+  "version": "0.508.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "repository": {
     "type": "git",

package/rules/recommended/decorator-key-sort.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
-import { type Rule } from 'eslint';
-export declare const rule: Rule.RuleModule & {
+type Options = [Record<string, readonly string[]>];
+export declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"incorrectOrder", Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };
 export default rule;

package/rules/recommended/no-empty-style-metadata.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+export declare const rule: TSESLint.RuleModule<"noEmptyStyleMetadata", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default rule;

package/rules/utils/angular/get-decorator-metadata.d.ts CHANGED Viewed

@@ -1,4 +1,9 @@
 import { type TSESTree } from '@typescript-eslint/utils';
+export interface DecoratorMetadataWithName {
+    readonly expression: TSESTree.CallExpression;
+    readonly metadata: TSESTree.ObjectExpression;
+    readonly name: string;
+}
 /**
  * Extracts the metadata object from a class decorator such as
  * `@Component()`, `@Directive()`, `@NgModule()`, or `@Pipe()`.
@@ -15,7 +20,7 @@ import { type TSESTree } from '@typescript-eslint/utils';
  * class MyCmp {}
  *
  * // In the AST for @Component(...)
- * getDecoratorMetadata(decorator, allowed) →
+ * getDecoratorMetadata(decorator, allowed) returns
  *    ObjectExpression({ selector: ..., imports: ... })
  *
  * @param decorator - The decorator node attached to a class declaration.
@@ -25,4 +30,5 @@ import { type TSESTree } from '@typescript-eslint/utils';
  * @returns The metadata `ObjectExpression` if present and valid,
  *          otherwise `null`.
  */
-export declare function getDecoratorMetadata(decorator: TSESTree.Decorator, allowedNames: Set<string>): TSESTree.ObjectExpression | null;
+export declare function getDecoratorMetadata(decorator: TSESTree.Decorator, allowedNames: ReadonlySet<string>): TSESTree.ObjectExpression | null;
+export declare function getDecoratorMetadataWithName(decorator: TSESTree.Decorator, allowedNames: ReadonlySet<string>): DecoratorMetadataWithName | null;

package/rules/utils/angular/is-imports-array-property.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
 import { type TSESTree } from '@typescript-eslint/utils';
-export declare function isImportsArrayProperty(property?: TSESTree.Property): property is TSESTree.Property & {
+export declare function isImportsArrayProperty(property?: TSESTree.ObjectExpression['properties'][number]): property is TSESTree.Property & {
     value: TSESTree.ArrayExpression;
 };

package/rules/utils/sorting/get-sorted-names.d.ts CHANGED Viewed

@@ -1,9 +1,9 @@
 import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
 /**
- * Sorts Angular standalone import elements into a deterministic, alphabetical order.
+ * Sorts Angular standalone import elements into a deterministic, natural order.
  *
  * The sorting rules:
- * 1. Regular elements (Identifiers, MemberExpressions, etc.) are sorted alphabetically.
+ * 1. Regular elements (Identifiers, MemberExpressions, etc.) are sorted naturally.
  * 2. Spread elements (e.g. `...A`) are sorted separately and placed after regular ones.
  * 3. Sorting is based on the string value returned by `nameOf()`.
  *