@depup/angular-eslint__eslint-plugin 22.1.0-depup.1 → 22.3.0-depup.0

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.d.ts

@@ -1,7 +1,10 @@
-export type Options = [];
-export type MessageIds = 'preferOnPushComponentChangeDetection' | 'suggestRemoveChangeDetection';
+import type { TSESLint } from '@typescript-eslint/utils';
+export type Options = [{
+    readonly allowExplicitOnPush: boolean;
+}];
+export type MessageIds = 'preferOnPushComponentChangeDetection' | 'suggestRemoveChangeDetection' | 'redundantOnPushComponentChangeDetection';
 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> & {
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../utils/create-eslint-rule").RuleDocs, TSESLint.RuleListener> & {
     name: string;
 };
 export default _default;

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

@@ -1 +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,GACpB,sCAAsC,GAAG,8BAA8B,CAAC;AAC1E,eAAO,MAAM,SAAS,8CAA8C,CAAC;;;;AAKrE,wBAoEG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}
+{"version":3,"file":"prefer-on-push-component-change-detection.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-on-push-component-change-detection.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAGnE,MAAM,MAAM,OAAO,GAAG,CAAC;IAAE,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAClE,MAAM,MAAM,UAAU,GAClB,sCAAsC,GACtC,8BAA8B,GAC9B,yCAAyC,CAAC;AAC9C,eAAO,MAAM,SAAS,8CAA8C,CAAC;;;;AAMrE,wBAoGG;AAEH,eAAO,MAAM,mBAAmB;;CAQ/B,CAAC"}

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

