@angular-eslint/eslint-plugin 22.2.1-alpha.10 → 22.2.1-alpha.11

package/dist/index.d.ts

@@ -108,7 +108,9 @@ declare const _default: {
         "prefer-service-decorator": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferServiceDecorator", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        "prefer-signal-model": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSignalModel", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        "prefer-signal-model": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSignalModel", [{
+            useTypeChecking: boolean;
+        }], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         "prefer-signals": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-signals").MessageIds, [{

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuJA,kBAsDE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuJA,kBAsDE"}

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

@@ -1,6 +1,12 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+type Options = [
+    {
+        useTypeChecking: boolean;
+    }
+];
 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> & {
+declare const _default: ESLintUtils.RuleModule<"preferSignalModel", Options, import("../utils/create-eslint-rule").RuleDocs, ESLintUtils.RuleListener> & {
     name: string;
 };
 export default _default;

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

@@ -1 +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,wBA4FG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}
+{"version":3,"file":"prefer-signal-model.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-signal-model.ts"],"names":[],"mappings":"AASA,OAAO,EAAkB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIvE,KAAK,OAAO,GAAG;IACb;QACE,eAAe,EAAE,OAAO,CAAC;KAC1B;CACF,CAAC;AAMF,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;AAC7C,eAAO,MAAM,SAAS,wBAAwB,CAAC;;;;AA8B/C,wBAuKG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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

@@ -1,9 +1,25 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 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 typescript_1 = __importDefault(require("typescript"));
 const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const DEFAULT_OPTIONS = {
+    useTypeChecking: false,
+};
 exports.RULE_NAME = 'prefer-signal-model';
+function hasTransformOption(options) {
+    return (options?.type === utils_2.AST_NODE_TYPES.ObjectExpression &&
+        options.properties.some((property) => property.type === utils_2.AST_NODE_TYPES.Property &&
+            ((property.key.type === utils_2.AST_NODE_TYPES.Identifier &&
+                property.key.name === 'transform') ||
+                (property.key.type === utils_2.AST_NODE_TYPES.Literal &&
+                    property.key.value === 'transform'))));
+}
 exports.default = (0, create_eslint_rule_1.createESLintRule)({
     name: exports.RULE_NAME,
     meta: {
@@ -12,66 +28,116 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             description: 'Use `model` instead of `input` and `output` for two-way bindings',
         },
         fixable: 'code',
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    useTypeChecking: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.useTypeChecking,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             preferSignalModel: 'Use `model` for two-way bindings instead of `input()` and `output()`',
         },
-        defaultOptions: [],
+        defaultOptions: [{ ...DEFAULT_OPTIONS }],
     },
