@depup/angular-eslint__eslint-plugin 21.3.1-depup.0

package/dist/rules/prefer-standalone.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'prefer-standalone';
+const RECOMMENDED_GUIDE_URL = 'https://angular.dev/reference/migrations/standalone';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Ensures Components, Directives and Pipes do not opt out of standalone.`,
+            recommended: 'recommended',
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            preferStandalone: `Components, Directives and Pipes should not opt out of standalone. Following this guide is highly recommended: ${RECOMMENDED_GUIDE_URL}`,
+            removeStandaloneFalse: `Quickly remove 'standalone: false'. NOTE - Following this guide is highly recommended: ${RECOMMENDED_GUIDE_URL}`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const standaloneRuleFactory = (type) => (node) => {
+            const standalone = utils_1.ASTUtils.getDecoratorPropertyValue(node, 'standalone');
+            // Leave the standalone property alone if it was set to true or not present
+            if (!standalone ||
+                (utils_1.ASTUtils.isLiteral(standalone) && standalone.value === true)) {
+                return;
+            }
+            if (!utils_1.ASTUtils.getDecoratorArgument(node)) {
+                return;
+            }
+            context.report({
+                node: standalone.parent,
+                messageId: 'preferStandalone',
+                data: { type },
+                suggest: [
+                    {
+                        messageId: 'removeStandaloneFalse',
+                        fix: (fixer) => {
+                            // Remove the standalone property altogether if it was set to false
+                            const tokenAfter = context.sourceCode.getTokenAfter(standalone.parent);
+                            // Remove the trailing comma, if present
+                            const removeStart = standalone.parent.range[0];
+                            let removeEnd = standalone.parent.range[1];
+                            if (tokenAfter && tokenAfter.value === ',') {
+                                removeEnd = tokenAfter.range[1];
+                            }
+                            return fixer.removeRange([removeStart, removeEnd]);
+                        },
+                    },
+                ],
+            });
+        };
+        return {
+            [utils_1.Selectors.COMPONENT_CLASS_DECORATOR]: standaloneRuleFactory('component'),
+            [utils_1.Selectors.DIRECTIVE_CLASS_DECORATOR]: standaloneRuleFactory('directive'),
+            [utils_1.Selectors.PIPE_CLASS_DECORATOR]: standaloneRuleFactory('pipe'),
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: 'Standalone components, directives, and pipes are the recommended way to build Angular applications. Setting standalone: false opts out of the standalone API, tying your code to the older NgModule-based architecture. Standalone components simplify Angular applications by eliminating the need for NgModules in most cases, reducing boilerplate and making dependencies more explicit. Each standalone component declares its own dependencies directly, making it self-contained and easier to understand, test, and reuse. Standalone components also enable better tree-shaking and lazy loading. Angular provides comprehensive migration guides to help transition existing applications, such as https://angular.dev/reference/migrations/standalone. New projects should use standalone components from the start, and existing projects should avoid adding new non-standalone components as they will make future migrations harder.',
+};

package/dist/rules/relative-url-prefix.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'relativeUrlPrefix';
+export declare const RULE_NAME = "relative-url-prefix";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"relativeUrlPrefix", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=relative-url-prefix.d.ts.map

package/dist/rules/relative-url-prefix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relative-url-prefix.d.ts","sourceRoot":"","sources":["../../src/rules/relative-url-prefix.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAC7C,eAAO,MAAM,SAAS,wBAAwB,CAAC;;;;AAI/C,wBA0CG;AAiBH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/relative-url-prefix.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'relative-url-prefix';
+const RELATIVE_URL_PREFIX_MATCHER = /^\.\.?\/.+/;
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `The ./ and ../ prefix is standard syntax for relative URLs; don't depend on Angular's current ability to do without that prefix.`,
+        },
+        schema: [],
+        messages: {
+            relativeUrlPrefix: `The ./ and ../ prefix is standard syntax for relative URLs.`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name='templateUrl']`]({ value, }) {
+                if (!isUrlInvalid(value))
+                    return;
+                context.report({
+                    node: value,
+                    messageId: 'relativeUrlPrefix',
+                });
+            },
+            [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name='styleUrls']`]({ value, }) {
+                if (!utils_1.ASTUtils.isArrayExpression(value))
+                    return;
+                value.elements.filter(isUrlInvalid).forEach((element) => {
+                    if (!element) {
+                        return;
+                    }
+                    context.report({
+                        node: element,
+                        messageId: 'relativeUrlPrefix',
+                    });
+                });
+            },
+        };
+    },
+});
+function isUrlInvalid(node) {
+    if (!node) {
+        return false;
+    }
+    if (utils_1.ASTUtils.isTemplateLiteral(node)) {
+        return !RELATIVE_URL_PREFIX_MATCHER.test(node.quasis[0].value.raw);
+    }
+    return (!utils_1.ASTUtils.isStringLiteral(node) ||
+        !RELATIVE_URL_PREFIX_MATCHER.test(node.value));
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Using relative URLs (like './user-profile.component.html') instead of absolute URLs (like 'app/users/user-profile.component.html') for templateUrl and styleUrls makes components more portable and easier to refactor. When you move a component to a different directory, relative URLs don't need to be updated as long as the template and styles move with the component. This follows the principle of co-locating related files and makes refactoring safer. Relative URLs should typically start with './' for files in the same directory or '../' for files in parent directories.",
+};

package/dist/rules/require-lifecycle-on-prototype.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'defineOnPrototype';
+export declare const RULE_NAME = "require-lifecycle-on-prototype";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"defineOnPrototype", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=require-lifecycle-on-prototype.d.ts.map

package/dist/rules/require-lifecycle-on-prototype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-lifecycle-on-prototype.d.ts","sourceRoot":"","sources":["../../src/rules/require-lifecycle-on-prototype.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAIzB,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAC7C,eAAO,MAAM,SAAS,mCAAmC,CAAC;;;;AAY1D,wBA2CG;AAkBH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/require-lifecycle-on-prototype.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const utils_2 = require("@angular-eslint/utils");
+const ISSUE_LINK = 'https://github.com/angular/angular/issues/38241';
+exports.RULE_NAME = 'require-lifecycle-on-prototype';
+const angularLifecycleMethodsPattern = (0, utils_2.toPattern)([
+    ...utils_2.ASTUtils.ANGULAR_LIFECYCLE_METHODS,
+]);
+const propertyDefinitionSelector = `PropertyDefinition > ${createAngularLifecycleMethodsPattern('key')}`;
+const assignmentSelector = `AssignmentExpression[operator="="] > MemberExpression.left > ${createAngularLifecycleMethodsPattern('property')}`;
+function createAngularLifecycleMethodsPattern(parentProperty) {
+    return `:matches(Literal.${parentProperty}[value=${angularLifecycleMethodsPattern}], Identifier.${parentProperty}[name=${angularLifecycleMethodsPattern}])`;
+}
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: "Ensures that lifecycle methods are defined on the object's prototype instead of on an instance.",
+        },
+        schema: [],
+        messages: {
+            defineOnPrototype: `The {{ method }} lifecycle method should be defined on the object's prototype. See more at ${ISSUE_LINK}`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [propertyDefinitionSelector](node) {
+                context.report({
+                    node,
+                    messageId: 'defineOnPrototype',
+                    data: {
+                        method: node.type === utils_1.AST_NODE_TYPES.Literal ? node.value : node.name,
+                    },
+                });
+            },
+            [assignmentSelector](node) {
+                // Assigning to the prototype is OK.
+                if (!isPrototype(node.parent.object)) {
+                    context.report({
+                        node,
+                        messageId: 'defineOnPrototype',
+                        data: {
+                            method: node.type === utils_1.AST_NODE_TYPES.Literal ? node.value : node.name,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+function isPrototype(node) {
+    while (node.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+        node = node.expression;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        switch (node.property.type) {
+            case utils_1.AST_NODE_TYPES.Identifier:
+                return node.property.name === 'prototype';
+            case utils_1.AST_NODE_TYPES.Literal:
+                return node.property.value === 'prototype';
+        }
+    }
+    return false;
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Lifecycle methods in Angular must be defined on the class prototype (using method syntax) rather than as instance properties (using arrow functions or property assignments). Angular's change detection looks for lifecycle methods on the prototype chain, and defining them as instance properties can prevent Angular from finding and invoking them correctly. This is a subtle but critical issue that can cause lifecycle hooks to silently fail. For example, if ngOnInit is defined as a class property (ngOnInit = () => {}), Angular will not call it, leading to missing initialization logic. Using standard method definitions ensures lifecycle hooks are placed on the prototype where Angular expects them.",
+};

package/dist/rules/require-localize-metadata.d.ts

@@ -0,0 +1,17 @@
+export type Options = [
+    {
+        readonly requireDescription?: boolean;
+        readonly requireMeaning?: boolean;
+        readonly requireCustomId?: boolean | string;
+    }
+];
+export type MessageIds = 'requireLocalizeDescription' | 'requireLocalizeMeaning' | 'requireLocalizeCustomId';
+export declare const RULE_NAME = "require-localize-metadata";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=require-localize-metadata.d.ts.map

package/dist/rules/require-localize-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-localize-metadata.d.ts","sourceRoot":"","sources":["../../src/rules/require-localize-metadata.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;QACtC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;QAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;KAC7C;CACF,CAAC;AAYF,MAAM,MAAM,UAAU,GAClB,4BAA4B,GAC5B,wBAAwB,GACxB,yBAAyB,CAAC;AAC9B,eAAO,MAAM,SAAS,8BAA8B,CAAC;;;;AAErD,wBAyFG;AAyCH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/require-localize-metadata.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const DEFAULT_OPTIONS = {
+    requireDescription: false,
+    requireMeaning: false,
+    requireCustomId: false,
+};
+const STYLE_GUIDE_LINK = 'https://angular.dev/guide/i18n';
+const STYLE_GUIDE_LINK_PREPARE = `${STYLE_GUIDE_LINK}/prepare`;
+const STYLE_GUIDE_LINK_METADATA_FOR_TRANSLATION = `${STYLE_GUIDE_LINK_PREPARE}#i18n-metadata-for-translation`;
+exports.RULE_NAME = 'require-localize-metadata';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that $localize tagged messages contain helpful metadata to aid with translations.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    requireDescription: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.requireDescription,
+                    },
+                    requireMeaning: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.requireMeaning,
+                    },
+                    requireCustomId: {
+                        oneOf: [{ type: 'boolean' }, { type: 'string' }],
+                        default: DEFAULT_OPTIONS.requireCustomId,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            requireLocalizeDescription: `$localize tagged messages should contain a description. See more at ${STYLE_GUIDE_LINK_METADATA_FOR_TRANSLATION}`,
+            requireLocalizeMeaning: `$localize tagged messages should contain a meaning. See more at ${STYLE_GUIDE_LINK_METADATA_FOR_TRANSLATION}`,
+            requireLocalizeCustomId: `$localize tagged messages should contain a custom id{{patternMessage}}. See more at ${STYLE_GUIDE_LINK_METADATA_FOR_TRANSLATION}`,
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context, [{ requireDescription, requireMeaning, requireCustomId }]) {
+        return {
+            TaggedTemplateExpression(taggedTemplateExpression) {
+                if ((requireDescription || requireMeaning || requireCustomId) &&
+                    utils_1.ASTUtils.isIdentifier(taggedTemplateExpression.tag)) {
+                    const identifierName = taggedTemplateExpression.tag.name;
+                    const templateElement = taggedTemplateExpression.quasi.quasis[0];
+                    if (identifierName === '$localize' && !!templateElement) {
+                        const metadata = parseMetadata(templateElement.value.raw.trim());
+                        if (requireDescription && !metadata.description) {
+                            context.report({
+                                loc: templateElement.loc,
+                                messageId: 'requireLocalizeDescription',
+                            });
+                        }
+                        if (requireMeaning && !metadata.meaning) {
+                            context.report({
+                                loc: templateElement.loc,
+                                messageId: 'requireLocalizeMeaning',
+                            });
+                        }
+                        if (requireCustomId &&
+                            !(metadata.customId &&
+                                (typeof requireCustomId === 'string'
+                                    ? RegExp(requireCustomId).test(metadata.customId)
+                                    : true))) {
+                            context.report({
+                                loc: templateElement.loc,
+                                messageId: 'requireLocalizeCustomId',
+                                data: {
+                                    patternMessage: typeof requireCustomId === 'string'
+                                        ? ` matching the pattern /${requireCustomId}/ on '${metadata.customId}'`
+                                        : '',
+                                },
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+// see https://github.com/angular/angular/blob/main/packages/localize/src/utils/src/messages.ts#L247
+const BLOCK_MARKER = ':';
+const MEANING_SEPARATOR = '|';
+const ID_SEPARATOR = '@@';
+function parseMetadata(rawText) {
+    const output = {
+        rawText,
+        meaning: undefined,
+        description: undefined,
+        customId: undefined,
+    };
+    if (rawText.charAt(0) !== BLOCK_MARKER) {
+        return output;
+    }
+    const endOfTheBlock = rawText.lastIndexOf(BLOCK_MARKER);
+    if (endOfTheBlock === -1) {
+        return output;
+    }
+    const text = rawText.slice(1, endOfTheBlock);
+    const [meaningAndDesc, customId] = text.split(ID_SEPARATOR, 2);
+    let [meaning, description] = meaningAndDesc.split(MEANING_SEPARATOR, 2);
+    if (description === undefined) {
+        description = meaning;
+        meaning = undefined;
+    }
+    if (description === '') {
+        description = undefined;
+    }
+    return { rawText, meaning, description, customId };
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `When internationalizing Angular applications with @angular/localize, adding metadata (description, meaning, and custom IDs) to $localize tagged strings is essential for high-quality translations. The description helps translators understand the context and purpose of the text they're translating. For example, "Open" could mean "open a file" (access/view) or "open an account" (establish/create) - context matters for accurate translation. The meaning field distinguishes identical text that needs different translations in different contexts. Custom IDs provide stable references that persist across code changes, preventing retranslation when only code structure changes. Without this metadata, translators work blind, leading to poor translations, wasted effort on retranslating unchanged strings, and difficulty managing large translation projects. This rule ensures your $localize strings include helpful metadata for translation workflows.`,
+};

package/dist/rules/runtime-localize.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'runtimeLocalize';
+export declare const RULE_NAME = "runtime-localize";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"runtimeLocalize", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=runtime-localize.d.ts.map

package/dist/rules/runtime-localize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-localize.d.ts","sourceRoot":"","sources":["../../src/rules/runtime-localize.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,iBAAiB,CAAC;AAC3C,eAAO,MAAM,SAAS,qBAAqB,CAAC;;;;AAE5C,wBA6CG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/runtime-localize.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'runtime-localize';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that $localize tagged messages can use runtime-loaded translations.',
+        },
+        schema: [],
+        messages: {
+            runtimeLocalize: `$localize could be called before translations are loaded`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            TaggedTemplateExpression(taggedTemplateExpression) {
+                if (utils_1.ASTUtils.isIdentifier(taggedTemplateExpression.tag) &&
+                    taggedTemplateExpression.tag.name === '$localize') {
+                    for (const ancestor of context.sourceCode.getAncestors(taggedTemplateExpression)) {
+                        if (ancestor.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                            ancestor.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                            ancestor.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                            (ancestor.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+                                !ancestor.static)) {
+                            return;
+                        }
+                    }
+                    context.report({
+                        loc: taggedTemplateExpression.tag.loc,
+                        messageId: 'runtimeLocalize',
+                    });
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Using $localize at the top level of a module (outside of functions or methods) means the localization happens immediately when the module loads, before runtime translation data can be loaded. This creates a timing problem - the string gets localized using whatever translations are available at module load time (typically none), and the translated value is frozen. Even if you load translations later, these top-level $localize calls won't use them. Instead, $localize should be called inside functions, methods, or non-static class properties so it executes after translations are loaded. This ensures the runtime-loaded translations are actually used. For top-level strings that need localization, initialize them in a function called after translations load, or use them within component templates where Angular handles the timing correctly.",
+};

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

@@ -0,0 +1,16 @@
+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> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# 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;AA2D1C,eAAO,MAAM,SAAS,gCAAgC,CAAC;;;;AAEvD,wBA+IG;AAsFH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = 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 = {
+    // https://angular.dev/api/core/Component
+    Component: [
+        'selector',
+        'imports',
+        'standalone',
+        'templateUrl',
+        'template',
+        'styleUrl',
+        'styleUrls',
+        'styles',
+        'providers',
+        'changeDetection',
+        'encapsulation',
+        'viewProviders',
+        'host',
+        'hostDirectives',
+        'inputs',
+        'outputs',
+        'animations',
+        'schemas',
+        'exportAs',
+        'queries',
+        'preserveWhitespaces',
+        'jit',
+        // Deprecated properties according to https://angular.dev/api/core/Component
+        'moduleId',
+        'interpolation',
+    ],
+    // https://angular.dev/api/core/Directive
+    Directive: [
+        'selector',
+        'standalone',
+        'providers',
+        'host',
+        'hostDirectives',
+        'inputs',
+        'outputs',
+        'exportAs',
+        'queries',
+        'jit',
+    ],
+    // https://angular.dev/api/core/NgModule
+    NgModule: [
+        'id', // rarely used but good to have first if set
+        'imports',
+        'declarations',
+        'providers',
+        'exports',
+        'bootstrap',
+        'schemas',
+        'jit',
+    ],
+    // https://angular.dev/api/core/Pipe
+    Pipe: ['name', 'standalone', 'pure'],
+};
+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 configuredProps = expectedOrder.filter((name) => propNames.includes(name));
+            const unconfiguredProps = propNames.filter((name) => !expectedOrder.includes(name));
+            const filteredOrder = [...configuredProps, ...unconfiguredProps];
+            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)}}`);
+        },
+    });
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: 'Maintaining a consistent order for properties in Angular decorators (@Component, @Directive, @NgModule, @Pipe) makes code more predictable and easier to scan. When all components in a codebase follow the same property order, developers can quickly locate specific metadata without searching. For example, if selector always comes first and providers always comes before changeDetection, you develop muscle memory for where to look. This is especially helpful in large components with many properties. The recommended default order groups related properties logically: identification (selector, name) first, then dependencies (imports, providers), then templates/styles, then configuration options. Consistent ordering also makes code reviews easier, reduces merge conflicts when multiple developers edit decorators, and creates a professional, well-organized codebase.',
+};