@angular-eslint/eslint-plugin 22.2.1-alpha.1 → 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/component-class-suffix.js

@@ -28,12 +28,12 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             componentClassSuffix: `Component class names should end with one of these suffixes: {{suffixes}}`,
         },
+        defaultOptions: [
+            {
+                suffixes: ['Component'],
+            },
+        ],
     },
-    defaultOptions: [
-        {
-            suffixes: ['Component'],
-        },
-    ],
     create(context, [{ suffixes }]) {
         return {
             [utils_1.Selectors.COMPONENT_CLASS_DECORATOR](node) {

package/dist/rules/component-max-inline-declarations.js

@@ -38,14 +38,14 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             componentMaxInlineDeclarations: `\`{{propertyType}}\` has too many lines ({{lineCount}}). Maximum allowed is {{max}}`,
         },
+        defaultOptions: [
+            {
+                template: DEFAULT_TEMPLATE_LIMIT,
+                styles: DEFAULT_STYLES_LIMIT,
+                animations: DEFAULT_ANIMATIONS_LIMIT,
+            },
+        ],
     },
-    defaultOptions: [
-        {
-            template: DEFAULT_TEMPLATE_LIMIT,
-            styles: DEFAULT_STYLES_LIMIT,
-            animations: DEFAULT_ANIMATIONS_LIMIT,
-        },
-    ],
     create(context, [{ template = DEFAULT_TEMPLATE_LIMIT, styles = DEFAULT_STYLES_LIMIT, animations = DEFAULT_ANIMATIONS_LIMIT, },]) {
         return {
             [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name='template']`]({ value, }) {

package/dist/rules/computed-must-return.js

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             computedMissingReturn: 'computed() is missing a return value',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const functionStack = [];
         function enterFunction(node) {

package/dist/rules/consistent-component-styles.js

@@ -24,8 +24,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             useStylesArray: 'Use a `string[]` instead of a `string` for the `styles` property',
             useStylesString: 'Use a `string` instead of a `string[]` for the `styles` property',
         },
+        defaultOptions: ['string'],
     },
-    defaultOptions: ['string'],
     create(context, [mode]) {
         const { COMPONENT_CLASS_DECORATOR, metadataProperty } = utils_1.Selectors;
         const LITERAL_OR_TEMPLATE_LITERAL = ':matches(Literal, TemplateLiteral)';

package/dist/rules/contextual-decorator.js

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             contextualDecorator: 'Decorator out of context for "@{{classDecoratorName}}()"',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             'MethodDefinition[kind=/^(get|set|method)$/], PropertyDefinition, TSParameterProperty'(node) {

package/dist/rules/contextual-lifecycle.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             contextualLifecycle: `Angular will not invoke the \`{{methodName}}\` lifecycle method within \`@{{classDecoratorName}}()\` classes`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         function checkContext({ parent }, decorator) {
             const classDeclaration = parent;

package/dist/rules/directive-class-suffix.js

@@ -30,8 +30,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             directiveClassSuffix: `Directive class names should end with one of these suffixes: {{suffixes}}`,
         },
+        defaultOptions: [{ suffixes: DEFAULT_SUFFIXES }],
     },
-    defaultOptions: [{ suffixes: DEFAULT_SUFFIXES }],
     create(context, [{ suffixes }]) {
         return {
             [utils_1.Selectors.DIRECTIVE_CLASS_DECORATOR](node) {

package/dist/rules/inject-at-top.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             injectAtTop: 'Move this inject() to the top of the class. Class fields are initialized in the order they are written, so anything declared above this line cannot safely use the service yet.',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const angularDecoratorsPattern = (0, utils_1.toPattern)([
             'Component',

package/dist/rules/no-async-lifecycle-method.js

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noAsyncLifecycleMethod: 'Angular Lifecycle method should not be async',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const angularDecoratorsPattern = (0, utils_1.toPattern)([
             'Component',

package/dist/rules/no-attribute-decorator.js

@@ -14,8 +14,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noAttributeDecorator: '@Attribute can only obtain a single value and is rarely what is required. Use @Input instead to retrieve a stream of values.',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             'ClassDeclaration MethodDefinition[key.name="constructor"] Decorator[expression.callee.name="Attribute"]'(node) {

package/dist/rules/no-developer-preview.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noDeveloperPreview: '`{{name}}` is in developer preview',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const services = (0, eslint_utils_1.getParserServices)(context);
         const checker = services.program.getTypeChecker();

package/dist/rules/no-duplicates-in-metadata-arrays.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noDuplicatesInMetadataArrays: 'Entry is duplicated in metadata array',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const selectors = [
             // https://angular.dev/api/core/NgModule

package/dist/rules/no-empty-lifecycle-method.js

@@ -18,8 +18,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             noEmptyLifecycleMethod: 'Lifecycle methods should not be empty',
             suggestRemoveLifecycleMethod: 'Remove lifecycle method',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
         const angularDecoratorsPattern = (0, utils_1.toPattern)([

package/dist/rules/no-experimental.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noExperimental: '`{{name}}` is experimental',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const services = (0, eslint_utils_1.getParserServices)(context);
         const checker = services.program.getTypeChecker();

package/dist/rules/no-forward-ref.js

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noForwardRef: `Avoid using \`${exports.FORWARD_REF}\``,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [`CallExpression[callee.type="Identifier"][callee.name="${exports.FORWARD_REF}"]`](node) {

package/dist/rules/no-implicit-take-until-destroyed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-implicit-take-until-destroyed.d.ts","sourceRoot":"","sources":["../../src/rules/no-implicit-take-until-destroyed.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,8BAA8B,CAAC;AACxD,eAAO,MAAM,SAAS,qCAAqC,CAAC;;;;AAO5D,wBAgCG;AAwMH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}
+{"version":3,"file":"no-implicit-take-until-destroyed.d.ts","sourceRoot":"","sources":["../../src/rules/no-implicit-take-until-destroyed.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,8BAA8B,CAAC;AACxD,eAAO,MAAM,SAAS,qCAAqC,CAAC;;;;AAO5D,wBAgCG;AAiNH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/no-implicit-take-until-destroyed.js

@@ -18,8 +18,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noImplicitTakeUntilDestroyed: `\`takeUntilDestroyed()\` must be called with an explicit \`DestroyRef\` parameter when used outside of an injection context. See more at ${DEPENDENCY_INJECTION_CONTEXT} and ${RXJS_INTEROP_LINK}`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             CallExpression(node) {
@@ -89,16 +89,26 @@ function isMethodCalledFromInjectionContext(method, classDeclaration) {
         return false;
     }
     const isPrivateField = method.key.type === utils_2.AST_NODE_TYPES.PrivateIdentifier;
+    let isCalledFromInjectionContext = false;
     for (const member of classDeclaration.body.body) {
-        if (!isConstructorMethod(member) &&
-            !utils_1.ASTUtils.isPropertyDefinition(member)) {
+        // Ignore recursive calls from the method to itself
+        if (member === method) {
             continue;
         }
-        if (containsCallToMethod(member, methodName, isPrivateField)) {
-            return true;
+        if (!containsCallToMethod(member, methodName, isPrivateField)) {
+            continue;
+        }
+        if (isConstructorMethod(member) || utils_1.ASTUtils.isPropertyDefinition(member)) {
+            isCalledFromInjectionContext = true;
+        }
+        else {
+            // The method is also called from somewhere that is not an injection
+            // context (e.g. a lifecycle hook or a regular method), so we cannot
+            // assume that `takeUntilDestroyed()` will always run within one.
+            return false;
         }
     }
-    return false;
+    return isCalledFromInjectionContext;
 }
 function isASTNode(value) {
     return (value !== null &&

package/dist/rules/no-input-prefix.js

@@ -29,8 +29,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noInputPrefix: 'Input bindings, including aliases, should not be named, nor prefixed by {{prefixes}}',
         },
+        defaultOptions: [{ prefixes: [] }],
     },
-    defaultOptions: [{ prefixes: [] }],
     create(context, [{ prefixes }]) {
         return {
             [utils_1.Selectors.INPUT_PROPERTY_OR_SETTER](node) {

package/dist/rules/no-input-rename.js

@@ -37,8 +37,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             suggestRemoveAliasName: 'Remove alias name',
             suggestReplaceOriginalNameWithAliasName: 'Remove alias name and use it as the original name',
         },
+        defaultOptions: [{ allowedNames: [] }],
     },
-    defaultOptions: [{ allowedNames: [] }],
     create(context, [{ allowedNames = [] }]) {
         let selectors = new Set();
         const ariaAttributeKeys = (0, utils_1.getAriaAttributeKeys)();

package/dist/rules/no-inputs-metadata-property.js

@@ -18,8 +18,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noInputsMetadataProperty: `Use \`@Input\` rather than the \`${METADATA_PROPERTY_NAME}\` metadata property`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [`${utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} ${utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME)}`](node) {

package/dist/rules/no-lifecycle-call.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noLifecycleCall: 'Avoid explicit calls to lifecycle methods',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const angularLifeCycleMethodsPattern = (0, utils_1.toPattern)([
             ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,

package/dist/rules/no-output-native.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noOutputNative: 'Output bindings, including aliases, should not be named as standard DOM events',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const nativeEventNames = (0, utils_1.getNativeEventNames)();
         const selectors = [

package/dist/rules/no-output-on-prefix.js

@@ -17,8 +17,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noOutputOnPrefix: `Output bindings, including aliases, should not be named "on", nor prefixed with it (${STYLE_GUIDE_LINK})`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const outputOnPattern = /^on(([^a-z])|(?=$))/;
         const selectors = [

package/dist/rules/no-output-rename.js

@@ -22,8 +22,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             suggestRemoveAliasName: 'Remove alias name',
             suggestReplaceOriginalNameWithAliasName: 'Remove alias name and use it as the original name',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         let selectors = new Set();
         return {

package/dist/rules/no-outputs-metadata-property.js

@@ -18,8 +18,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noOutputsMetadataProperty: `Use \`@Output\` rather than the \`${METADATA_PROPERTY_NAME}\` metadata property`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [`${utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} ${utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME)}`](node) {

package/dist/rules/no-pipe-impure.js

@@ -17,8 +17,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             noPipeImpure: 'Impure pipes should be avoided because they are invoked on each change-detection cycle',
             suggestRemovePipeImpure: 'Remove `pure` property',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
         return {

package/dist/rules/no-queries-metadata-property.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             noQueriesMetadataProperty: `Use @${utils_1.ASTUtils.AngularInnerClassDecorators.Output} rather than the \`${METADATA_PROPERTY_NAME}\` metadata property`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR](node) {

package/dist/rules/no-uncalled-signals.js

@@ -33,8 +33,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             noUncalledSignals: 'Doing logic operations on signals will give unexpected results, you probably want to invoke the signal to get its value',
             suggestCallSignal: 'Call this signal to get its value.',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const services = utils_1.ESLintUtils.getParserServices(context);
         function checkForUncalledSignal(node) {

package/dist/rules/pipe-prefix.js

@@ -30,12 +30,12 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             pipePrefix: '@Pipes should be prefixed with {{prefixes}}',
             selectorAfterPrefixFailure: '@Pipes should have a selector after the {{prefixes}} prefix',
         },
+        defaultOptions: [
+            {
+                prefixes: [],
+            },
+        ],
     },
-    defaultOptions: [
-        {
-            prefixes: [],
-        },
-    ],
     create(context, [{ prefixes }]) {
         function checkValidOption(prefixes) {
             return Array.isArray(prefixes) && prefixes.length > 0;

package/dist/rules/prefer-host-metadata-property.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             preferHostMetadataPropertyForBinding: 'Prefer using the `host` metadata property in the `@Component` decorator for host bindings instead of the `@HostBinding` decorator.',
             preferHostMetadataPropertyForListener: 'Prefer using the `host` metadata property in the `@Component` decorator for host listeners instead of the `@HostListener` decorator.',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [utils_1.Selectors.HOST_BINDING_DECORATOR]: (node) => {

package/dist/rules/prefer-inject.js

@@ -17,8 +17,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         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: [],
     },
-    defaultOptions: [],
     create(context) {
         const angularDecoratorsPattern = (0, utils_1.toPattern)([
             'Component',

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

@@ -35,8 +35,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             suggestRemoveChangeDetection: `Remove \`${METADATA_PROPERTY_NAME}\` to use the default (\`${STRATEGY_ON_PUSH}\`)`,
             redundantOnPushComponentChangeDetection: `\`${METADATA_PROPERTY_NAME}: ${STRATEGY_ON_PUSH}\` is redundant because \`${STRATEGY_ON_PUSH}\` is the default change detection strategy`,
         },
+        defaultOptions: [DEFAULT_OPTIONS],
     },
-    defaultOptions: [DEFAULT_OPTIONS],
     create(context, [{ allowExplicitOnPush }]) {
         const sourceCode = context.sourceCode;
         const changeDetectionMetadataProperty = utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME);

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

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             preferOutputEmitterRef: 'Use `OutputEmitterRef` via `output()` for Component and Directive outputs rather than the legacy `@Output()` decorator',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [utils_1.Selectors.OUTPUT_DECORATOR]: (node) => {

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

@@ -17,8 +17,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             preferOutputReadonly: 'Prefer to declare `{{type}}` as `readonly` since they are not supposed to be reassigned',
             suggestAddReadonlyModifier: 'Add `readonly` modifier',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [`PropertyDefinition:not([readonly=true]) > ${utils_1.Selectors.OUTPUT_DECORATOR}`]({ parent: { key }, }) {

package/dist/rules/prefer-service-decorator.js

@@ -17,8 +17,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             preferServiceDecorator: "Use the `@Service()` decorator instead of `@Injectable({ providedIn: 'root' })`",
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [utils_1.Selectors.INJECTABLE_CLASS_DECORATOR](node) {

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,wBA0EG;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,54 +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: [{ ...DEFAULT_OPTIONS }],
     },
-    defaultOptions: [],
-    create(context) {
+    create(context, [{ useTypeChecking = DEFAULT_OPTIONS.useTypeChecking }]) {
+        const { sourceCode } = context;
         const inputs = new Map();
         const outputs = new Map();
+        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
+                if (hasTransformOption(options)) {
+                    return;
+                }
+                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']"(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);
-            },
+            "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();
             },
@@ -67,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/dist/rules/prefer-signals.js

@@ -67,8 +67,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             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 }],
     },
-    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 = {};

package/dist/rules/prefer-standalone.js

@@ -19,8 +19,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             preferStandalone: `Components, Directives and Pipes should not opt out of standalone. Following this guide is highly recommended: ${RECOMMENDED_GUIDE_URL}`,
             removeStandaloneFalse: `Quickly remove 'standalone: false'. NOTE - Following this guide is highly recommended: ${RECOMMENDED_GUIDE_URL}`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const standaloneRuleFactory = (type) => (node) => {
             const standalone = utils_1.ASTUtils.getDecoratorPropertyValue(node, 'standalone');

package/dist/rules/relative-url-prefix.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             relativeUrlPrefix: `The ./ and ../ prefix is standard syntax for relative URLs.`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name='templateUrl']`]({ value, }) {

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

@@ -25,8 +25,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             defineOnPrototype: `The {{ method }} lifecycle method should be defined on the object's prototype. See more at ${ISSUE_LINK}`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [propertyDefinitionSelector](node) {

package/dist/rules/require-localize-metadata.js

@@ -44,8 +44,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             requireLocalizeMeaning: `$localize tagged messages should contain a meaning. See more at ${STYLE_GUIDE_LINK_METADATA_FOR_TRANSLATION}`,
             requireLocalizeCustomId: `$localize tagged messages should contain a custom id{{patternMessage}}. See more at ${STYLE_GUIDE_LINK_METADATA_FOR_TRANSLATION}`,
         },
+        defaultOptions: [DEFAULT_OPTIONS],
     },
-    defaultOptions: [DEFAULT_OPTIONS],
     create(context, [{ requireDescription, requireMeaning, requireCustomId }]) {
         return {
             TaggedTemplateExpression(taggedTemplateExpression) {

package/dist/rules/runtime-localize.js

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             runtimeLocalize: `$localize could be called before translations are loaded`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             TaggedTemplateExpression(taggedTemplateExpression) {

package/dist/rules/sort-keys-in-type-decorator.js

@@ -103,8 +103,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             incorrectOrder: 'Keys in @{{decorator}} decorator should be ordered: {{expectedOrder}}',
         },
+        defaultOptions: [DEFAULT_ORDER],
     },
-    defaultOptions: [DEFAULT_ORDER],
     create(context, [orderConfig]) {
         function checkContext(node, decoratorName) {
             const expectedOrder = orderConfig[decoratorName];

package/dist/rules/sort-lifecycle-methods.js

@@ -15,8 +15,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             lifecycleMethodsNotSorted: `Lifecycle Methods are not declared in order of execution`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const isBefore = (method1, method2) => {
             const methodIndex1 = utils_1.ASTUtils.angularLifecycleMethodsOrdered.indexOf(utils_1.ASTUtils.getMethodName(method1));

package/dist/rules/use-component-selector.js

@@ -16,8 +16,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             useComponentSelector: 'The selector of the component is mandatory',
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [utils_1.Selectors.COMPONENT_CLASS_DECORATOR](node) {

package/dist/rules/use-component-view-encapsulation.js

@@ -18,8 +18,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             useComponentViewEncapsulation: `Using \`${VIEW_ENCAPSULATION_NONE}\` makes your styles global, which may have an unintended effect`,
             suggestRemoveViewEncapsulationNone: `Remove \`${VIEW_ENCAPSULATION_NONE}\``,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
         return {

package/dist/rules/use-injectable-provided-in.js

@@ -35,8 +35,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             useInjectableProvidedIn: `The \`${METADATA_PROPERTY_NAME}\` property is mandatory for \`Injectables\``,
             suggestInjector: `Use \`${METADATA_PROPERTY_NAME}: '{{injector}}'\``,
         },
+        defaultOptions: [DEFAULT_OPTIONS],
     },
-    defaultOptions: [DEFAULT_OPTIONS],
     create(context, [{ ignoreClassNamePattern, allowProvidedInNull }]) {
         const injectableClassDecorator = `ClassDeclaration:not([id.name=${ignoreClassNamePattern}]):not(:has(TSClassImplements:matches([expression.property.name='HttpInterceptor'], [expression.name='HttpInterceptor']))) > Decorator[expression.callee.name="Injectable"]`;
         const providedInMetadataProperty = utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME);

package/dist/rules/use-lifecycle-interface.js

@@ -17,8 +17,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             useLifecycleInterface: `Lifecycle interface '{{interfaceName}}' should be implemented for method '{{methodName}}'. (${STYLE_GUIDE_LINK})`,
         },
         fixable: 'code',
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         const angularLifecycleMethodsPattern = (0, utils_1.toPattern)([
             ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,

package/dist/rules/use-pipe-transform-interface.js

@@ -18,8 +18,8 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         messages: {
             usePipeTransformInterface: `Pipes should implement \`${PIPE_TRANSFORM}\` interface`,
         },
+        defaultOptions: [],
     },
-    defaultOptions: [],
     create(context) {
         return {
             [`ClassDeclaration:not(:has(TSClassImplements:matches([expression.name='${PIPE_TRANSFORM}'], [expression.property.name='${PIPE_TRANSFORM}']))) > Decorator[expression.callee.name='Pipe']`]({ parent: classDeclaration, }) {

package/dist/utils/create-eslint-rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-eslint-rule.d.ts","sourceRoot":"","sources":["../../src/utils/create-eslint-rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,MAAM,WAAW,QAAQ;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAiCD,eAAO,MAAM,gBAAgB;;CAG5B,CAAC"}
+{"version":3,"file":"create-eslint-rule.d.ts","sourceRoot":"","sources":["../../src/utils/create-eslint-rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,MAAM,WAAW,QAAQ;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,gBAAgB;;CAG5B,CAAC"}

package/dist/utils/create-eslint-rule.js

@@ -2,27 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createESLintRule = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-/**
- * We need to patch the RuleCreator in order to preserve the defaultOptions
- * to use as part of documentation generation.
- */
-const patchedRuleCreator = (urlCreator) => {
-    return function createRule({ name, meta, defaultOptions, create }) {
-        const resolvedDefaultOptions = (defaultOptions ?? []);
-        return {
-            name,
-            meta: Object.assign(Object.assign({}, meta), {
-                docs: Object.assign(Object.assign({}, meta.docs), {
-                    url: urlCreator(name),
-                }),
-            }),
-            defaultOptions: resolvedDefaultOptions,
-            create(context) {
-                const optionsWithDefault = utils_1.ESLintUtils.applyDefault(resolvedDefaultOptions, context.options);
-                return create(context, optionsWithDefault);
-            },
-        };
-    };
-};
-patchedRuleCreator.withoutDocs = utils_1.ESLintUtils.RuleCreator.withoutDocs;
-exports.createESLintRule = patchedRuleCreator((ruleName) => `https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/${ruleName}.md`);
+exports.createESLintRule = utils_1.ESLintUtils.RuleCreator((ruleName) => `https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/${ruleName}.md`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "22.2.1-alpha.1",
+  "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.1",
-    "@angular-eslint/utils": "22.2.1-alpha.1",
+    "@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.1"
+    "@angular-eslint/test-utils": "22.2.1-alpha.11"
   },
   "peerDependencies": {
     "@typescript-eslint/utils": "^8.0.0",