@@ -6,6 +6,7 @@ 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';
+const DEFAULT_OPTIONS = { allowExplicitOnPush: true };
 exports.default = (0, create_eslint_rule_1.createESLintRule)({
     name: exports.RULE_NAME,
     meta: {
@@ -14,26 +15,41 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             description: `Ensures components do not opt out of the default \`${STRATEGY_ON_PUSH}\` change detection strategy`,
             recommended: 'recommended',
         },
+        fixable: 'code',
         hasSuggestions: true,
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowExplicitOnPush: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.allowExplicitOnPush,
+                        description: `Whether to allow a component to set \`${METADATA_PROPERTY_NAME}: ${STRATEGY_ON_PUSH}\` explicitly even though it is now the default.`,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             preferOnPushComponentChangeDetection: `Components should not opt out of the default \`${STRATEGY_ON_PUSH}\` change detection strategy`,
             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: [],
-    create(context) {
+    create(context, [{ allowExplicitOnPush }]) {
         const sourceCode = context.sourceCode;
         const changeDetectionMetadataProperty = utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME);
-        /**
-         * As of Angular v22 OnPush is the default change detection strategy, so a
-         * component only needs to be reported when it explicitly opts out of it by
-         * setting a non-OnPush `ChangeDetectionStrategy` member (e.g. `Eager`, or
-         * the deprecated `Default`). Omitting `changeDetection` entirely, or setting
-         * it to `ChangeDetectionStrategy.OnPush`, is the desired default and is not
-         * reported.
-         */
-        const onPushOptOutProperty = `${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} > CallExpression > ObjectExpression > ${changeDetectionMetadataProperty}[value.object.name='ChangeDetectionStrategy'][value.property.name!='OnPush']`;
+        const changeDetectionStrategyProperty = `${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} > CallExpression > ObjectExpression > ${changeDetectionMetadataProperty}[value.object.name='ChangeDetectionStrategy']`;
+        const onPushOptOutProperty = `${changeDetectionStrategyProperty}[value.property.name!='OnPush']`;
+        const redundantOnPushProperty = `${changeDetectionStrategyProperty}[value.property.name='OnPush']`;
+        function removeChangeDetectionProperty(node, fixer) {
+            const importDeclarations = utils_1.ASTUtils.getImportDeclarations(node, '@angular/core') ?? [];
+            return [
+                utils_1.RuleFixes.getNodeToCommaRemoveFix(sourceCode, node, fixer),
+                utils_1.RuleFixes.getImportRemoveFix(sourceCode, importDeclarations, 'ChangeDetectionStrategy', fixer),
+            ].filter(utils_1.isNotNullOrUndefined);
+        }
         return {
             [onPushOptOutProperty](node) {
                 const { value } = node;
@@ -48,20 +64,34 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                     suggest: [
                         {
                             messageId: 'suggestRemoveChangeDetection',
-                            fix: (fixer) => {
-                                const importDeclarations = utils_1.ASTUtils.getImportDeclarations(node, '@angular/core') ?? [];
-                                return [
-                                    utils_1.RuleFixes.getNodeToCommaRemoveFix(sourceCode, node, fixer),
-                                    utils_1.RuleFixes.getImportRemoveFix(sourceCode, importDeclarations, 'ChangeDetectionStrategy', fixer),
-                                ].filter(utils_1.isNotNullOrUndefined);
-                            },
+                            fix: (fixer) => removeChangeDetectionProperty(node, fixer),
                         },
                     ],
                 });
             },
+            [redundantOnPushProperty](node) {
+                if (allowExplicitOnPush) {
+                    return;
+                }
+                const { value } = node;
+                if (!utils_1.ASTUtils.isMemberExpression(value)) {
+                    return;
+                }
+                context.report({
+                    node: value.property,
+                    messageId: 'redundantOnPushComponentChangeDetection',
+                    fix: (fixer) => removeChangeDetectionProperty(node, fixer),
+                });
+            },
         };
     },
 });
 exports.RULE_DOCS_EXTENSION = {
-    rationale: `As of Angular v22, \`${STRATEGY_ON_PUSH}\` is the default change detection strategy: a component that does not specify \`${METADATA_PROPERTY_NAME}\` is checked using OnPush. This brings new code in line with zoneless being the default and with Angular's goal of performance by default, and means it is no longer necessary to set \`${STRATEGY_ON_PUSH}\` explicitly. The previous default, \`ChangeDetectionStrategy.Default\`, has been renamed to \`ChangeDetectionStrategy.Eager\`. When you run \`ng update\`, the v22 migration adds an explicit \`ChangeDetectionStrategy.Eager\` to existing components that relied on the old implicit default, so that they keep behaving as before.\n\nBecause omitting \`${METADATA_PROPERTY_NAME}\` (or setting it to \`${STRATEGY_ON_PUSH}\`) already gives you OnPush, this rule does not require you to declare it. Instead it reports components that explicitly opt out of OnPush by setting \`ChangeDetectionStrategy.Eager\` (or the deprecated \`ChangeDetectionStrategy.Default\`) — including the components the migration marked as \`Eager\` — so you can review them and adopt OnPush where it is safe to do so. The suggestion removes the \`${METADATA_PROPERTY_NAME}\` property entirely (along with the now-unused \`ChangeDetectionStrategy\` import), relying on the v22 default rather than setting \`${STRATEGY_ON_PUSH}\` explicitly. Note that switching a component from eager checking to OnPush can change its runtime behaviour, so apply the suggestion deliberately and make sure the component uses immutable data patterns (creating new object references when data changes).`,
+    rationale: `As of Angular v22, \`${STRATEGY_ON_PUSH}\` is the default change detection strategy: a component that does not specify \`${METADATA_PROPERTY_NAME}\` is checked using OnPush. \
+This brings new code in line with zoneless being the default and with Angular's goal of performance by default, and means it is no longer necessary to set \`${STRATEGY_ON_PUSH}\` explicitly. \
+The previous default, \`ChangeDetectionStrategy.Default\`, has been renamed to \`ChangeDetectionStrategy.Eager\`. \
+When you run \`ng update\`, the v22 migration adds an explicit \`ChangeDetectionStrategy.Eager\` to existing components that relied on the old implicit default, so that they keep behaving as before.\n\n\
+By default the rule reports components that explicitly opt out of OnPush by setting \`${METADATA_PROPERTY_NAME}\` to \`ChangeDetectionStrategy.Eager\` (or the deprecated \`ChangeDetectionStrategy.Default\`) — including the components the migration marked as \`Eager\` — so you can review them and adopt OnPush where it is safe to do so. \
+Because omitting \`${METADATA_PROPERTY_NAME}\` already gives you OnPush, declaring \`${STRATEGY_ON_PUSH}\` explicitly is redundant; set \`allowExplicitOnPush\` to \`false\` to have the rule flag and autofix that too. \
+Note that switching a component from eager checking to OnPush can change its runtime behaviour, so apply the suggestion deliberately and make sure the component uses immutable data patterns (creating new object references when data changes).`,
 };

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/reactive-context-must-read-signal.d.ts

@@ -0,0 +1,16 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export type Options = [
+    {
+        readonly checkResources?: boolean;
+    }
+];
+export type MessageIds = 'mustReadSignal';
+export declare const RULE_NAME = "reactive-context-must-read-signal";
+declare const _default: ESLintUtils.RuleModule<"mustReadSignal", Options, import("../utils/create-eslint-rule").RuleDocs, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=reactive-context-must-read-signal.d.ts.map

package/dist/rules/reactive-context-must-read-signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive-context-must-read-signal.d.ts","sourceRoot":"","sources":["../../src/rules/reactive-context-must-read-signal.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EAGZ,MAAM,0BAA0B,CAAC;AAMlC,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;KACnC;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAC1C,eAAO,MAAM,SAAS,sCAAsC,CAAC;;;;AA8D7D,wBA2VG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}