angular-eslint-zoneless 1.0.2

package/LICENSE

@@ -0,0 +1,20 @@
+The MIT License
+
+Copyright (c) 2026 Cyrille Tuzi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# angular-eslint-zoneless
+
+ESLint rules for Angular zoneless.
+
+**Checks that a zoneless application does not use zone.js-based features and that signals/resources patterns are used, for example:**
+- no zone.js import and provider
+- no zone.js testing functions like `fakeAsync()`
+- no `ChangeDectectionStrategy.Eager`
+- no `NgZone`
+- no `@Input()` and other decorators, to enforce `input()` and other signal equivalents
+- no `ngOnInit()` and other component lifecycle methods, to enforce using signals and resources patterns
+
+[The documentation is available on GitHub.](https://github.com/cyrilletuzi/angular-eslint-zoneless)

package/index.d.ts

@@ -0,0 +1,32 @@
+import type { ConfigObject } from "@eslint/core";
+declare const plugin: {
+    configs: {
+        readonly recommended: ConfigObject<import("@eslint/core").RulesConfig>;
+    };
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        "no-zonejs-import": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-providezonechangedetection": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-eager-change-detection": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-ngoninit": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-ngdocheck": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-ngonchanges": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-ngaftercontentinit": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-ngaftercontentchecked": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-ngafterviewinit": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-ngafterviewchecked": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-ngondestroy": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-input-decorator": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-output-decorator": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-content-decorator": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-view-decorator": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-ngzone": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-detectchanges-testing": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-zonejs-testing-functions": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+        "no-subscribe-in-component-constructor": import("@eslint/core").RuleDefinition<import("@eslint/core").RuleDefinitionTypeOptions>;
+    };
+};
+export = plugin;

