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

package/dist/rules/contextual-decorator.js

@@ -0,0 +1,61 @@
+"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 = 'contextual-decorator';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that classes use contextual decorators in their body',
+        },
+        schema: [],
+        messages: {
+            contextualDecorator: 'Decorator out of context for "@{{classDecoratorName}}()"',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            'MethodDefinition[kind=/^(get|set|method)$/], PropertyDefinition, TSParameterProperty'(node) {
+                validateNode(context, node);
+            },
+        };
+    },
+});
+function validateNode(context, node) {
+    if (!node.decorators?.length) {
+        return;
+    }
+    const classDeclaration = utils_1.ASTUtils.getNearestNodeFrom(node, utils_1.ASTUtils.isClassDeclaration);
+    if (!classDeclaration) {
+        return;
+    }
+    const classDecoratorName = utils_1.ASTUtils.getAngularClassDecorator(classDeclaration);
+    if (!classDecoratorName) {
+        return;
+    }
+    for (const decorator of node.decorators) {
+        validateDecorator(context, decorator, classDecoratorName);
+    }
+}
+function validateDecorator(context, decorator, classDecoratorName) {
+    const decoratorName = utils_1.ASTUtils.getDecoratorName(decorator);
+    if (!decoratorName || !utils_1.ASTUtils.isAngularInnerClassDecorator(decoratorName)) {
+        return;
+    }
+    const allowedDecorators = utils_1.ASTUtils.ANGULAR_CLASS_DECORATOR_MAPPER.get(classDecoratorName);
+    if (allowedDecorators?.has(decoratorName)) {
+        return;
+    }
+    context.report({
+        node: decorator,
+        messageId: 'contextualDecorator',
+        data: { classDecoratorName },
+    });
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `Angular decorators like @Input(), @Output(), @ViewChild(), and @HostBinding() are only meaningful in specific class types. For example, @Input() and @Output() only work in @Component or @Directive classes because they define the component/directive's API. Using these decorators in @Injectable() classes or @Pipe() classes will not work as expected, as Angular does not process these decorators in those contexts. This rule prevents bugs by ensuring decorators are only used where Angular will recognize and process them.`,
+};

package/dist/rules/contextual-lifecycle.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'contextualLifecycle';
+export declare const RULE_NAME = "contextual-lifecycle";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"contextualLifecycle", [], 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=contextual-lifecycle.d.ts.map

package/dist/rules/contextual-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextual-lifecycle.d.ts","sourceRoot":"","sources":["../../src/rules/contextual-lifecycle.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,qBAAqB,CAAC;AAC/C,eAAO,MAAM,SAAS,yBAAyB,CAAC;;;;AAEhD,wBA8DG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/contextual-lifecycle.js

@@ -0,0 +1,61 @@
+"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 = 'contextual-lifecycle';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensures that lifecycle methods are used in a correct context',
+            recommended: 'recommended',
+        },
+        schema: [],
+        messages: {
+            contextualLifecycle: `Angular will not invoke the \`{{methodName}}\` lifecycle method within \`@{{classDecoratorName}}()\` classes`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function checkContext({ parent }, decorator) {
+            const classDeclaration = parent;
+            const allowedMethods = utils_1.ASTUtils.ANGULAR_CLASS_DECORATOR_LIFECYCLE_METHOD_MAPPER.get(decorator);
+            const declaredMethods = utils_1.ASTUtils.getDeclaredMethods(classDeclaration);
+            for (const method of declaredMethods) {
+                const methodName = utils_1.ASTUtils.getMethodName(method);
+                if (!methodName ||
+                    !utils_1.ASTUtils.isAngularLifecycleMethod(methodName) ||
+                    allowedMethods?.has(methodName)) {
+                    continue;
+                }
+                context.report({
+                    node: method.key,
+                    messageId: 'contextualLifecycle',
+                    data: { classDecoratorName: decorator, methodName },
+                });
+            }
+        }
+        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);
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `Angular lifecycle hooks are only invoked for specific class types. For example, ngOnInit(), ngOnChanges(), and ngOnDestroy() are only called for components and directives, not for services (@Injectable), pipes (@Pipe), or modules (@NgModule). Defining these lifecycle methods in the wrong class type gives a false impression that they will be called, leading to bugs where initialization or cleanup logic never executes. This rule ensures lifecycle methods are only used where Angular will actually invoke them.`,
+};

package/dist/rules/directive-class-suffix.d.ts

