@angular-eslint/eslint-plugin 19.0.0-alpha.2 → 19.0.0-alpha.4

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

@@ -0,0 +1,15 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+type Options = [
+    {
+        preferReadonlySignalProperties: boolean;
+        preferInputSignals: boolean;
+        preferQuerySignals: boolean;
+        useTypeChecking: boolean;
+        additionalSignalCreationFunctions: string[];
+    }
+];
+export type MessageIds = 'preferInputSignals' | 'preferQuerySignals' | 'preferReadonlySignalProperties' | 'suggestAddReadonlyModifier';
+export declare const RULE_NAME = "prefer-signals";
+declare const _default: ESLintUtils.RuleModule<MessageIds, Options, import("../utils/create-eslint-rule").RuleDocs, ESLintUtils.RuleListener>;
+export default _default;
+//# 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;AAGvE,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;AA4BF,MAAM,MAAM,UAAU,GAClB,oBAAoB,GACpB,oBAAoB,GACpB,gCAAgC,GAChC,4BAA4B,CAAC;AACjC,eAAO,MAAM,SAAS,mBAAmB,CAAC;;AAE1C,wBA6KG"}

package/dist/rules/prefer-signals.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 DEFAULT_OPTIONS = {
+    preferReadonlySignalProperties: true,
+    preferInputSignals: true,
+    preferQuerySignals: true,
+    useTypeChecking: false,
+    additionalSignalCreationFunctions: [],
+};
+const KNOWN_SIGNAL_TYPES = new Set([
+    'InputSignal',
+    'ModelSignal',
+    'Signal',
+    'WritableSignal',
+]);
+const KNOWN_SIGNAL_CREATION_FUNCTIONS = new Set([
+    'computed',
+    'contentChild',
+    'contentChildren',
+    'input',
+    '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',
+            recommended: 'recommended',
+        },
+        hasSuggestions: true,
+        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',
+            suggestAddReadonlyModifier: 'Add `readonly` modifier',
+        },
+    },
+    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 &&
+                            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.
+                    if (node.value?.type === utils_2.AST_NODE_TYPES.CallExpression) {
+                        let callee = node.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 && KNOWN_SIGNAL_TYPES.has(name);
+                    }
+                }
+                if (shouldBeReadonly) {
+                    context.report({
+                        node: node.key,
+                        messageId: 'preferReadonlySignalProperties',
+                        suggest: [
+                            {
+                                messageId: 'suggestAddReadonlyModifier',
+                                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;
+    },
+});

package/package.json

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