package/index.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+const noContentDecorator = __importStar(require("./rules/no-content-decorator.js"));
+const noDetectchangesTesting = __importStar(require("./rules/no-detectchanges-testing.js"));
+const noEagerChangeDetection = __importStar(require("./rules/no-eager-change-detection.js"));
+const noInputDecorator = __importStar(require("./rules/no-input-decorator.js"));
+const noNgaftercontentchecked = __importStar(require("./rules/no-ngaftercontentchecked.js"));
+const noNgaftercontentinit = __importStar(require("./rules/no-ngaftercontentinit.js"));
+const noNgafterviewchecked = __importStar(require("./rules/no-ngafterviewchecked.js"));
+const noNgafterviewinit = __importStar(require("./rules/no-ngafterviewinit.js"));
+const noNgdocheck = __importStar(require("./rules/no-ngdocheck.js"));
+const noNgonchanges = __importStar(require("./rules/no-ngonchanges.js"));
+const noNgondestroy = __importStar(require("./rules/no-ngondestroy.js"));
+const noNgoninit = __importStar(require("./rules/no-ngoninit.js"));
+const noNgzone = __importStar(require("./rules/no-ngzone.js"));
+const noOutputDecorator = __importStar(require("./rules/no-output-decorator.js"));
+const noProvidezonechangedetection = __importStar(require("./rules/no-providezonechangedetection.js"));
+const noSubscribeInComponentConstructor = __importStar(require("./rules/no-subscribe-in-component-constructor.js"));
+const noViewDecorator = __importStar(require("./rules/no-view-decorator.js"));
+const noZonejsImport = __importStar(require("./rules/no-zonejs-import.js"));
+const noZonejsTestingFunctions = __importStar(require("./rules/no-zonejs-testing-functions.js"));
+const { name, version } = 
+// importing here would bypass the tsconfig `"rootDir": "src"`
+require("./package.json");
+const plugin = {
+    configs: {
+        get recommended() {
+            return recommended;
+        }
+    },
+    meta: { name, version },
+    rules: {
+        [noZonejsImport.ruleName]: noZonejsImport.ruleDefinition,
+        [noProvidezonechangedetection.ruleName]: noProvidezonechangedetection.ruleDefinition,
+        [noEagerChangeDetection.ruleName]: noEagerChangeDetection.ruleDefinition,
+        [noNgoninit.ruleName]: noNgoninit.ruleDefinition,
+        [noNgdocheck.ruleName]: noNgdocheck.ruleDefinition,
+        [noNgonchanges.ruleName]: noNgonchanges.ruleDefinition,
+        [noNgaftercontentinit.ruleName]: noNgaftercontentinit.ruleDefinition,
+        [noNgaftercontentchecked.ruleName]: noNgaftercontentchecked.ruleDefinition,
+        [noNgafterviewinit.ruleName]: noNgafterviewinit.ruleDefinition,
+        [noNgafterviewchecked.ruleName]: noNgafterviewchecked.ruleDefinition,
+        [noNgondestroy.ruleName]: noNgondestroy.ruleDefinition,
+        [noInputDecorator.ruleName]: noInputDecorator.ruleDefinition,
+        [noOutputDecorator.ruleName]: noOutputDecorator.ruleDefinition,
+        [noContentDecorator.ruleName]: noContentDecorator.ruleDefinition,
+        [noViewDecorator.ruleName]: noViewDecorator.ruleDefinition,
+        [noNgzone.ruleName]: noNgzone.ruleDefinition,
+        [noDetectchangesTesting.ruleName]: noDetectchangesTesting.ruleDefinition,
+        [noZonejsTestingFunctions.ruleName]: noZonejsTestingFunctions.ruleDefinition,
+        [noSubscribeInComponentConstructor.ruleName]: noSubscribeInComponentConstructor.ruleDefinition,
+    },
+};
+const recommended = {
+    plugins: {
+        [name]: plugin
+    },
+    rules: {
+        [`${name}/${noZonejsImport.ruleName}`]: "error",
+        [`${name}/${noProvidezonechangedetection.ruleName}`]: "error",
+        [`${name}/${noEagerChangeDetection.ruleName}`]: "error",
+        [`${name}/${noNgoninit.ruleName}`]: "error",
+        [`${name}/${noNgdocheck.ruleName}`]: "error",
+        [`${name}/${noNgonchanges.ruleName}`]: "error",
+        [`${name}/${noNgaftercontentinit.ruleName}`]: "error",
+        [`${name}/${noNgaftercontentchecked.ruleName}`]: "error",
+        [`${name}/${noNgafterviewinit.ruleName}`]: "error",
+        [`${name}/${noNgafterviewchecked.ruleName}`]: "error",
+        [`${name}/${noNgondestroy.ruleName}`]: "error",
+        [`${name}/${noInputDecorator.ruleName}`]: "error",
+        [`${name}/${noOutputDecorator.ruleName}`]: "error",
+        [`${name}/${noContentDecorator.ruleName}`]: "error",
+        [`${name}/${noViewDecorator.ruleName}`]: "error",
+        [`${name}/${noNgzone.ruleName}`]: "error",
+        [`${name}/${noDetectchangesTesting.ruleName}`]: "error",
+        [`${name}/${noZonejsTestingFunctions.ruleName}`]: "error",
+    },
+};
+module.exports = plugin;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "angular-eslint-zoneless",
+  "version": "1.0.2",
+  "description": "Angular zoneless lint rules for ESLint",
+  "keywords": [
+    "angular",
+    "eslint"
+  ],
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/cyrilletuzi"
+  },
+  "homepage": "https://github.com/cyrilletuzi/angular-eslint-zoneless#readme",
+  "bugs": {
+    "url": "https://github.com/cyrilletuzi/angular-eslint-zoneless/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cyrilletuzi/angular-eslint-zoneless.git"
+  },
+  "license": "MIT",
+  "author": "Cyrille Tuzi",
+  "type": "commonjs",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "peerDependencies": {
+    "@typescript-eslint/utils": "^8.0.0"
+  }
+}

