@angular-eslint/eslint-plugin 19.0.0-alpha.3 → 19.0.0-alpha.5

package/README.md

@@ -66,7 +66,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`pipe-prefix`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/pipe-prefix.md) | Enforce consistent prefix for pipes. |  |  |  |
 | [`prefer-on-push-component-change-detection`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-on-push-component-change-detection.md) | Ensures component's `changeDetection` is set to `ChangeDetectionStrategy.OnPush` |  |  | :bulb: |
 | [`prefer-output-readonly`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-output-readonly.md) | Prefer to declare `@Output`, `OutputEmitterRef` and `OutputRef` as `readonly` since they are not supposed to be reassigned |  |  | :bulb: |
-| [`prefer-standalone`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-standalone.md) | Ensures component, directive and pipe `standalone` property is set to `true` in the component decorator |  | :wrench: |  |
+| [`prefer-standalone`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/prefer-standalone.md) | Ensures component, directive and pipe `standalone` property is set to `true` in the component decorator | :white_check_mark: | :wrench: |  |
 | [`relative-url-prefix`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/relative-url-prefix.md) | The ./ and ../ prefix is standard syntax for relative URLs; don't depend on Angular's current ability to do without that prefix. See more at https://angular.dev/style-guide#style-05-04 |  |  |  |
 | [`require-localize-metadata`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/require-localize-metadata.md) | Ensures that $localize tagged messages contain helpful metadata to aid with translations. |  |  |  |
 | [`runtime-localize`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/runtime-localize.md) | Ensures that $localize tagged messages can use runtime-loaded translations. |  |  |  |

package/dist/configs/recommended.json

@@ -12,6 +12,7 @@
     "@angular-eslint/no-output-on-prefix": "error",
     "@angular-eslint/no-output-rename": "error",
     "@angular-eslint/no-outputs-metadata-property": "error",
+    "@angular-eslint/prefer-standalone": "error",
     "@angular-eslint/use-pipe-transform-interface": "error",
     "@angular-eslint/use-lifecycle-interface": "warn"
   }

package/dist/index.d.ts

@@ -57,6 +57,7 @@ declare const _default: {
                 "@angular-eslint/no-output-on-prefix": string;
                 "@angular-eslint/no-output-rename": string;
                 "@angular-eslint/no-outputs-metadata-property": string;
+                "@angular-eslint/prefer-standalone": string;
                 "@angular-eslint/use-pipe-transform-interface": string;
                 "@angular-eslint/use-lifecycle-interface": string;
             };

package/dist/index.d.ts.map

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

package/dist/rules/no-input-rename.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-input-rename.d.ts","sourceRoot":"","sources":["../../src/rules/no-input-rename.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,OAAO,GAAG,CAAC;IAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC;AACtE,MAAM,MAAM,UAAU,GAClB,eAAe,GACf,wBAAwB,GACxB,yCAAyC,CAAC;AAC9C,eAAO,MAAM,SAAS,oBAAoB,CAAC;;AAG3C,wBAkPG"}
+{"version":3,"file":"no-input-rename.d.ts","sourceRoot":"","sources":["../../src/rules/no-input-rename.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,OAAO,GAAG,CAAC;IAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC;AACtE,MAAM,MAAM,UAAU,GAClB,eAAe,GACf,wBAAwB,GACxB,yCAAyC,CAAC;AAC9C,eAAO,MAAM,SAAS,oBAAoB,CAAC;;AAG3C,wBAgQG"}

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

@@ -58,14 +58,6 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                     !utils_2.ASTUtils.isIdentifier(propertyOrMethodDefinition.key)) {
                     return;
                 }
-                let isAliasMetadataProperty = false;
-                if (node.parent && utils_1.ASTUtils.isProperty(node.parent)) {
-                    if (utils_1.ASTUtils.getRawText(node.parent.key) !== 'alias') {
-                        // We're within an Input decorator metadata object, but it is not the alias property
-                        return;
-                    }
-                    isAliasMetadataProperty = true;
-                }
                 const aliasName = utils_1.ASTUtils.getRawText(node);
                 const propertyName = utils_1.ASTUtils.getRawText(propertyOrMethodDefinition.key);
                 if (allowedNames.includes(aliasName) ||
@@ -73,28 +65,65 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                         propertyName === (0, utils_1.kebabToCamelCase)(aliasName))) {
                     return;
                 }