@@ -0,0 +1,13 @@
+export type Options = [{
+    readonly suffixes: readonly string[];
+}];
+export type MessageIds = 'directiveClassSuffix';
+export declare const RULE_NAME = "directive-class-suffix";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"directiveClassSuffix", 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=directive-class-suffix.d.ts.map

package/dist/rules/directive-class-suffix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directive-class-suffix.d.ts","sourceRoot":"","sources":["../../src/rules/directive-class-suffix.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,OAAO,GAAG,CAAC;IAAE,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC;AACjE,MAAM,MAAM,UAAU,GAAG,sBAAsB,CAAC;AAChD,eAAO,MAAM,SAAS,2BAA2B,CAAC;;;;AAIlD,wBA4DG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/directive-class-suffix.js

@@ -0,0 +1,60 @@
+"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 = 'directive-class-suffix';
+const DEFAULT_SUFFIXES = ['Directive'];
+const VALIDATOR_SUFFIX = 'Validator';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Classes decorated with @Directive must have suffix "Directive" (or custom) in their name. Note: As of v20, this is no longer recommended by the Angular Team.`,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    suffixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            directiveClassSuffix: `Directive class names should end with one of these suffixes: {{suffixes}}`,
+        },
+    },
+    defaultOptions: [{ suffixes: DEFAULT_SUFFIXES }],
+    create(context, [{ suffixes }]) {
+        return {
+            [utils_1.Selectors.DIRECTIVE_CLASS_DECORATOR](node) {
+                const selectorPropertyValue = utils_1.ASTUtils.getDecoratorPropertyValue(node, 'selector');
+                if (!selectorPropertyValue)
+                    return;
+                const classParent = node.parent;
+                const className = utils_1.ASTUtils.getClassName(classParent);
+                const declaredInterfaceNames = utils_1.ASTUtils.getDeclaredInterfaceNames(classParent);
+                const hasValidatorInterface = declaredInterfaceNames.some((interfaceName) => interfaceName.endsWith(VALIDATOR_SUFFIX));
+                const allSuffixes = suffixes.concat(hasValidatorInterface ? VALIDATOR_SUFFIX : []);
+                if (!className ||
+                    !allSuffixes.some((suffix) => className.endsWith(suffix))) {
+                    context.report({
+                        node: classParent.id ?? classParent,
+                        messageId: 'directiveClassSuffix',
+                        data: { suffixes: (0, utils_1.toHumanReadableText)(allSuffixes) },
+                    });
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Historically, appending 'Directive' to directive class names was recommended to distinguish directives from other classes. However, as of Angular v20, the Angular Team no longer recommends this convention, favoring simpler class names. This rule remains available for teams that have established this naming pattern and wish to maintain consistency in their existing codebase.",
+};

package/dist/rules/directive-selector.d.ts

@@ -0,0 +1,14 @@
+import { SelectorUtils } from '@angular-eslint/utils';
+export type Options = readonly [
+    SelectorUtils.SingleConfigOption | SelectorUtils.MultipleConfigOption
+];
+export type MessageIds = 'prefixFailure' | 'styleFailure' | 'typeFailure' | 'selectorAfterPrefixFailure';
+export declare const RULE_NAME = "directive-selector";
+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=directive-selector.d.ts.map

package/dist/rules/directive-selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directive-selector.d.ts","sourceRoot":"","sources":["../../src/rules/directive-selector.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,aAAa,EACd,MAAM,uBAAuB,CAAC;AAI/B,MAAM,MAAM,OAAO,GAAG,SAAS;IAC7B,aAAa,CAAC,kBAAkB,GAAG,aAAa,CAAC,oBAAoB;CACtE,CAAC;AACF,MAAM,MAAM,UAAU,GAClB,eAAe,GACf,cAAc,GACd,aAAa,GACb,4BAA4B,CAAC;AACjC,eAAO,MAAM,SAAS,uBAAuB,CAAC;;;;AAE9C,wBA6KG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/directive-selector.js

@@ -0,0 +1,156 @@
+"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 = 'directive-selector';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Directive selectors should follow given naming rules. See more at https://angular.dev/style-guide#choosing-directive-selectors.',
+        },
+        schema: [
+            {
+                oneOf: [
+                    // Single config object
+                    {
+                        type: 'object',
+                        properties: {
+                            type: {
+                                oneOf: [
+                                    { type: 'string' },
+                                    {
+                                        type: 'array',
+                                        items: {
+                                            type: 'string',
+                                            enum: [
+                                                utils_1.SelectorUtils.OPTION_TYPE_ELEMENT,
+                                                utils_1.SelectorUtils.OPTION_TYPE_ATTRIBUTE,
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                            prefix: {
+                                oneOf: [{ type: 'string' }, { type: 'array' }],
+                            },
+                            style: {
+                                type: 'string',
+                                enum: [
+                                    utils_1.ASTUtils.OPTION_STYLE_CAMEL_CASE,
+                                    utils_1.ASTUtils.OPTION_STYLE_KEBAB_CASE,
+                                ],
+                            },
+                        },
+                        required: ['type', 'style'],
+                        additionalProperties: false,
+                    },
+                    // Array of 1-2 config objects
+                    {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                type: {
+                                    type: 'string',
+                                    enum: [
+                                        utils_1.SelectorUtils.OPTION_TYPE_ELEMENT,
+                                        utils_1.SelectorUtils.OPTION_TYPE_ATTRIBUTE,
+                                    ],
+                                },
+                                prefix: {
+                                    oneOf: [{ type: 'string' }, { type: 'array' }],
+                                },
+                                style: {
+                                    type: 'string',
+                                    enum: [
+                                        utils_1.ASTUtils.OPTION_STYLE_CAMEL_CASE,
+                                        utils_1.ASTUtils.OPTION_STYLE_KEBAB_CASE,
+                                    ],
+                                },
+                            },
+                            additionalProperties: false,
+                            required: ['type', 'style'],
+                        },
+                        minItems: 1,
+                        maxItems: 2,
+                    },
+                ],
+            },
+        ],
+        messages: {
+            prefixFailure: 'The selector should start with one of these prefixes: {{prefix}}',
+            styleFailure: 'The selector should be {{style}}',
+            typeFailure: 'The selector should be used as an {{type}}',
+            selectorAfterPrefixFailure: `There should be a selector after the {{prefix}} prefix`,
+        },
+    },
+    defaultOptions: [
+        {
+            type: undefined,
+            prefix: 'app', // Match default Angular CLI prefix
+            style: undefined,
+        },
+    ],
+    create(context, [options]) {
+        // Options are required by schema, so if undefined, ESLint will throw an error
+        if (!options) {
+            return {};
+        }
+        // Normalize options to a consistent format using shared utility
+        const configByType = utils_1.SelectorUtils.normalizeOptionsToConfigs(options);
+        return {
+            [utils_1.Selectors.DIRECTIVE_CLASS_DECORATOR](node) {
+                const rawSelectors = utils_1.ASTUtils.getDecoratorPropertyValue(node, 'selector');
+                if (!rawSelectors) {
+                    return;
+                }
+                // Parse selectors once for reuse
+                const parsedSelectors = utils_1.SelectorUtils.parseSelectorNode(rawSelectors);
+                if (!parsedSelectors || parsedSelectors.length === 0) {
+                    return;
+                }
+                const applicableConfig = utils_1.SelectorUtils.getApplicableConfig(rawSelectors, configByType);
+                if (!applicableConfig) {
+                    return;
+                }
+                const { type, prefix, style } = applicableConfig;
+                const isValidOptions = utils_1.SelectorUtils.checkValidOptions(type, prefix, style);
+                if (!isValidOptions) {
+                    return;
+                }
+                const hasExpectedSelector = utils_1.SelectorUtils.checkSelector(rawSelectors, type, prefix, style, parsedSelectors);
+                if (hasExpectedSelector === null) {
+                    return;
+                }
+                // Directive-specific validation logic (simpler than component)
+                if (!hasExpectedSelector.hasExpectedType) {
+                    utils_1.SelectorUtils.reportTypeError(rawSelectors, type, context);
+                }
+                else if (!hasExpectedSelector.hasSelectorAfterPrefix) {
+                    // Only report selector after prefix error if prefix is actually required
+                    if (prefix !== undefined) {
+                        utils_1.SelectorUtils.reportSelectorAfterPrefixError(rawSelectors, prefix, context);
+                    }
+                }
+                else if (!hasExpectedSelector.hasExpectedStyle) {
+                    utils_1.SelectorUtils.reportStyleError(rawSelectors, style, context);
+                }
+                else if (!hasExpectedSelector.hasExpectedPrefix) {
+                    // Only report prefix error if prefix is actually required (not empty)
+                    if (prefix !== undefined) {
+                        const prefixArray = (0, utils_1.arrayify)(prefix);
+                        if (prefixArray.length > 0) {
+                            utils_1.SelectorUtils.reportPrefixError(rawSelectors, prefix, context);
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Consistent directive selector naming conventions help identify which directives belong to your application versus third-party libraries, prevent naming collisions with native HTML attributes and other directives, and make code reviews and debugging easier. For example, using a camelCase attribute selector with a prefix like 'appHighlight' makes it immediately clear that this is a custom directive from your application.",
+};

package/dist/rules/no-async-lifecycle-method.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noAsyncLifecycleMethod';
+export declare const RULE_NAME = "no-async-lifecycle-method";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noAsyncLifecycleMethod", [], 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=no-async-lifecycle-method.d.ts.map

package/dist/rules/no-async-lifecycle-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-async-lifecycle-method.d.ts","sourceRoot":"","sources":["../../src/rules/no-async-lifecycle-method.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,wBAAwB,CAAC;AAClD,eAAO,MAAM,SAAS,8BAA8B,CAAC;;;;AAErD,wBAyCG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/no-async-lifecycle-method.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("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-async-lifecycle-method';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Angular Lifecycle methods should not be async. Angular does not wait for async lifecycle but the code incorrectly suggests it does.`,
+        },
+        schema: [],
+        messages: {
+            noAsyncLifecycleMethod: 'Angular Lifecycle method should not be async',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const angularDecoratorsPattern = (0, utils_1.toPattern)([
+            'Component',
+            'Directive',
+            'Injectable',
+            'NgModule',
+            'Pipe',
+        ]);
+        const angularLifecycleMethodsPattern = (0, utils_1.toPattern)([
+            ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,
+        ]);
+        return {
+            [`${utils_1.Selectors.decoratorDefinition(angularDecoratorsPattern)} > ClassBody > MethodDefinition[key.name=${angularLifecycleMethodsPattern}]`](node) {
+                if (node.value.async === true) {
+                    context.report({
+                        node: node.key,
+                        messageId: 'noAsyncLifecycleMethod',
+                    });
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Angular does not wait for async lifecycle methods to complete before continuing with the component lifecycle. If you make ngOnInit() async, Angular will call it and immediately move on without waiting for any await statements inside to resolve. This creates a misleading code pattern where it appears Angular will wait for asynchronous operations to complete, but it won't. For example, if ngOnInit() fetches data asynchronously, the component will continue rendering with potentially incomplete data. Instead of making lifecycle methods async, call async functions from within them and handle the promises appropriately, or use Angular patterns like resolvers, signals with async pipes, or reactive approaches with RxJS.",
+};

package/dist/rules/no-attribute-decorator.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noAttributeDecorator';
+export declare const RULE_NAME = "no-attribute-decorator";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noAttributeDecorator", [], 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=no-attribute-decorator.d.ts.map

package/dist/rules/no-attribute-decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-attribute-decorator.d.ts","sourceRoot":"","sources":["../../src/rules/no-attribute-decorator.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,sBAAsB,CAAC;AAChD,eAAO,MAAM,SAAS,2BAA2B,CAAC;;;;AAElD,wBA0BG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/no-attribute-decorator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-attribute-decorator';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `The @Attribute decorator is used to obtain a single value for an attribute. This is a much less common use case than getting a stream of values (using @Input), so the @Attribute decorator is often mistakenly used when @Input is intended. This rule disallows the usage of @Attribute decorator entirely to prevent these mistakes.`,
+        },
+        schema: [],
+        messages: {
+            noAttributeDecorator: '@Attribute can only obtain a single value and is rarely what is required. Use @Input instead to retrieve a stream of values.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            'ClassDeclaration MethodDefinition[key.name="constructor"] Decorator[expression.callee.name="Attribute"]'(node) {
+                context.report({
+                    node,
+                    messageId: 'noAttributeDecorator',
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: 'The @Attribute decorator is frequently misunderstood and misused. Unlike @Input(), which creates a binding that updates when the input value changes, @Attribute reads the attribute value only once during component construction and never updates. This single-read behavior is rarely what developers intend when they want to receive data from a parent component. In almost all cases, @Input() is the correct choice because it provides reactive updates. The @Attribute decorator is only appropriate for very specific optimization scenarios where you know the value will never change and want to avoid the overhead of change detection for that property. To prevent bugs from this common mistake, this rule disallows @Attribute entirely and encourages using @Input() instead, or modern signal-based inputs via input().',
+};

package/dist/rules/no-conflicting-lifecycle.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noConflictingLifecycleInterface' | 'noConflictingLifecycleMethod';
+export declare const RULE_NAME = "no-conflicting-lifecycle";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], 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=no-conflicting-lifecycle.d.ts.map

package/dist/rules/no-conflicting-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-conflicting-lifecycle.d.ts","sourceRoot":"","sources":["../../src/rules/no-conflicting-lifecycle.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAClB,iCAAiC,GACjC,8BAA8B,CAAC;AACnC,eAAO,MAAM,SAAS,6BAA6B,CAAC;;;;AAWpD,wBA8EG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/no-conflicting-lifecycle.js

@@ -0,0 +1,74 @@
+"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 utils_2 = require("@typescript-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-conflicting-lifecycle';
+const LIFECYCLE_INTERFACES = [
+    utils_1.ASTUtils.AngularLifecycleInterfaces.DoCheck,
+    utils_1.ASTUtils.AngularLifecycleInterfaces.OnChanges,
+];
+const LIFECYCLE_METHODS = [
+    utils_1.ASTUtils.AngularLifecycleMethods.ngDoCheck,
+    utils_1.ASTUtils.AngularLifecycleMethods.ngOnChanges,
+];
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        deprecated: true,
+        docs: {
+            description: 'Ensures that directives do not implement conflicting lifecycle interfaces.',
+        },
+        schema: [],
+        messages: {
+            noConflictingLifecycleInterface: `Implementing ${utils_1.ASTUtils.AngularLifecycleInterfaces.DoCheck} and ${utils_1.ASTUtils.AngularLifecycleInterfaces.OnChanges} in a class is not recommended`,
+            noConflictingLifecycleMethod: `Declaring ${utils_1.ASTUtils.AngularLifecycleMethods.ngDoCheck} and ${utils_1.ASTUtils.AngularLifecycleMethods.ngOnChanges} method in a class is not recommended`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const validateInterfaces = (node) => {
+            const declaredAngularLifecycleInterfaces = utils_1.ASTUtils.getDeclaredAngularLifecycleInterfaces(node);
+            const hasInterfaceConflictingLifecycle = LIFECYCLE_INTERFACES.every((lifecycleInterface) => declaredAngularLifecycleInterfaces.includes(lifecycleInterface));
+            if (!hasInterfaceConflictingLifecycle)
+                return;
+            const declaredInterfaces = utils_1.ASTUtils.getInterfaces(node);
+            const declaredAngularLifecycleInterfacesNodes = declaredInterfaces.filter((node) => {
+                const interfaceName = utils_1.ASTUtils.getInterfaceName(node);
+                return (interfaceName && utils_1.ASTUtils.isAngularLifecycleInterface(interfaceName));
+            });
+            for (const interFaceNode of declaredAngularLifecycleInterfacesNodes) {
+                context.report({
+                    node: interFaceNode,
+                    messageId: 'noConflictingLifecycleInterface',
+                });
+            }
+        };
+        const validateMethods = (node) => {
+            const declaredAngularLifecycleMethods = utils_1.ASTUtils.getDeclaredAngularLifecycleMethods(node);
+            const hasMethodConflictingLifecycle = LIFECYCLE_METHODS.every((lifecycleMethod) => declaredAngularLifecycleMethods.includes(lifecycleMethod));
+            if (!hasMethodConflictingLifecycle)
+                return;
+            const declaredMethods = utils_1.ASTUtils.getDeclaredMethods(node);
+            const declaredAngularLifecycleMethodNodes = declaredMethods.filter((node) => utils_2.ASTUtils.isIdentifier(node.key) &&
+                utils_1.ASTUtils.isAngularLifecycleMethod(node.key.name));
+            for (const method of declaredAngularLifecycleMethodNodes) {
+                context.report({
+                    node: method,
+                    messageId: 'noConflictingLifecycleMethod',
+                });
+            }
+        };
+        return {
+            ClassDeclaration(node) {
+                validateInterfaces(node);
+                validateMethods(node);
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: 'This rule was created with the intent to prevent potential issues when both DoCheck and OnChanges lifecycle hooks are implemented together, as they both deal with change detection and could create confusing or duplicated logic. However, the rule has proven to be overly broad in practice. It triggers whenever a component or directive implements both hooks, regardless of whether they actually conflict or track the same data. In reality, there are legitimate use cases where both hooks can coexist without issues—for instance, using OnChanges to respond to specific input changes while using DoCheck for custom change detection logic on different data. Because the rule cannot accurately determine whether the hooks are actually conflicting (i.e., checking the same variables), it produces false positives and has been removed from the recommended configuration. While the rule was well-intentioned, it should not be relied upon in practice.',
+};

package/dist/rules/no-developer-preview.d.ts

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

package/dist/rules/no-developer-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-developer-preview.d.ts","sourceRoot":"","sources":["../../src/rules/no-developer-preview.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,oBAAoB,CAAC;AAC9C,eAAO,MAAM,SAAS,yBAAyB,CAAC;;;;AAEhD,wBAsCG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}