package/rules/no-content-decorator.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-content-decorator";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-content-decorator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-content-decorator";
+const messageId = "noContentDecorator";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ContentChild()\` and \`ContentChildren()\` should not be used in a zoneless application, use \`contentChild()\` and \`contentChildren()\` instead.`,
+        },
+        docs: {
+            description: `Checks that \`ContentChild()\` and \`ContentChildren()\` are not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_CONTENT_DECORATOR.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            Decorator(node) {
+                if (node.expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    node.expression.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (node.expression.callee.name === "ContentChild" ||
+                        node.expression.callee.name === "ContentChildren")) {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-detectchanges-testing.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-detectchanges-testing";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-detectchanges-testing.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const angular_class_decorator_1 = require("../utils/angular-class-decorator");
+exports.ruleName = "no-detectchanges-testing";
+const messageId = "noDetectchangesTesting";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`fixture.detectChanges()\` should be avoided in a zoneless application, use \`await fixture.whenStable()\` instead.`,
+        },
+        docs: {
+            description: `Checks that \`fixture.detectChanges()\` is not called.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_DETECTCHANGES_TESTING.md',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === "detectChanges" &&
+                    // Report only in tests, otherwise it will report on `ChangeDetectorRef.detectChanges()`
+                    !(0, angular_class_decorator_1.isInAngularClass)(node, ["Component", "Directive"])) {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-eager-change-detection.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-eager-change-detection";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-eager-change-detection.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-eager-change-detection";
+const messageId = "noEagerChangeDetection";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ChangeDetectionStrategy.Eager\` and \`ChangeDetectionStrategy.Default\` should not be used in a zoneless application, use \`ChangeDetectionStrategy.OnPush\` instead (the default in Angular >= 22).`,
+        },
+        docs: {
+            description: `Checks that \`ChangeDetectionStrategy.Eager\` and \`ChangeDetectionStrategy.Default\` are not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_EAGER_CHANGE_DETECTION.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            MemberExpression(node) {
+                if (node.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.object.name === "ChangeDetectionStrategy" &&
+                    node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (node.property.name === "Eager" || node.property.name === "Default")) {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-input-decorator.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-input-decorator";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-input-decorator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-input-decorator";
+const messageId = "noInputDecorator";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`Input()\` should not be used in a zoneless application, use \`input()\` instead.`,
+        },
+        docs: {
+            description: `Checks that \`Input()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_INPUT_DECORATOR.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            Decorator(node) {
+                if (node.expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    node.expression.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.expression.callee.name === "Input") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-ngaftercontentchecked.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-ngaftercontentchecked";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-ngaftercontentchecked.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-ngaftercontentchecked";
+const messageId = "noNgaftercontentchecked";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ngAfterContentChecked()\` should be avoided in a zoneless application, use signals and resources reactivity instead.`,
+        },
+        docs: {
+            description: `Checks that \`ngAfterContentChecked()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_NGAFTERCONTENTCHECKED.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            MethodDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.key.name === "ngAfterContentChecked") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-ngaftercontentinit.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-ngaftercontentinit";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-ngaftercontentinit.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-ngaftercontentinit";
+const messageId = "noNgaftercontentinit";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ngAfterContentInit()\` should be avoided in a zoneless application, use signals and resources reactivity instead.`,
+        },
+        docs: {
+            description: `Checks that \`ngAfterContentInit()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_NGAFTERCONTENTINIT.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            MethodDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.key.name === "ngAfterContentInit") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-ngafterviewchecked.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-ngafterviewchecked";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-ngafterviewchecked.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-ngafterviewchecked";
+const messageId = "noNgafterviewchecked";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ngAfterViewChecked()\` should be avoided in a zoneless application, use signals and resources reactivity instead.`,
+        },
+        docs: {
+            description: `Checks that \`ngAfterViewChecked()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_NGAFTERVIEWCHECKED.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            MethodDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.key.name === "ngAfterViewChecked") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-ngafterviewinit.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-ngafterviewinit";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-ngafterviewinit.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-ngafterviewinit";
+const messageId = "noNgafterviewinit";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ngAfterViewInit()\` should be avoided in a zoneless application, use signals and resources reactivity instead, or when really needed, use \`afterNextRender()\`.`,
+        },
+        docs: {
+            description: `Checks that \`ngAfterViewInit()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_NGAFTERVIEWINIT.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            MethodDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.key.name === "ngAfterViewInit") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-ngdocheck.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-ngdocheck";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-ngdocheck.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-ngdocheck";
+const messageId = "noNgdocheck";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ngDoCheck()\` should be avoided in a zoneless application, use signals and resources reactivity instead.`,
+        },
+        docs: {
+            description: `Checks that \`ngDoCheck()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_NGDOCHECK.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            MethodDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.key.name === "ngDoCheck") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-ngonchanges.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-ngonchanges";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-ngonchanges.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-ngonchanges";
+const messageId = "noNgonchanges";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ngOnChanges()\` should be avoided in a zoneless application, use signals and resources reactivity instead.`,
+        },
+        docs: {
+            description: `Checks that \`ngOnChanges()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_NGONCHANGES.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            MethodDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.key.name === "ngOnChanges") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-ngondestroy.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-ngondestroy";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-ngondestroy.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-ngondestroy";
+const messageId = "noNgondestroy";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ngOnDestroy()\` should be avoided in a zoneless application, signals and resources destroy is automatic; if really needed, use \`DestroyRef.onDestroy()\`.`,
+        },
+        docs: {
+            description: `Checks that \`ngOnDestroy()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_NGONDESTROY.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            MethodDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.key.name === "ngOnDestroy") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-ngoninit.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-ngoninit";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-ngoninit.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-ngoninit";
+const messageId = "noNgoninit";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ngOnInit()\` should be avoided in a zoneless application, use signals and resources reactivity instead.`,
+        },
+        docs: {
+            description: `Checks that \`ngOnInit()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_NGONINIT.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            MethodDefinition(node) {
+                if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.key.name === "ngOnInit") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-ngzone.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-ngzone";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-ngzone.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+exports.ruleName = "no-ngzone";
+const messageId = "noNgzone";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`NgZone()\` is useless and does not work in a zoneless application.`,
+        },
+        docs: {
+            description: `Checks that \`NgZone()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_NGZONE.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            Identifier(node) {
+                if (node.name === 'NgZone') {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-output-decorator.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-output-decorator";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-output-decorator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-output-decorator";
+const messageId = "noOutputDecorator";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`Output()\` should not be used in a zoneless application, use \`output()\` instead.`,
+        },
+        docs: {
+            description: `Checks that \`Output()\` is not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_OUTPUT_DECORATOR.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            Decorator(node) {
+                if (node.expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    node.expression.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.expression.callee.name === "Output") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-providezonechangedetection.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-providezonechangedetection";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-providezonechangedetection.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-providezonechangedetection";
+const messageId = "noProvidezonechangedetection";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`provideZoneChangeDetection()\` is forbidden in a zoneless application.`,
+        },
+        docs: {
+            description: `Checks that \`provideZoneChangeDetection()\` is not called.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_PROVIDEZONECHANGEDETECTION.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.name === "provideZoneChangeDetection") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-subscribe-in-component-constructor.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-subscribe-in-component-constructor";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-subscribe-in-component-constructor.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const in_constructor_1 = require("../utils/in-constructor");
+exports.ruleName = "no-subscribe-in-component-constructor";
+const messageId = "noSubscribeInComponentConstructor";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `An observable inside a component constructor can generally be managed with \`toSignal()\` or \`rxResource()\` instead.`,
+        },
+        docs: {
+            description: `Checks that observables are not explicitly subscribed in components constructors.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_SUBSCRIBE_IN_COMPONENT_CONSTRUCTOR.md',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'subscribe' &&
+                    (0, in_constructor_1.isInAngularComponentConstructor)(node)) {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-view-decorator.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-view-decorator";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-view-decorator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-view-decorator";
+const messageId = "noViewDecorator";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `\`ViewChild()\` and \`ViewChildren()\` should not be used in a zoneless application, use \`viewChild()\` and \`viewChildren()\` instead.`,
+        },
+        docs: {
+            description: `Checks that \`ViewChild()\` and \`ViewChildren()\` are not used.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_VIEW_DECORATOR.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            Decorator(node) {
+                if (node.expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    node.expression.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (node.expression.callee.name === "ViewChild" ||
+                        node.expression.callee.name === "ViewChildren")) {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-zonejs-import.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-zonejs-import";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-zonejs-import.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+exports.ruleName = "no-zonejs-import";
+const messageId = "noZonejsImport";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `Importing zone.js is forbidden in a zoneless application.`,
+        },
+        docs: {
+            description: `Checks that \`zone.js\` is not imported.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_ZONEJS_IMPORT.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === "zone.js") {
+                    context.report({
+                        node,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+};

package/rules/no-zonejs-testing-functions.d.ts

@@ -0,0 +1,3 @@
+import type { RuleDefinition } from "@eslint/core";
+export declare const ruleName = "no-zonejs-testing-functions";
+export declare const ruleDefinition: RuleDefinition;

package/rules/no-zonejs-testing-functions.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleDefinition = exports.ruleName = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+exports.ruleName = "no-zonejs-testing-functions";
+const messageId = "noZonejsTestingFunctions";
+exports.ruleDefinition = {
+    meta: {
+        type: "problem",
+        messages: {
+            [messageId]: `zone.js testing functions (\`fakeAsync()\`, \`discardPeriodicTasks()\`, \`flush()\`, \`flushMicrotasks()\`, \`resetFakeAsyncZone()\`, \`tick()\`, \`waitForAsync()\`) are useless and do not work in a zoneless application.`,
+        },
+        docs: {
+            description: `Checks that zone.js testing functions are not called.`,
+            url: 'https://github.com/cyrilletuzi/angular-eslint-zoneless/blob/main/docs/rules/NO_ZONEJS_TESTING_FUNCTIONS.md',
+            recommended: true,
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const testingFunctions = new Set([
+                        "fakeAsync",
+                        "discardPeriodicTasks",
+                        "flush",
+                        "flushMicrotasks",
+                        "resetFakeAsyncZone",
+                        "tick",
+                        "waitForAsync",
+                    ]);
+                    if (testingFunctions.has(node.callee.name)) {
+                        context.report({
+                            node,
+                            messageId,
+                        });
+                    }
+                }
+            },
+        };
+    },
+};