-                const inputCallExpression = utils_1.ASTUtils.getNearestNodeFrom(node, utils_1.ASTUtils.isCallExpression);
-                if (inputCallExpression &&
-                    utils_2.ASTUtils.isIdentifier(inputCallExpression.callee) &&
-                    inputCallExpression.callee.name === 'Input' &&
-                    utils_1.ASTUtils.isObjectExpression(inputCallExpression.arguments?.[0])) {
-                    const [firstArg] = inputCallExpression.arguments;
-                    const aliasProperty = firstArg.properties.find((property) => utils_1.ASTUtils.isProperty(property) &&
-                        utils_1.ASTUtils.getRawText(property.key) === 'alias');
-                    if (!aliasProperty) {
-                        return;
+                // The alias is either a string in the `@Input()` decorator function,
+                // or a string on an `alias` property that is in an object expression
+                // that is in the `@Input()` decorator or the `input()` function or the
+                // `input.required()` function. If it's on the `alias` property, then we
+                // want to remove that whole property rather than just the string literal.
+                const stringToRemove = utils_1.ASTUtils.isTemplateElement(node)
+                    ? node.parent
+                    : node;
+                let rangeToRemove = stringToRemove.range;
+                if (utils_1.ASTUtils.isProperty(stringToRemove.parent)) {
+                    const property = stringToRemove.parent;
+                    rangeToRemove = property.range;
+                    if (utils_1.ASTUtils.isObjectExpression(property.parent)) {
+                        const objectExpression = property.parent;
+                        if (objectExpression.properties.length === 1) {
+                            // The property is the only property in the
+                            // object, so we can remove the whole object.
+                            rangeToRemove = objectExpression.range;
+                            // If the object is in an `input()` function, then
+                            // the object will be the second argument. The first
+                            // argument will be the default value. We need to
+                            // remove the comma after the default value.
+                            const tokenBefore = context.sourceCode.getTokenBefore(objectExpression);
+                            if (tokenBefore && utils_2.ASTUtils.isCommaToken(tokenBefore)) {
+                                rangeToRemove = [tokenBefore.range[0], rangeToRemove[1]];
+                            }
+                        }
+                        else {
+                            // There are other properties in the object, so we
+                            // can only remove the property. How we remove it
+                            // will depend on where the property is in the object.
+                            const propertyIndex = objectExpression.properties.indexOf(property);
+                            if (propertyIndex < objectExpression.properties.length - 1) {
+                                // The property is not the last one, so we can
+                                // remove everything up to the next property
+                                // which will remove the comma after it.
+                                rangeToRemove = [
+                                    property.range[0],
+                                    objectExpression.properties[propertyIndex + 1].range[0],
+                                ];
+                            }
+                            else {
+                                // The property is the last one. If the object has a
+                                // trailing comma, then we want to keep the trailing comma.
+                                // The simplest way to do that is to remove the property
+                                // and the comma that precedes it.
+                                const tokenBefore = context.sourceCode.getTokenBefore(property);
+                                if (tokenBefore && utils_2.ASTUtils.isCommaToken(tokenBefore)) {
+                                    rangeToRemove = [tokenBefore.range[0], rangeToRemove[1]];
+                                }
+                            }
+                        }
                     }
                 }
                 if (aliasName === propertyName) {
                     context.report({
                         node,
                         messageId: 'noInputRename',
-                        fix: (fixer) => {
-                            if (node.parent && isAliasMetadataProperty) {
-                                return fixer.remove(node.parent);
-                            }
-                            return fixer.remove(node);
-                        },
+                        fix: (fixer) => fixer.removeRange(rangeToRemove),
                     });
                 }
                 else if (!isAliasNameAllowed(selectors, propertyName, aliasName, selectorDirectiveName)) {
@@ -104,17 +133,12 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                         suggest: [
                             {
                                 messageId: 'suggestRemoveAliasName',
-                                fix: (fixer) => {
-                                    if (node.parent && isAliasMetadataProperty) {
-                                        return fixer.remove(node.parent);
-                                    }
-                                    return fixer.remove(node);
-                                },
+                                fix: (fixer) => fixer.removeRange(rangeToRemove),
                             },
                             {
                                 messageId: 'suggestReplaceOriginalNameWithAliasName',
                                 fix: (fixer) => [
-                                    fixer.remove(node),
+                                    fixer.removeRange(rangeToRemove),
                                     fixer.replaceText(propertyOrMethodDefinition.key, aliasName.includes('-') ? `'${aliasName}'` : aliasName),
                                 ],
                             },

package/dist/rules/no-output-rename.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-output-rename.d.ts","sourceRoot":"","sources":["../../src/rules/no-output-rename.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,wBAAwB,GACxB,yCAAyC,CAAC;AAC9C,eAAO,MAAM,SAAS,qBAAqB,CAAC;;AAG5C,wBAkJG"}
+{"version":3,"file":"no-output-rename.d.ts","sourceRoot":"","sources":["../../src/rules/no-output-rename.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,wBAAwB,GACxB,yCAAyC,CAAC;AAC9C,eAAO,MAAM,SAAS,qBAAqB,CAAC;;AAG5C,wBAgMG"}

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

@@ -38,11 +38,56 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                 }
                 const aliasName = utils_1.ASTUtils.getRawText(node);
                 const propertyName = utils_1.ASTUtils.getRawText(propertyOrMethodDefinition.key);
+                // The alias is either a string in the `@Output()` decorator function,
+                // or a string on an `alias` property that is in an object expression
+                // that is in the `output()` function. If it's the latter, then we want
+                // to remove that whole property rather than just the string literal.
+                const stringToRemove = utils_1.ASTUtils.isTemplateElement(node)
+                    ? node.parent
+                    : node;
+                let rangeToRemove = stringToRemove.range;
+                if (utils_1.ASTUtils.isProperty(stringToRemove.parent)) {
+                    const property = stringToRemove.parent;
+                    rangeToRemove = property.range;
+                    if (utils_1.ASTUtils.isObjectExpression(property.parent)) {
+                        const objectExpression = property.parent;
+                        if (objectExpression.properties.length === 1) {
+                            // The property is the only property in the
+                            // object, so we can remove the whole object.
+                            rangeToRemove = objectExpression.range;
+                        }
+                        else {
+                            // There are other properties in the object, so we
+                            // can only remove the property. How we remove it
+                            // will depend on where the property is in the object.
+                            const propertyIndex = objectExpression.properties.indexOf(property);
+                            if (propertyIndex < objectExpression.properties.length - 1) {
+                                // The property is not the last one, so we can
+                                // remove everything up to the next property
+                                // which will remove the comma after it.
+                                rangeToRemove = [
+                                    property.range[0],
+                                    objectExpression.properties[propertyIndex + 1].range[0],
+                                ];
+                            }
+                            else {
+                                // The property is the last one. If the object has a
+                                // trailing comma, then we want to keep the trailing comma.
+                                // The simplest way to do that is to remove the property
+                                // and the comma that precedes it.
+                                const tokenBefore = context.sourceCode.getTokenBefore(property);
+                                if (tokenBefore && utils_2.ASTUtils.isCommaToken(tokenBefore)) {
+                                    rangeToRemove = [tokenBefore.range[0], rangeToRemove[1]];
+                                }
+                            }
+                        }
+                    }
+                }
                 if (aliasName === propertyName) {
                     context.report({
                         node,
                         messageId: 'noOutputRename',
-                        fix: (fixer) => fixer.remove(node),
+                        fix: (fixer) => fixer.removeRange(rangeToRemove),
                     });
                 }
                 else if (!isAliasNameAllowed(selectors, propertyName, aliasName)) {
@@ -52,12 +97,12 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                         suggest: [
                             {
                                 messageId: 'suggestRemoveAliasName',
-                                fix: (fixer) => fixer.remove(node),
+                                fix: (fixer) => fixer.removeRange(rangeToRemove),
                             },
                             {
                                 messageId: 'suggestReplaceOriginalNameWithAliasName',
                                 fix: (fixer) => [
-                                    fixer.remove(node),
+                                    fixer.removeRange(rangeToRemove),
                                     fixer.replaceText(propertyOrMethodDefinition.key, aliasName.includes('-') ? `'${aliasName}'` : aliasName),
                                 ],
                             },

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/dist/rules/prefer-standalone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-standalone.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-standalone.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC;AAC5C,eAAO,MAAM,SAAS,sBAAsB,CAAC;;AAI7C,wBAiEG"}
+{"version":3,"file":"prefer-standalone.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-standalone.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC;AAC5C,eAAO,MAAM,SAAS,sBAAsB,CAAC;;AAI7C,wBAkEG"}

package/dist/rules/prefer-standalone.js

@@ -12,6 +12,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         type: 'suggestion',
         docs: {
             description: `Ensures component, directive and pipe \`${METADATA_PROPERTY_NAME}\` property is set to \`${IS_STANDALONE}\` in the component decorator`,
+            recommended: 'recommended',
         },
         fixable: 'code',
         schema: [],

package/package.json

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