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

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

package/README.md +1 -36
package/index.d.ts +4 -1
package/index.esm.js +503 -187
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/recommended/prefer-conditional-return.d.ts +2 -2
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 { ... }`                               | ✅  | 🔧  |     |
@@ -126,39 +127,3 @@ from third-party plugins. The exact severities and file globs live in
 | [single-line-variable-spacing](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/single-line-variable-spacing.md)                                       | Group consecutive single-line variables 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         |     | 🔧  |     |
-## prefer-conditional-return
-Prefer a single conditional return when an `if` statement returns one expression and the immediately following statement
-returns the fallback expression. The rule skips branches with comments, `else`, empty returns, intervening statements,
-or a return expression that is already a conditional expression.
-```ts
-// ❌ error
-if (index < count) {
-  return {value: index++, done: false};
-}
-return {value: undefined, done: true};
-// ✅ after autofix
-return index < count ? {value: index++, done: false} : {value: undefined, done: true};
-```
-```ts
-// not changed: if branch return is already conditional
-if (condition) {
-  return first ? second : third;
-}
-return fallback;
-```
-```ts
-// not changed: fallback return is already conditional
-if (condition) {
-  return value;
-}
-return first ? second : third;
-```

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

@@ -532,6 +532,7 @@ var recommended = defineConfig([
     progress.configs['recommended-ci'],
     {
         ignores: [
+            '**/tests-results/**',
             '**/tests-report/**',
             '**/snapshots/**',
             '**/test-results/**',
@@ -1201,6 +1202,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 +46224,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join('\n');
 }
-const rule$R = createRule({
+const rule$S = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -46308,54 +46310,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 +46464,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 +46540,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 +46614,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 +46679,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 +47010,7 @@ const config$4 = {
         type: 'suggestion',
     },
 };
-const rule$N = createRule({
+const rule$O = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
@@ -247920,6 +247943,9 @@ function sourceFileHasDefaultExport(sourceFile) {
         hasRuntimeDefaultModifier(statement) ||
         (ts.isExportDeclaration(statement) && exportsDefaultSpecifier(statement)));
 }
+function isJsonModuleFileName(fileName) {
+    return path.extname(fileName).toLowerCase() === '.json';
+}
 function hasDefaultExport(program, fileName) {
     const canonicalFileName = createCanonicalFileName();
     const normalizedFileName = canonicalFileName(fileName);
@@ -248226,7 +248252,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;
@@ -248379,7 +248405,8 @@ const rule$M = createRule({
                 : null;
         }
         function getIndexPathReplacement(moduleSpecifierPath, canonicalResolvedFileName) {
-            if (!isIndexModulePath(moduleSpecifierPath)) {
+            if (codeFileExtensionRegExp.test(moduleSpecifierPath) ||
+                !isIndexModulePath(moduleSpecifierPath)) {
                 return null;
             }
             const parentDirectory = path.posix.dirname(moduleSpecifierPath);
@@ -248596,7 +248623,8 @@ const rule$M = createRule({
             const moduleSpecifier = node.source.value;
             const resolved = resolveModule(tsProgram, context.filename, moduleSpecifier);
             if (!resolved ||
-                (resolved.isExternalLibraryImport && ignoreExternalDefaultImports)) {
+                (resolved.isExternalLibraryImport && ignoreExternalDefaultImports) ||
+                isJsonModuleFileName(resolved.resolvedFileName)) {
                 return;
             }
             const hasResolvedDefaultExport = hasDefaultExport(tsProgram, resolved.resolvedFileName);
@@ -248687,6 +248715,7 @@ const rule$M = createRule({
             const resolved = resolveModule(tsProgram, context.filename, moduleSpecifier);
             if (!resolved ||
                 (resolved.isExternalLibraryImport && ignoreExternalDefaultImports) ||
+                isJsonModuleFileName(resolved.resolvedFileName) ||
                 !hasDefaultExport(tsProgram, resolved.resolvedFileName)) {
                 return;
             }
@@ -248712,7 +248741,11 @@ const rule$M = createRule({
                 return;
             }
             const namespaceImport = node.specifiers.find((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier);
-            if (!namespaceImport) {
+            if (!namespaceImport || typeof node.source.value !== 'string') {
+                return;
+            }
+            const resolved = resolveModule(tsProgram, context.filename, node.source.value);
+            if (resolved && isJsonModuleFileName(resolved.resolvedFileName)) {
                 return;
             }
             const exportNames = getNamespaceImportExportNames(checker, esTreeNodeToTSNodeMap, node);
@@ -248944,7 +248977,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 +249026,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 +249121,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 +249213,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 +249407,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 +249474,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 +249529,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 ||
@@ -251231,6 +251391,34 @@ function getStatementIndent$1(statement, sourceText) {
     const before = sourceText.slice(lineStart, start);
     return /^\s*$/.test(before) ? before : '';
 }
+function isAstNode(value) {
+    if (!value || typeof value !== 'object' || !('type' in value)) {
+        return false;
+    }
+    const { type } = value;
+    return typeof type === 'string';
+}
+function getParent(node) {
+    const maybeNode = node;
+    if (!maybeNode || typeof maybeNode !== 'object' || !('parent' in maybeNode)) {
+        return null;
+    }
+    const { parent } = maybeNode;
+    return isAstNode(parent) ? parent : null;
+}
+function isOptionalMemberReceiver(call) {
+    let current = call;
+    let parent = getParent(current);
+    while (parent?.type === dist$3.AST_NODE_TYPES.TSAsExpression ||
+        parent?.type === dist$3.AST_NODE_TYPES.TSNonNullExpression ||
+        parent?.type === dist$3.AST_NODE_TYPES.TSTypeAssertion) {
+        current = parent;
+        parent = getParent(current);
+    }
+    return (parent?.type === dist$3.AST_NODE_TYPES.MemberExpression &&
+        parent.object === current &&
+        parent.optional);
+}
 const rule$t = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
@@ -251247,6 +251435,7 @@ const rule$t = createRule({
                     return false;
                 }
                 if (child.type === dist$3.AST_NODE_TYPES.CallExpression &&
+                    !isOptionalMemberReceiver(child) &&
                     isSignalReadCall(child, checker, signalNodeMap) &&
                     isNullableCallType(child, checker, signalNodeMap)) {
                     const text = sourceCode.getText(child);
@@ -252723,6 +252912,18 @@ const rule$m = createRule({
 });
 const MAX_INLINE_CONDITIONAL_RETURN_LENGTH = 90;
+const BOOLEAN_BINARY_OPERATORS = new Set([
+    '!=',
+    '!==',
+    '<',
+    '<=',
+    '==',
+    '===',
+    '>',
+    '>=',
+    'in',
+    'instanceof',
+]);
 function getReturnStatement(statement) {
     if (statement.type === dist$3.AST_NODE_TYPES.ReturnStatement) {
         return statement;
@@ -252763,6 +252964,52 @@ function isConditionalExpression(node) {
     return (node !== null &&
         unwrapTypeAndParentheses(node).type === dist$3.AST_NODE_TYPES.ConditionalExpression);
 }
+function isBooleanLiteral(node) {
+    return node.type === dist$3.AST_NODE_TYPES.Literal && typeof node.value === 'boolean';
+}
+function getBooleanLiteralValue(node) {
+    return isBooleanLiteral(node) ? node.value : null;
+}
+function isKnownBooleanExpression(node) {
+    const unwrapped = unwrapTypeAndParentheses(node);
+    switch (unwrapped.type) {
+        case dist$3.AST_NODE_TYPES.BinaryExpression:
+            return BOOLEAN_BINARY_OPERATORS.has(unwrapped.operator);
+        case dist$3.AST_NODE_TYPES.Literal:
+            return typeof unwrapped.value === 'boolean';
+        case dist$3.AST_NODE_TYPES.LogicalExpression:
+            return (isKnownBooleanExpression(unwrapped.left) &&
+                isKnownBooleanExpression(unwrapped.right));
+        case dist$3.AST_NODE_TYPES.UnaryExpression:
+            return unwrapped.operator === '!';
+        default:
+            return false;
+    }
+}
+function isBooleanType(type) {
+    const types = type.isUnion() ? type.types : [type];
+    return types.every((part) => !!(part.flags & ts.TypeFlags.BooleanLike));
+}
+function getBooleanTestReturnStrategy(test, consequentExpression, alternateExpression, isTypeCheckedBooleanExpression) {
+    const consequentValue = getBooleanLiteralValue(consequentExpression);
+    const alternateValue = getBooleanLiteralValue(alternateExpression);
+    if (consequentValue === false && alternateValue === true) {
+        return unwrapTypeAndParentheses(test).type === dist$3.AST_NODE_TYPES.LogicalExpression
+            ? 'skip'
+            : 'negate';
+    }
+    if (consequentValue !== true || alternateValue !== false) {
+        return 'skip';
+    }
+    return isKnownBooleanExpression(test) || isTypeCheckedBooleanExpression(test)
+        ? 'direct'
+        : 'coerce';
+}
+function shouldSkipBooleanReturn(test, consequentExpression, alternateExpression) {
+    return (getBooleanLiteralValue(consequentExpression) === false &&
+        getBooleanLiteralValue(alternateExpression) === true &&
+        unwrapTypeAndParentheses(test).type === dist$3.AST_NODE_TYPES.LogicalExpression);
+}
 function needsParenthesesInConditionalTest(node) {
     if (getParenthesizedInner(node)) {
         return false;
@@ -252800,6 +253047,27 @@ function needsParenthesesInConditionalBranch(node) {
             return false;
     }
 }
+function needsParenthesesInBooleanCoercion(node) {
+    if (getParenthesizedInner(node)) {
+        return false;
+    }
+    switch (node.type) {
+        case dist$3.AST_NODE_TYPES.ArrowFunctionExpression:
+        case dist$3.AST_NODE_TYPES.AssignmentExpression:
+        case dist$3.AST_NODE_TYPES.BinaryExpression:
+        case dist$3.AST_NODE_TYPES.ConditionalExpression:
+        case dist$3.AST_NODE_TYPES.LogicalExpression:
+        case dist$3.AST_NODE_TYPES.ObjectExpression:
+        case dist$3.AST_NODE_TYPES.SequenceExpression:
+        case dist$3.AST_NODE_TYPES.TSAsExpression:
+        case dist$3.AST_NODE_TYPES.TSSatisfiesExpression:
+        case dist$3.AST_NODE_TYPES.TSTypeAssertion:
+        case dist$3.AST_NODE_TYPES.YieldExpression:
+            return true;
+        default:
+            return false;
+    }
+}
 function renderExpression(node, sourceCode, needsParentheses) {
     const text = sourceCode.getText(node);
     return needsParentheses(node) ? `(${text})` : text;
@@ -252823,9 +253091,58 @@ function renderConditionalReturn(ifStatement, consequentExpression, alternateExp
     const branchIndent = `${indent}    `;
     return `return ${test}\n${branchIndent}? ${consequent}\n${branchIndent}: ${alternate};`;
 }
+function renderBooleanTestReturn(ifStatement, sourceCode, strategy) {
+    const test = sourceCode.getText(ifStatement.test);
+    if (strategy === 'negate') {
+        if (!test.includes('\n')) {
+            const renderedTest = needsParenthesesInBooleanCoercion(ifStatement.test)
+                ? `(${test})`
+                : test;
+            return `return !${renderedTest};`;
+        }
+        const indent = getStatementIndent(ifStatement, sourceCode);
+        return `return !(\n${indent}    ${test}\n${indent});`;
+    }
+    if (strategy === 'coerce') {
+        if (!test.includes('\n')) {
+            const renderedTest = needsParenthesesInBooleanCoercion(ifStatement.test)
+                ? `(${test})`
+                : test;
+            return `return !!${renderedTest};`;
+        }
+        const indent = getStatementIndent(ifStatement, sourceCode);
+        return `return !!(\n${indent}    ${test}\n${indent});`;
+    }
+    if (!test.includes('\n')) {
+        return `return ${test};`;
+    }
+    const indent = getStatementIndent(ifStatement, sourceCode);
+    return `return (\n${indent}    ${test}\n${indent});`;
+}
 const rule$l = createRule({
     create(context) {
         const { sourceCode } = context;
+        let parserServices = null;
+        let checker = null;
+        try {
+            parserServices = dist$3.ESLintUtils.getParserServices(context);
+            checker = parserServices.program.getTypeChecker();
+        }
+        catch {
+            // Type checking is optional; syntactic boolean detection still works.
+        }
+        function isTypeCheckedBooleanExpression(node) {
+            if (!parserServices || !checker) {
+                return false;
+            }
+            try {
+                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                return isBooleanType(checker.getTypeAtLocation(tsNode));
+            }
+            catch {
+                return false;
+            }
+        }
         function checkBody(statements) {
             for (const [index, statement] of statements.entries()) {
                 if (statement.type !== dist$3.AST_NODE_TYPES.IfStatement) {
@@ -252844,6 +253161,7 @@ const rule$l = createRule({
                     !finalArgument ||
                     isConditionalExpression(consequentArgument) ||
                     isConditionalExpression(finalArgument) ||
+                    shouldSkipBooleanReturn(statement.test, consequentArgument, finalArgument) ||
                     !hasOnlyWhitespaceBetween(sourceCode, statement, finalReturn) ||
                     sourceCode.getCommentsInside(statement).length > 0 ||
                     sourceCode.getCommentsInside(finalReturn).length > 0) {
@@ -252851,7 +253169,10 @@ const rule$l = createRule({
                 }
                 context.report({
                     fix(fixer) {
-                        const replacement = renderConditionalReturn(statement, consequentArgument, finalArgument, sourceCode);
+                        const booleanTestReturnStrategy = getBooleanTestReturnStrategy(statement.test, consequentArgument, finalArgument, isTypeCheckedBooleanExpression);
+                        const replacement = booleanTestReturnStrategy === 'skip'
+                            ? renderConditionalReturn(statement, consequentArgument, finalArgument, sourceCode)
+                            : renderBooleanTestReturn(statement, sourceCode, booleanTestReturnStrategy);
                         return fixer.replaceTextRange([statement.range[0], finalReturn.range[1]], replacement);
                     },
                     messageId: 'preferConditionalReturn',
@@ -253819,10 +254140,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 +254171,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) {
+            Decorator(decorator) {
+                const metadata = getDecoratorMetadata(decorator, allowedDecorators);
+                if (!metadata) {
                     return;
                 }
-                const [arg] = expression.arguments;
-                const isNotObject = arg?.type !== dist$3.AST_NODE_TYPES.ObjectExpression;
-                if (isNotObject) {
+                const importsArray = getImportsArray(metadata);
+                if (!importsArray) {
                     return;
                 }
-                const importsProperty = arg.properties
-                    .filter((literal) => literal.type === dist$3.AST_NODE_TYPES.Property)
-                    .find((literal) => isImportsArrayProperty(literal));
-                if (!importsProperty) {
-                    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 +254594,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 +254633,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 +254657,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 +255592,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.509.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/recommended/prefer-conditional-return.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
-import { type TSESLint } from '@typescript-eslint/utils';
-export declare const rule: TSESLint.RuleModule<"preferConditionalReturn", [], unknown, TSESLint.RuleListener> & {
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const rule: ESLintUtils.RuleModule<"preferConditionalReturn", [], unknown, ESLintUtils.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()`.
  *