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

package/dist/rules/prefer-inject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-inject.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-inject.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,MAAM,MAAM,UAAU,GAAG,cAAc,CAAC;AACxC,eAAO,MAAM,SAAS,kBAAkB,CAAC;;;;AAEzC,wBAkGG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/prefer-inject.js

@@ -0,0 +1,86 @@
+"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 = 'prefer-inject';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer using the inject() function over constructor parameter injection',
+            recommended: 'recommended',
+        },
+        schema: [],
+        messages: {
+            preferInject: "Prefer using the inject() function over constructor parameter injection. Use Angular's migration schematic to automatically refactor: ng generate @angular/core:inject",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const angularDecoratorsPattern = (0, utils_1.toPattern)([
+            'Component',
+            'Directive',
+            'Injectable',
+            'Pipe',
+        ]);
+        function shouldReportParameter(param) {
+            let actualParam = param;
+            let hasModifier = false;
+            if (param.type === utils_2.AST_NODE_TYPES.TSParameterProperty) {
+                actualParam = param.parameter;
+                hasModifier = true;
+            }
+            const decorators = (param.type === utils_2.AST_NODE_TYPES.TSParameterProperty
+                ? param.parameter
+                : param).decorators;
+            if (decorators?.some((d) => {
+                const name = utils_1.ASTUtils.getDecoratorName(d);
+                return (name === 'Inject' ||
+                    name === 'Optional' ||
+                    name === 'Self' ||
+                    name === 'SkipSelf' ||
+                    name === 'Host');
+            })) {
+                return true;
+            }
+            if (hasModifier) {
+                return true;
+            }
+            const typeAnnotation = actualParam.typeAnnotation;
+            if (typeAnnotation) {
+                switch (typeAnnotation.typeAnnotation.type) {
+                    case utils_2.AST_NODE_TYPES.TSStringKeyword:
+                    case utils_2.AST_NODE_TYPES.TSNumberKeyword:
+                    case utils_2.AST_NODE_TYPES.TSBooleanKeyword:
+                    case utils_2.AST_NODE_TYPES.TSBigIntKeyword:
+                    case utils_2.AST_NODE_TYPES.TSSymbolKeyword:
+                    case utils_2.AST_NODE_TYPES.TSAnyKeyword:
+                    case utils_2.AST_NODE_TYPES.TSUnknownKeyword:
+                        return false;
+                    default:
+                        return true;
+                }
+            }
+            return false;
+        }
+        return {
+            [`${utils_1.Selectors.decoratorDefinition(angularDecoratorsPattern)} > ClassBody > MethodDefinition[kind="constructor"]`](node) {
+                const params = node.value.params ?? [];
+                if (params.length === 0) {
+                    return;
+                }
+                for (const param of params) {
+                    if (shouldReportParameter(param)) {
+                        context.report({ node: param, messageId: 'preferInject' });
+                    }
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "The inject() function is Angular's modern dependency injection API that offers several advantages over constructor-based injection. First, it enables dependency injection outside of constructors, allowing you to use DI in functions, factories, and even at the class field level. This makes code more flexible and composable. Second, inject() is more concise and reduces boilerplate - you don't need constructor parameter properties or manual field assignments. Third, inject() works naturally with modern TypeScript features and tree-shaking. Fourth, it's required for using many modern Angular features like functional guards, interceptors, and the new signal-based APIs. Angular provides an automated migration schematic (ng generate @angular/core:inject) to convert constructor injection to inject(), making adoption straightforward. This is the recommended approach for all new Angular code.",
+};

package/dist/rules/prefer-on-push-component-change-detection.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'preferOnPushComponentChangeDetection' | 'suggestAddChangeDetectionOnPush';
+export declare const RULE_NAME = "prefer-on-push-component-change-detection";
+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=prefer-on-push-component-change-detection.d.ts.map

package/dist/rules/prefer-on-push-component-change-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-on-push-component-change-detection.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-on-push-component-change-detection.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAClB,sCAAsC,GACtC,iCAAiC,CAAC;AACtC,eAAO,MAAM,SAAS,8CAA8C,CAAC;;;;AAKrE,wBAuEG;AAYH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/prefer-on-push-component-change-detection.js

@@ -0,0 +1,81 @@
+"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-on-push-component-change-detection';
+const METADATA_PROPERTY_NAME = 'changeDetection';
+const STRATEGY_ON_PUSH = 'ChangeDetectionStrategy.OnPush';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Ensures component's \`${METADATA_PROPERTY_NAME}\` is set to \`${STRATEGY_ON_PUSH}\``,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            preferOnPushComponentChangeDetection: `The component's \`${METADATA_PROPERTY_NAME}\` value should be set to \`${STRATEGY_ON_PUSH}\``,
+            suggestAddChangeDetectionOnPush: `Add \`${STRATEGY_ON_PUSH}\``,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const changeDetectionMetadataProperty = utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME);
+        const withoutChangeDetectionDecorator = `${utils_1.Selectors.COMPONENT_CLASS_DECORATOR}:matches([expression.arguments.length=0], [expression.arguments.0.type='ObjectExpression']:not(:has(${changeDetectionMetadataProperty})))`;
+        const nonChangeDetectionOnPushProperty = `${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} > CallExpression > ObjectExpression > ${changeDetectionMetadataProperty}:matches([value.type='Identifier'][value.name='undefined'], [value.object.name='ChangeDetectionStrategy'][value.property.name!='OnPush'])`;
+        const selectors = [
+            withoutChangeDetectionDecorator,
+            nonChangeDetectionOnPushProperty,
+        ].join(',');
+        return {
+            [selectors](node) {
+                context.report({
+                    node: nodeToReport(node),
+                    messageId: 'preferOnPushComponentChangeDetection',
+                    suggest: [
+                        {
+                            messageId: 'suggestAddChangeDetectionOnPush',
+                            fix: (fixer) => {
+                                if (utils_1.ASTUtils.isProperty(node)) {
+                                    return [
+                                        utils_1.RuleFixes.getImportAddFix({
+                                            fixer,
+                                            importName: 'ChangeDetectionStrategy',
+                                            moduleName: '@angular/core',
+                                            node: node.parent.parent.parent.parent,
+                                        }),
+                                        utils_1.ASTUtils.isMemberExpression(node.value)
+                                            ? fixer.replaceText(node.value.property, 'OnPush')
+                                            : fixer.replaceText(node.value, STRATEGY_ON_PUSH),
+                                    ].filter(utils_1.isNotNullOrUndefined);
+                                }
+                                return [
+                                    utils_1.RuleFixes.getImportAddFix({
+                                        fixer,
+                                        importName: 'ChangeDetectionStrategy',
+                                        moduleName: '@angular/core',
+                                        node: node.parent,
+                                    }),
+                                    utils_1.RuleFixes.getDecoratorPropertyAddFix(node, fixer, `${METADATA_PROPERTY_NAME}: ${STRATEGY_ON_PUSH}`),
+                                ].filter(utils_1.isNotNullOrUndefined);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});
+function nodeToReport(node) {
+    if (!utils_1.ASTUtils.isProperty(node)) {
+        return node;
+    }
+    return utils_1.ASTUtils.isMemberExpression(node.value)
+        ? node.value.property
+        : node.value;
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `By default, Angular's change detection checks every component on every change detection cycle, which can involve thousands of checks per second in a large application. OnPush change detection strategy is a performance optimization that tells Angular to only check a component when: (1) its input properties receive new references, (2) an event originates from the component or its children, or (3) change detection is manually triggered. This dramatically reduces the number of change detection runs, improving application performance. OnPush pairs well with immutable data patterns and Angular signals, and is considered a best practice for most components. However, you must be careful to use immutable data patterns (creating new object references when data changes) for OnPush to work correctly.`,
+};

package/dist/rules/prefer-output-emitter-ref.d.ts

@@ -0,0 +1,10 @@
+export type MessageIds = 'preferOutputEmitterRef';
+export declare const RULE_NAME = "prefer-output-emitter-ref";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferOutputEmitterRef", [], 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=prefer-output-emitter-ref.d.ts.map

package/dist/rules/prefer-output-emitter-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-output-emitter-ref.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-output-emitter-ref.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,UAAU,GAAG,wBAAwB,CAAC;AAClD,eAAO,MAAM,SAAS,8BAA8B,CAAC;;;;AAErD,wBAqBG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/prefer-output-emitter-ref.js

@@ -0,0 +1,30 @@
+"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-output-emitter-ref';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Use `OutputEmitterRef` instead of `@Output()`',
+        },
+        schema: [],
+        messages: {
+            preferOutputEmitterRef: 'Use `OutputEmitterRef` via `output()` for Component and Directive outputs rather than the legacy `@Output()` decorator',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [utils_1.Selectors.OUTPUT_DECORATOR]: (node) => {
+                context.report({ node, messageId: 'preferOutputEmitterRef' });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "The output() function is Angular's modern API for component outputs, intended to be used instead of the @Output() decorator (which still exists for backwards compatibility). OutputEmitterRef (returned by output()) provides better type safety, integrates seamlessly with Angular's signal ecosystem, and offers a more functional programming approach. Unlike @Output() which uses EventEmitter, output() is specifically designed for component outputs and has a cleaner, more predictable API, that resembles other function based and signals APIs that have been added to the framework in recent versions.",
+};

package/dist/rules/prefer-output-readonly.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'preferOutputReadonly' | 'suggestAddReadonlyModifier';
+export declare const RULE_NAME = "prefer-output-readonly";
+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=prefer-output-readonly.d.ts.map

package/dist/rules/prefer-output-readonly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-output-readonly.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-output-readonly.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,sBAAsB,GAAG,4BAA4B,CAAC;AAC/E,eAAO,MAAM,SAAS,2BAA2B,CAAC;;;;AAElD,wBAkDG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/prefer-output-readonly.js

@@ -0,0 +1,51 @@
+"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-output-readonly';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer to declare `@Output`, `OutputEmitterRef` and `OutputRef` as `readonly` since they are not supposed to be reassigned',
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            preferOutputReadonly: 'Prefer to declare `{{type}}` as `readonly` since they are not supposed to be reassigned',
+            suggestAddReadonlyModifier: 'Add `readonly` modifier',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [`PropertyDefinition:not([readonly=true]) > ${utils_1.Selectors.OUTPUT_DECORATOR}`]({ parent: { key }, }) {
+                report(key, '@Output');
+            },
+            [`PropertyDefinition:not([readonly=true]):matches([typeAnnotation.typeAnnotation.typeName.name=OutputEmitterRef], [value.callee.name=output])`]({ key, }) {
+                report(key, 'OutputEmitterRef');
+            },
+            [`PropertyDefinition:not([readonly=true]):matches([typeAnnotation.typeAnnotation.typeName.name=OutputRef], [value.callee.name=outputFromObservable])`]({ key, }) {
+                report(key, 'OutputRef');
+            },
+        };
+        function report(key, type) {
+            context.report({
+                node: key,
+                messageId: 'preferOutputReadonly',
+                data: { type },
+                suggest: [
+                    {
+                        messageId: 'suggestAddReadonlyModifier',
+                        fix: (fixer) => fixer.insertTextBefore(key, 'readonly '),
+                    },
+                ],
+            });
+        }
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Output properties should never be reassigned after initialization because they are meant to be stable references that parent components can bind to. Reassigning an output would break those bindings. For @Output() with EventEmitter, marking the property as 'readonly' makes this constraint explicit and leverages TypeScript's type system to prevent accidental reassignment. The correct pattern is '@Output() readonly userClick = new EventEmitter<User>()', not '@Output() userClick: EventEmitter<User>' where the emitter could be reassigned later. Note that the modern output() function (introduced in Angular v17.3) returns an OutputEmitterRef which is inherently immutable, so this rule is less relevant for those outputs but remains important for traditional EventEmitter-based outputs.",
+};

package/dist/rules/prefer-signal-model.d.ts

@@ -0,0 +1,10 @@
+export type MessageIds = 'preferSignalModel';
+export declare const RULE_NAME = "prefer-signal-model";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSignalModel", [], 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=prefer-signal-model.d.ts.map

package/dist/rules/prefer-signal-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-signal-model.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-signal-model.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAC7C,eAAO,MAAM,SAAS,wBAAwB,CAAC;;;;AAE/C,wBA0EG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/prefer-signal-model.js

@@ -0,0 +1,71 @@
+"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-signal-model';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Use `model` instead of `input` and `output` for two-way bindings',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferSignalModel: 'Use `model` for two-way bindings instead of `input()` and `output()`',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const inputs = new Map();
+        const outputs = new Map();
+        return {
+            "PropertyDefinition > CallExpression[callee.name='input']"(node) {
+                const propertyDef = node.parent;
+                const propertyName = utils_1.ASTUtils.getPropertyDefinitionName(propertyDef);
+                inputs.set(propertyName, propertyDef);
+            },
+            "PropertyDefinition > CallExpression[callee.name='output']"(node) {
+                const propertyDef = node.parent;
+                const propertyName = utils_1.ASTUtils.getPropertyDefinitionName(propertyDef);
+                outputs.set(propertyName, propertyDef);
+            },
+            'ClassDeclaration:exit'() {
+                for (const [inputName, inputProperty] of inputs) {
+                    const outputName = `${inputName}Change`;
+                    const outputProperty = outputs.get(outputName);
+                    if (outputProperty) {
+                        // Report on the input property
+                        context.report({
+                            node: inputProperty,
+                            messageId: 'preferSignalModel',
+                            fix: (fixer) => {
+                                const sourceCode = context.sourceCode;
+                                const inputText = sourceCode.getText(inputProperty);
+                                const fixedInputText = inputText.replace(/\binput\b/, 'model');
+                                return [
+                                    utils_1.RuleFixes.getImportAddFix({
+                                        fixer,
+                                        importName: 'model',
+                                        moduleName: '@angular/core',
+                                        node: inputProperty,
+                                    }),
+                                    fixer.replaceText(inputProperty, fixedInputText),
+                                    fixer.remove(outputProperty),
+                                ].filter(utils_1.isNotNullOrUndefined);
+                            },
+                        });
+                    }
+                }
+                // Clear the maps for the next class
+                inputs.clear();
+                outputs.clear();
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "The model() function is Angular's modern API for two-way bindings, combining both input and output into a single signal. When you have an input property paired with an output property that follows the naming pattern of `propertyChange` (e.g., `enabled` input with `enabledChange` output), this is the traditional pattern for two-way binding. The model() function provides a cleaner, more concise way to express this pattern with better type safety and integration with Angular's signal ecosystem. It eliminates the boilerplate of managing separate input and output properties while maintaining the same two-way binding functionality.",
+};

package/dist/rules/prefer-signals.d.ts

@@ -0,0 +1,20 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+type Options = [
+    {
+        preferReadonlySignalProperties: boolean;
+        preferInputSignals: boolean;
+        preferQuerySignals: boolean;
+        useTypeChecking: boolean;
+        additionalSignalCreationFunctions: string[];
+    }
+];
+export type MessageIds = 'preferInputSignals' | 'preferQuerySignals' | 'preferReadonlySignalProperties';
+export declare const RULE_NAME = "prefer-signals";
+declare const _default: ESLintUtils.RuleModule<MessageIds, Options, import("../utils/create-eslint-rule").RuleDocs, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=prefer-signals.d.ts.map

package/dist/rules/prefer-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-signals.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-signals.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIvE,KAAK,OAAO,GAAG;IACb;QACE,8BAA8B,EAAE,OAAO,CAAC;QACxC,kBAAkB,EAAE,OAAO,CAAC;QAC5B,kBAAkB,EAAE,OAAO,CAAC;QAC5B,eAAe,EAAE,OAAO,CAAC;QACzB,iCAAiC,EAAE,MAAM,EAAE,CAAC;KAC7C;CACF,CAAC;AAuBF,MAAM,MAAM,UAAU,GAClB,oBAAoB,GACpB,oBAAoB,GACpB,gCAAgC,CAAC;AACrC,eAAO,MAAM,SAAS,mBAAmB,CAAC;;;;AAE1C,wBAsLG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/prefer-signals.js

@@ -0,0 +1,174 @@
+"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");
+const signals_1 = require("../utils/signals");
+const DEFAULT_OPTIONS = {
+    preferReadonlySignalProperties: true,
+    preferInputSignals: true,
+    preferQuerySignals: true,
+    useTypeChecking: false,
+    additionalSignalCreationFunctions: [],
+};
+const KNOWN_SIGNAL_CREATION_FUNCTIONS = new Set([
+    'computed',
+    'contentChild',
+    'contentChildren',
+    'input',
+    'linkedSignal',
+    'model',
+    'signal',
+    'toSignal',
+    'viewChild',
+    'viewChildren',
+]);
+exports.RULE_NAME = 'prefer-signals';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Use readonly signals instead of `@Input()`, `@ViewChild()` and other legacy decorators',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    preferReadonlySignalProperties: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.preferReadonlySignalProperties,
+                    },
+                    preferInputSignals: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.preferInputSignals,
+                    },
+                    preferQuerySignals: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.preferQuerySignals,
+                    },
+                    useTypeChecking: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.useTypeChecking,
+                    },
+                    additionalSignalCreationFunctions: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: DEFAULT_OPTIONS.additionalSignalCreationFunctions,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            preferInputSignals: 'Use `InputSignal`s (e.g. via `input()`) for Component input properties rather than the legacy `@Input()` decorator',
+            preferQuerySignals: 'Use the `{{function}}` function instead of the `{{decorator}}` decorator',
+            preferReadonlySignalProperties: 'Properties declared using signals should be marked as `readonly` since they should not be reassigned',
+        },
+    },
+    defaultOptions: [{ ...DEFAULT_OPTIONS }],
+    create(context, [{ preferReadonlySignalProperties = DEFAULT_OPTIONS.preferReadonlySignalProperties, preferInputSignals = DEFAULT_OPTIONS.preferInputSignals, preferQuerySignals = DEFAULT_OPTIONS.preferQuerySignals, additionalSignalCreationFunctions = DEFAULT_OPTIONS.additionalSignalCreationFunctions, useTypeChecking = DEFAULT_OPTIONS.useTypeChecking, },]) {
+        let services;
+        const listener = {};
+        if (preferReadonlySignalProperties) {
+            listener[`PropertyDefinition:not([readonly=true])`] = (node) => {
+                let shouldBeReadonly = false;
+                if (node.typeAnnotation) {
+                    // Use the type annotation to determine
+                    // whether the property is a signal.
+                    if (node.typeAnnotation.typeAnnotation.type ===
+                        utils_2.AST_NODE_TYPES.TSTypeReference) {
+                        const type = node.typeAnnotation.typeAnnotation;
+                        if (type.typeArguments &&
+                            type.typeName.type === utils_2.AST_NODE_TYPES.Identifier &&
+                            signals_1.KNOWN_SIGNAL_TYPES.has(type.typeName.name)) {
+                            shouldBeReadonly = true;
+                        }
+                    }
+                }
+                else {
+                    // There is no type annotation, so try to
+                    // use the value assigned to the property
+                    // to determine whether it would be a signal.
+                    let value = node.value;
+                    if (value?.type === utils_2.AST_NODE_TYPES.CallExpression) {
+                        const callee = value.callee;
+                        // A `WritableSignal` can be turned into a `Signal` using
+                        // the `.asReadonly()` method. If that method is being
+                        // called, then we need to look at the object that the method
+                        // is called on to determine if it's being called on a `Signal`.
+                        if (callee.type === utils_2.AST_NODE_TYPES.MemberExpression) {
+                            if (callee.property.type === utils_2.AST_NODE_TYPES.Identifier &&
+                                callee.property.name === 'asReadonly') {
+                                value = callee.object;
+                            }
+                        }
+                    }
+                    if (value?.type === utils_2.AST_NODE_TYPES.CallExpression) {
+                        let callee = value.callee;
+                        // Some signal-creating functions have a `.required`
+                        // member. For example, `input.required()`.
+                        if (callee.type === utils_2.AST_NODE_TYPES.MemberExpression) {
+                            if (callee.property.type === utils_2.AST_NODE_TYPES.Identifier &&
+                                callee.property.name !== 'required') {
+                                return;
+                            }
+                            callee = callee.object;
+                        }
+                        if (callee.type === utils_2.AST_NODE_TYPES.Identifier &&
+                            (KNOWN_SIGNAL_CREATION_FUNCTIONS.has(callee.name) ||
+                                additionalSignalCreationFunctions.includes(callee.name))) {
+                            shouldBeReadonly = true;
+                        }
+                    }
+                    if (!shouldBeReadonly && useTypeChecking && node.value) {
+                        services ??= utils_2.ESLintUtils.getParserServices(context);
+                        const name = services
+                            .getTypeAtLocation(node.value)
+                            .getSymbol()?.name;
+                        shouldBeReadonly =
+                            name !== undefined && signals_1.KNOWN_SIGNAL_TYPES.has(name);
+                    }
+                }
+                if (shouldBeReadonly) {
+                    context.report({
+                        node: node.key,
+                        messageId: 'preferReadonlySignalProperties',
+                        fix: (fixer) => fixer.insertTextBefore(node.key, 'readonly '),
+                    });
+                }
+            };
+        }
+        if (preferInputSignals) {
+            listener[utils_1.Selectors.INPUT_DECORATOR] = (node) => {
+                context.report({
+                    node,
+                    messageId: 'preferInputSignals',
+                });
+            };
+        }
+        if (preferQuerySignals) {
+            listener['Decorator[expression.callee.name=/^(ContentChild|ContentChildren|ViewChild|ViewChildren)$/]'] = (node) => {
+                if (node.expression.type === utils_2.AST_NODE_TYPES.CallExpression &&
+                    node.expression.callee.type === utils_2.AST_NODE_TYPES.Identifier) {
+                    const decoratorName = node.expression.callee.name;
+                    context.report({
+                        node,
+                        messageId: 'preferQuerySignals',
+                        data: {
+                            function: decoratorName.slice(0, 1).toLowerCase() +
+                                decoratorName.slice(1),
+                            decorator: decoratorName,
+                        },
+                    });
+                }
+            };
+        }
+        return listener;
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Angular signals represent the future of reactivity in Angular, offering fine-grained change detection, better performance, and improved developer experience. Signal-based APIs like input(), viewChild(), and contentChild() provide type-safe, reactive properties that integrate seamlessly with computed values and effects. Unlike decorator-based APIs (@Input(), @ViewChild(), etc.), signals enable more granular tracking of dependencies and updates, allowing Angular to optimize change detection. Signal properties should be marked readonly because signals themselves are stable references - you read their value by calling them, you don't reassign the signal. This prevents bugs where developers might accidentally reassign a signal instead of updating its value. Using signals throughout your components creates a consistent, reactive programming model that makes data flow explicit and easier to understand.",
+};

package/dist/rules/prefer-standalone.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'preferStandalone' | 'removeStandaloneFalse';
+export declare const RULE_NAME = "prefer-standalone";
+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=prefer-standalone.d.ts.map

package/dist/rules/prefer-standalone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-standalone.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-standalone.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,MAAM,MAAM,UAAU,GAAG,kBAAkB,GAAG,uBAAuB,CAAC;AACtE,eAAO,MAAM,SAAS,sBAAsB,CAAC;;;;AAK7C,wBAkEG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}