package/utils/angular-class-decorator.d.ts

@@ -0,0 +1,19 @@
+import { type TSESTree } from "@typescript-eslint/utils";
+export type AngularClassDecorator = "Component" | "Directive" | "Injectable" | "NgModule" | "Pipe" | "Service";
+/**
+ * Checks if a `ClassDeclaration` has an Angular decorator and returns it.
+ *
+ * @example
+ * ```typescript
+ * const classDeclaration = findNearestAncestorOf(
+ *   node,
+ *   (node) => node.type === AST_NODE_TYPES.ClassDeclaration,
+ * );
+ *
+ * if (classDeclaration && findAngularClassDecorator(classDeclaration)) {
+ *   return true;
+ * }
+ * ```
+ */
+export declare function findAngularClassDecorator({ decorators }: TSESTree.ClassDeclaration, allowedDecorators?: readonly AngularClassDecorator[]): AngularClassDecorator | undefined;
+export declare function isInAngularClass(node: TSESTree.Node, allowedDecorators?: readonly AngularClassDecorator[]): boolean;

package/utils/angular-class-decorator.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAngularClassDecorator = findAngularClassDecorator;
+exports.isInAngularClass = isInAngularClass;
+const utils_1 = require("@typescript-eslint/utils");
+const ast_traversal_1 = require("./ast-traversal");
+/**
+ * Checks if a `ClassDeclaration` has an Angular decorator and returns it.
+ *
+ * @example
+ * ```typescript
+ * const classDeclaration = findNearestAncestorOf(
+ *   node,
+ *   (node) => node.type === AST_NODE_TYPES.ClassDeclaration,
+ * );
+ *
+ * if (classDeclaration && findAngularClassDecorator(classDeclaration)) {
+ *   return true;
+ * }
+ * ```
+ */
+function findAngularClassDecorator({ decorators }, allowedDecorators = [
+    "Component", "Directive", "Injectable", "NgModule", "Pipe", "Service",
+]) {
+    const angularClassDecorators = new Set(allowedDecorators);
+    return decorators
+        ?.map(({ expression }) => {
+        if (utils_1.ASTUtils.isIdentifier(expression)) {
+            return expression.name;
+        }
+        return expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            utils_1.ASTUtils.isIdentifier(expression.callee)
+            ? expression.callee.name
+            : undefined;
+    })
+        .filter((item) => item !== undefined)
+        .find((value) => angularClassDecorators.has(value));
+}
+;
+function isInAngularClass(node, allowedDecorators) {
+    const classDeclaration = (0, ast_traversal_1.findNearestAncestorOf)(node, (node) => node.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
+    if (classDeclaration &&
+        findAngularClassDecorator(classDeclaration, allowedDecorators)) {
+        return true;
+    }
+    return false;
+}

package/utils/ast-traversal.d.ts

@@ -0,0 +1,25 @@
+import { type TSESTree } from "@typescript-eslint/utils";
+/**
+ * Get the nearest ancestor node of a certain type.
+ *
+ * @example
+ * ```typescript
+ * const classDeclaration = getNearestNodeFrom(
+ *   node,
+ *   (node) => node.type === AST_NODE_TYPES.ClassDeclaration,
+ * );
+ * ```
+ *
+ * With `notInCallback` option enabled, the traversal will stop if it encounters a `CallExpression`.
+ * This is needed for some rules because the injection context is lost when inside a callback.
+ *
+ * @example
+ * ```typescript
+ * const classDeclaration = getNearestNodeFrom(
+ *   node,
+ *   (node) => node.type === AST_NODE_TYPES.ClassDeclaration,
+ *   { notInCallback: true },
+ * );
+ * ```
+ */
+export declare function findNearestAncestorOf<T extends TSESTree.Node>({ parent }: TSESTree.Node, predicate: (parent: TSESTree.Node) => parent is T): T | undefined;

package/utils/ast-traversal.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNearestAncestorOf = findNearestAncestorOf;
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * Get the nearest ancestor node of a certain type.
+ *
+ * @example
+ * ```typescript
+ * const classDeclaration = getNearestNodeFrom(
+ *   node,
+ *   (node) => node.type === AST_NODE_TYPES.ClassDeclaration,
+ * );
+ * ```
+ *
+ * With `notInCallback` option enabled, the traversal will stop if it encounters a `CallExpression`.
+ * This is needed for some rules because the injection context is lost when inside a callback.
+ *
+ * @example
+ * ```typescript
+ * const classDeclaration = getNearestNodeFrom(
+ *   node,
+ *   (node) => node.type === AST_NODE_TYPES.ClassDeclaration,
+ *   { notInCallback: true },
+ * );
+ * ```
+ */
+function findNearestAncestorOf({ parent }, predicate) {
+    while (parent && parent.type !== utils_1.AST_NODE_TYPES.Program) {
+        if (predicate(parent)) {
+            return parent;
+        }
+        parent = parent.parent;
+    }
+    return undefined;
+}

package/utils/in-constructor.d.ts

@@ -0,0 +1,2 @@
+import { type TSESTree } from "@typescript-eslint/utils";
+export declare function isInAngularComponentConstructor(node: TSESTree.Node): boolean;

package/utils/in-constructor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInAngularComponentConstructor = isInAngularComponentConstructor;
+const utils_1 = require("@typescript-eslint/utils");
+const angular_class_decorator_1 = require("./angular-class-decorator");
+const ast_traversal_1 = require("./ast-traversal");
+function isInConstructor(node) {
+    const methodDefinition = (0, ast_traversal_1.findNearestAncestorOf)(node, (node) => node.type === utils_1.AST_NODE_TYPES.MethodDefinition);
+    if (methodDefinition?.kind === "constructor") {
+        return true;
+    }
+    return false;
+}
+function isInAngularComponentConstructor(node) {
+    if (isInConstructor(node)) {
+        const classDeclaration = (0, ast_traversal_1.findNearestAncestorOf)(node, (node) => node.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
+        if (classDeclaration &&
+            (0, angular_class_decorator_1.findAngularClassDecorator)(classDeclaration, ["Component"])) {
+            return true;
+        }
+    }
+    return false;
+}