-    create(context) {
+    create(context, [{ useTypeChecking = DEFAULT_OPTIONS.useTypeChecking }]) {
+        const { sourceCode } = context;
         const inputs = new Map();
         const outputs = new Map();
-        return {
-            "PropertyDefinition > CallExpression[callee.name='input']"(node) {
-                // Skip inputs with a transform option because model() does not support transform.
+        let services;
+        function getTypeServices() {
+            return (services ??= utils_2.ESLintUtils.getParserServices(context));
+        }
+        function createSignalCollector(signals, { hasInitialValueArgument }) {
+            return (node) => {
+                const options = node.arguments[hasInitialValueArgument ? 1 : 0];
+                // `model()` has no transform support.
                 // https://github.com/angular/angular/issues/55166#issuecomment-2032150999
-                const options = node.arguments[1];
-                const hasTransformOption = options?.type === 'ObjectExpression' &&
-                    options.properties.some((prop) => prop.type === 'Property' &&
-                        ((prop.key.type === 'Identifier' &&
-                            prop.key.name === 'transform') ||
-                            (prop.key.type === 'Literal' &&
-                                prop.key.value === 'transform')));
-                if (hasTransformOption) {
+                if (hasTransformOption(options)) {
                     return;
                 }
-                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);
-            },
+                const property = node.parent;
+                signals.set(utils_1.ASTUtils.getPropertyDefinitionName(property), {
+                    property,
+                    callee: (node.callee.type === utils_2.AST_NODE_TYPES.MemberExpression
+                        ? node.callee.object
+                        : node.callee),
+                    typeArgument: node.typeArguments?.params[0],
+                    initialValue: hasInitialValueArgument ? node.arguments[0] : undefined,
+                });
+            };
+        }
+        function getValueType({ typeArgument, initialValue }) {
+            const typeServices = getTypeServices();
+            if (typeArgument) {
+                return typeServices.getTypeAtLocation(typeArgument);
+            }
+            if (initialValue) {
+                return typeServices.program
+                    .getTypeChecker()
+                    .getBaseTypeOfLiteralType(typeServices.getTypeAtLocation(initialValue));
+            }
+            return undefined;
+        }
+        function haveEquallyWrittenTypes(input, output) {
+            return (!input.typeArgument ||
+                !output.typeArgument ||
+                sourceCode.getText(input.typeArgument) ===
+                    sourceCode.getText(output.typeArgument));
+        }
+        function haveMergeableTypes(input, output) {
+            if (!useTypeChecking) {
+                return haveEquallyWrittenTypes(input, output);
+            }
+            const inputType = getValueType(input);
+            const outputType = getValueType(output);
+            if (!inputType || !outputType) {
+                return true;
+            }
+            // A type argument that does not resolve becomes the error type, which is
+            // assignable in both directions, so only the written text is trustworthy.
+            if ((inputType.flags | outputType.flags) & typescript_1.default.TypeFlags.Any) {
+                return haveEquallyWrittenTypes(input, output);
+            }
+            // Mutual assignability stands in for the internal `isTypeIdenticalTo`;
+            // the same type written twice yields two distinct `ts.Type` objects.
+            const checker = getTypeServices().program.getTypeChecker();
+            return (checker.isTypeAssignableTo(inputType, outputType) &&
+                checker.isTypeAssignableTo(outputType, inputType));
+        }
+        return {
+            "PropertyDefinition > CallExpression[callee.name='input']": createSignalCollector(inputs, { hasInitialValueArgument: true }),
+            "PropertyDefinition > CallExpression[callee.object.name='input'][callee.property.name='required']": createSignalCollector(inputs, { hasInitialValueArgument: false }),
+            "PropertyDefinition > CallExpression[callee.name='output']": createSignalCollector(outputs, { hasInitialValueArgument: false }),
             '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);
-                            },
-                        });
-                    }
+                const twoWayBindings = [...inputs]
+                    .map(([name, input]) => ({
+                    input,
+                    output: outputs.get(`${name}Change`),
+                }))
+                    .filter((binding) => binding.output !== undefined &&
+                    haveMergeableTypes(binding.input, binding.output));
+                for (const { input, output } of twoWayBindings) {
+                    context.report({
+                        node: input.property,
+                        messageId: 'preferSignalModel',
+                        fix: (fixer) => [
+                            utils_1.RuleFixes.getImportAddFix({
+                                fixer,
+                                importName: 'model',
+                                moduleName: '@angular/core',
+                                node: input.property,
+                            }),
+                            fixer.replaceText(input.callee, 'model'),
+                            fixer.remove(output.property),
+                        ].filter(utils_1.isNotNullOrUndefined),
+                    });
                 }
-                // Clear the maps for the next class
                 inputs.clear();
                 outputs.clear();
             },
@@ -79,5 +145,5 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     },
 });
 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.",
+    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.\n\nBecause `model()` exposes a single type for both directions, only pairs whose `input` and `output` types match are reported. By default the written type arguments are compared as text, and a pair is assumed compatible when either side has no type argument. Enabling the `useTypeChecking` option compares the types semantically instead, and infers an `input`'s type from its initial value, so `input('')` paired with `output<number>()` is left alone. A type argument that does not resolve falls back to the text comparison.",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "22.2.1-alpha.10",
+  "version": "22.2.1-alpha.11",
   "description": "ESLint plugin for Angular applications, following https://angular.dev/style-guide",
   "license": "MIT",
   "main": "dist/index.js",
@@ -19,12 +19,12 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@angular-eslint/bundled-angular-compiler": "22.2.1-alpha.10",
-    "@angular-eslint/utils": "22.2.1-alpha.10",
+    "@angular-eslint/bundled-angular-compiler": "22.2.1-alpha.11",
+    "@angular-eslint/utils": "22.2.1-alpha.11",
     "ts-api-utils": "^2.1.0"
   },
   "devDependencies": {
-    "@angular-eslint/test-utils": "22.2.1-alpha.10"
+    "@angular-eslint/test-utils": "22.2.1-alpha.11"
   },
   "peerDependencies": {
     "@typescript-eslint/utils": "^8.0.0",