@angular-eslint/eslint-plugin 19.1.1-alpha.1 → 19.1.1-alpha.10

package/README.md

@@ -24,6 +24,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`contextual-lifecycle`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/contextual-lifecycle.md) | Ensures that lifecycle methods are used in a correct context | :white_check_mark: |  |  |
 | [`no-async-lifecycle-method`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-async-lifecycle-method.md) | Angular Lifecycle methods should not be async. Angular does not wait for async lifecycle but the code incorrectly suggests it does. |  |  |  |
 | [`no-attribute-decorator`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/no-attribute-decorator.md) | 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 often the @Attribute decorator is mistakenly used when @Input was what was intended. This rule disallows usage of @Attribute decorator altogether in order to prevent these mistakes. |  |  |  |
+| [`require-lifecycle-on-prototype`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/require-lifecycle-on-prototype.md) | Ensures that lifecycle methods are defined on the object's prototype instead of on an instance. |  |  |  |
 | [`sort-lifecycle-methods`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/sort-lifecycle-methods.md) | Ensures that lifecycle methods are declared in order of execution |  |  |  |
 <!-- prettier-ignore-end -->
 

package/dist/configs/all.json

@@ -32,6 +32,7 @@
     "@angular-eslint/prefer-signals": "error",
     "@angular-eslint/prefer-standalone": "error",
     "@angular-eslint/relative-url-prefix": "error",
+    "@angular-eslint/require-lifecycle-on-prototype": "error",
     "@angular-eslint/require-localize-metadata": "error",
     "@angular-eslint/runtime-localize": "error",
     "@angular-eslint/sort-lifecycle-methods": "error",

package/dist/index.d.ts

@@ -34,6 +34,7 @@ declare const _default: {
                 "@angular-eslint/prefer-signals": string;
                 "@angular-eslint/prefer-standalone": string;
                 "@angular-eslint/relative-url-prefix": string;
+                "@angular-eslint/require-lifecycle-on-prototype": string;
                 "@angular-eslint/require-localize-metadata": string;
                 "@angular-eslint/runtime-localize": string;
                 "@angular-eslint/sort-lifecycle-methods": string;
@@ -101,6 +102,7 @@ declare const _default: {
         "prefer-standalone": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferStandalone", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-output-readonly": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-output-readonly").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "relative-url-prefix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"relativeUrlPrefix", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "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-lifecycle-methods": import("@typescript-eslint/utils/ts-eslint").RuleModule<"lifecycleMethodsNotSorted", [], 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsHA,kBA8CE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyHA,kBA+CE"}

package/dist/index.js

@@ -56,6 +56,7 @@ const prefer_output_readonly_1 = __importStar(require("./rules/prefer-output-rea
 const prefer_signals_1 = __importStar(require("./rules/prefer-signals"));
 const prefer_standalone_1 = __importStar(require("./rules/prefer-standalone"));
 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_lifecycle_methods_1 = __importStar(require("./rules/sort-lifecycle-methods"));
@@ -101,6 +102,7 @@ module.exports = {
         [prefer_standalone_1.RULE_NAME]: prefer_standalone_1.default,
         [prefer_output_readonly_1.RULE_NAME]: prefer_output_readonly_1.default,
         [relative_url_prefix_1.RULE_NAME]: relative_url_prefix_1.default,
+        [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_lifecycle_methods_1.RULE_NAME]: sort_lifecycle_methods_1.default,

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

@@ -0,0 +1,6 @@
+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>;
+export default _default;
+//# 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"}

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "19.1.1-alpha.1",
+  "version": "19.1.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.1.1-alpha.1",
-    "@angular-eslint/utils": "19.1.1-alpha.1"
+    "@angular-eslint/bundled-angular-compiler": "19.1.1-alpha.10",
+    "@angular-eslint/utils": "19.1.1-alpha.10"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "19.1.1-alpha.1"
+    "@angular-eslint/test-utils": "19.1.1-alpha.10"
   },
   "peerDependencies": {
     "@typescript-eslint/utils": "^7.11.0 || ^8.0.0",