@angular-eslint/eslint-plugin 19.4.1-alpha.0 → 19.4.1-alpha.10

package/README.md

@@ -73,6 +73,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`relative-url-prefix`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/relative-url-prefix.md) | The ./ and ../ prefix is standard syntax for relative URLs; don't depend on Angular's current ability to do without that prefix. See more at https://angular.dev/style-guide#style-05-04 |  |  |  |
 | [`require-localize-metadata`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/require-localize-metadata.md) | Ensures that $localize tagged messages contain helpful metadata to aid with translations. |  |  |  |
 | [`runtime-localize`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/runtime-localize.md) | Ensures that $localize tagged messages can use runtime-loaded translations. |  |  |  |
+| [`sort-keys-in-type-decorator`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/sort-keys-in-type-decorator.md) | Ensures that keys in type decorators (Component, Directive, NgModule, Pipe) are sorted in a consistent order |  | :wrench: |  |
 | [`use-component-selector`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/use-component-selector.md) | Component selector must be declared |  |  |  |
 | [`use-component-view-encapsulation`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/use-component-view-encapsulation.md) | Disallows using `ViewEncapsulation.None` |  |  | :bulb: |
 | [`use-injectable-provided-in`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/use-injectable-provided-in.md) | Using the `providedIn` property makes `Injectables` tree-shakable |  |  | :bulb: |

package/dist/configs/all.json

@@ -36,6 +36,7 @@
     "@angular-eslint/require-lifecycle-on-prototype": "error",
     "@angular-eslint/require-localize-metadata": "error",
     "@angular-eslint/runtime-localize": "error",
+    "@angular-eslint/sort-keys-in-type-decorator": "error",
     "@angular-eslint/sort-lifecycle-methods": "error",
     "@angular-eslint/use-component-selector": "error",
     "@angular-eslint/use-component-view-encapsulation": "error",

package/dist/index.d.ts

@@ -38,6 +38,7 @@ declare const _default: {
                 "@angular-eslint/require-lifecycle-on-prototype": string;
                 "@angular-eslint/require-localize-metadata": string;
                 "@angular-eslint/runtime-localize": string;
+                "@angular-eslint/sort-keys-in-type-decorator": string;
                 "@angular-eslint/sort-lifecycle-methods": string;
                 "@angular-eslint/use-component-selector": string;
                 "@angular-eslint/use-component-view-encapsulation": string;
@@ -107,6 +108,7 @@ declare const _default: {
         "require-lifecycle-on-prototype": import("@typescript-eslint/utils/ts-eslint").RuleModule<"defineOnPrototype", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "require-localize-metadata": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/require-localize-metadata").MessageIds, import("./rules/require-localize-metadata").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "runtime-localize": import("@typescript-eslint/utils/ts-eslint").RuleModule<"runtimeLocalize", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "sort-keys-in-type-decorator": import("@typescript-eslint/utils/ts-eslint").RuleModule<"incorrectOrder", import("./rules/sort-keys-in-type-decorator").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "sort-lifecycle-methods": import("@typescript-eslint/utils/ts-eslint").RuleModule<"lifecycleMethodsNotSorted", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "use-component-selector": import("@typescript-eslint/utils/ts-eslint").RuleModule<"useComponentSelector", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "use-component-view-encapsulation": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/use-component-view-encapsulation").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4HA,kBAgDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+HA,kBAiDE"}

package/dist/index.js

@@ -48,6 +48,7 @@ const directive_selector_1 = __importStar(require("./rules/directive-selector"))
 const no_async_lifecycle_method_1 = __importStar(require("./rules/no-async-lifecycle-method"));
 const no_attribute_decorator_1 = __importStar(require("./rules/no-attribute-decorator"));
 const no_conflicting_lifecycle_1 = __importStar(require("./rules/no-conflicting-lifecycle"));
+const no_duplicates_in_metadata_arrays_1 = __importStar(require("./rules/no-duplicates-in-metadata-arrays"));
 const no_empty_lifecycle_method_1 = __importStar(require("./rules/no-empty-lifecycle-method"));
 const no_forward_ref_1 = __importStar(require("./rules/no-forward-ref"));
 const no_input_prefix_1 = __importStar(require("./rules/no-input-prefix"));
@@ -70,13 +71,13 @@ const relative_url_prefix_1 = __importStar(require("./rules/relative-url-prefix"
 const require_lifecycle_on_prototype_1 = __importStar(require("./rules/require-lifecycle-on-prototype"));
 const require_localize_metadata_1 = __importStar(require("./rules/require-localize-metadata"));
 const runtime_localize_1 = __importStar(require("./rules/runtime-localize"));
+const sort_keys_in_type_decorator_1 = __importStar(require("./rules/sort-keys-in-type-decorator"));
 const sort_lifecycle_methods_1 = __importStar(require("./rules/sort-lifecycle-methods"));
 const use_component_selector_1 = __importStar(require("./rules/use-component-selector"));
 const use_component_view_encapsulation_1 = __importStar(require("./rules/use-component-view-encapsulation"));
 const use_injectable_provided_in_1 = __importStar(require("./rules/use-injectable-provided-in"));
 const use_lifecycle_interface_1 = __importStar(require("./rules/use-lifecycle-interface"));
 const use_pipe_transform_interface_1 = __importStar(require("./rules/use-pipe-transform-interface"));
-const no_duplicates_in_metadata_arrays_1 = __importStar(require("./rules/no-duplicates-in-metadata-arrays"));
 module.exports = {
     configs: {
         all: all_json_1.default,
@@ -117,6 +118,7 @@ module.exports = {
         [require_lifecycle_on_prototype_1.RULE_NAME]: require_lifecycle_on_prototype_1.default,
         [require_localize_metadata_1.RULE_NAME]: require_localize_metadata_1.default,
         [runtime_localize_1.RULE_NAME]: runtime_localize_1.default,
+        [sort_keys_in_type_decorator_1.RULE_NAME]: sort_keys_in_type_decorator_1.default,
         [sort_lifecycle_methods_1.RULE_NAME]: sort_lifecycle_methods_1.default,
         [use_component_selector_1.RULE_NAME]: use_component_selector_1.default,
         [use_component_view_encapsulation_1.RULE_NAME]: use_component_view_encapsulation_1.default,

package/dist/rules/sort-keys-in-type-decorator.d.ts

@@ -0,0 +1,11 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export type Options = [
+    {
+        [key: string]: string[];
+    }
+];
+export type MessageIds = 'incorrectOrder';
+export declare const RULE_NAME = "sort-keys-in-type-decorator";
+declare const _default: TSESLint.RuleModule<"incorrectOrder", Options, import("../utils/create-eslint-rule").RuleDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=sort-keys-in-type-decorator.d.ts.map

package/dist/rules/sort-keys-in-type-decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-keys-in-type-decorator.d.ts","sourceRoot":"","sources":["../../src/rules/sort-keys-in-type-decorator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAG9D,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;KACzB;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAoB1C,eAAO,MAAM,SAAS,gCAAgC,CAAC;;AAEvD,wBA+IG"}

package/dist/rules/sort-keys-in-type-decorator.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const DEFAULT_ORDER = {
+    Component: [
+        'selector',
+        'imports',
+        'standalone',
+        'templateUrl',
+        'template',
+        'styleUrl',
+        'styleUrls',
+        'styles',
+        'encapsulation',
+        'changeDetection',
+    ],
+    Directive: ['selector', 'standalone'],
+    NgModule: ['declarations', 'imports', 'exports', 'providers', 'bootstrap'],
+    Pipe: ['name', 'standalone'],
+};
+exports.RULE_NAME = 'sort-keys-in-type-decorator';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that keys in type decorators (Component, Directive, NgModule, Pipe) are sorted in a consistent order',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    Component: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    Directive: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    NgModule: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    Pipe: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            incorrectOrder: 'Keys in @{{decorator}} decorator should be ordered: {{expectedOrder}}',
+        },
+    },
+    defaultOptions: [DEFAULT_ORDER],
+    create(context, [orderConfig]) {
+        function checkContext(node, decoratorName) {
+            const expectedOrder = orderConfig[decoratorName];
+            if (!expectedOrder) {
+                return;
+            }
+            const argument = utils_1.ASTUtils.getDecoratorArgument(node);
+            if (!argument) {
+                return;
+            }
+            const properties = utils_1.ASTUtils.getDecoratorProperties(node);
+            if (properties.length <= 1) {
+                return;
+            }
+            const firstConfiguredIndex = properties.findIndex(({ key }) => expectedOrder.includes(key.name));
+            const lastNonConfiguredIndex = properties.findIndex(({ key }) => !expectedOrder.includes(key.name));
+            if (firstConfiguredIndex !== -1 &&
+                lastNonConfiguredIndex !== -1 &&
+                lastNonConfiguredIndex < firstConfiguredIndex) {
+                createInvalidSortRuleForDecorator(context, decoratorName, expectedOrder, properties, properties[lastNonConfiguredIndex]);
+                return;
+            }
+            const configuredProperties = properties.filter(({ key }) => expectedOrder.includes(key.name));
+            if (configuredProperties.length) {
+                const actualConfiguredOrder = configuredProperties.map(({ key }) => key.name);
+                const expectedConfiguredOrder = expectedOrder.filter((key) => actualConfiguredOrder.includes(key));
+                if (actualConfiguredOrder.length &&
+                    JSON.stringify(actualConfiguredOrder) !==
+                        JSON.stringify(expectedConfiguredOrder)) {
+                    const firstOutOfOrderIndex = actualConfiguredOrder.findIndex((key, index) => key !== expectedConfiguredOrder[index]);
+                    const outOfOrderProperty = configuredProperties[firstOutOfOrderIndex];
+                    createInvalidSortRuleForDecorator(context, decoratorName, expectedOrder, properties, outOfOrderProperty);
+                }
+            }
+        }
+        return {
+            [utils_1.Selectors.COMPONENT_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.Component);
+            },
+            [utils_1.Selectors.DIRECTIVE_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.Directive);
+            },
+            [utils_1.Selectors.INJECTABLE_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.Injectable);
+            },
+            [utils_1.Selectors.MODULE_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.NgModule);
+            },
+            [utils_1.Selectors.PIPE_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.Pipe);
+            },
+        };
+    },
+});
+function createInvalidSortRuleForDecorator(context, decoratorName, expectedOrder, properties, node) {
+    const presentProps = properties.map((prop) => prop.key.name);
+    const relevantExpectedOrder = expectedOrder.filter((propName) => presentProps.includes(propName));
+    const data = {
+        decorator: decoratorName,
+        expectedOrder: relevantExpectedOrder.join(', '),
+    };
+    reportAndFix(context, node, 'incorrectOrder', data, properties, expectedOrder, node.parent);
+}
+function reportAndFix(context, node, messageId, data, properties, expectedOrder, objectExpression) {
+    const sourceCode = context.sourceCode;
+    context.report({
+        node,
+        messageId,
+        data,
+        fix(fixer) {
+            const indentation = utils_1.CommentUtils.getObjectIndentation(sourceCode, objectExpression);
+            const propNames = properties.map((p) => p.key.name);
+            const filteredOrder = expectedOrder.filter((name) => propNames.includes(name));
+            const propInfoMap = utils_1.CommentUtils.extractPropertyComments(sourceCode, properties, objectExpression, indentation);
+            const sortedText = utils_1.CommentUtils.buildSortedPropertiesWithComments(filteredOrder, propInfoMap, indentation);
+            return fixer.replaceText(objectExpression, `{\n${sortedText}\n${indentation.slice(0, -2)}}`);
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "19.4.1-alpha.0",
+  "version": "19.4.1-alpha.10",
   "description": "ESLint plugin for Angular applications, following https://angular.dev/style-guide",
   "license": "MIT",
   "main": "dist/index.js",
@@ -18,11 +18,11 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@angular-eslint/bundled-angular-compiler": "19.4.1-alpha.0",
-    "@angular-eslint/utils": "19.4.1-alpha.0"
+    "@angular-eslint/bundled-angular-compiler": "19.4.1-alpha.10",
+    "@angular-eslint/utils": "19.4.1-alpha.10"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "19.4.1-alpha.0"
+    "@angular-eslint/test-utils": "19.4.1-alpha.10"
   },
   "peerDependencies": {
     "@typescript-eslint/utils": "^7.11.0 || ^8.0.0",