@depup/angular-eslint__eslint-plugin 21.3.1-depup.0

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

@@ -0,0 +1,213 @@
+"use strict";
+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 create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-input-rename';
+const STYLE_GUIDE_LINK = 'https://angular.dev/guide/components/inputs#choosing-input-names';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that input bindings are not aliased',
+            recommended: 'recommended',
+        },
+        fixable: 'code',
+        hasSuggestions: true,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowedNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                        description: 'A list with allowed input names',
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noInputRename: `Input bindings should not be aliased (${STYLE_GUIDE_LINK})`,
+            suggestRemoveAliasName: 'Remove alias name',
+            suggestReplaceOriginalNameWithAliasName: 'Remove alias name and use it as the original name',
+        },
+    },
+    defaultOptions: [{ allowedNames: [] }],
+    create(context, [{ allowedNames = [] }]) {
+        let selectors = new Set();
+        const ariaAttributeKeys = (0, utils_1.getAriaAttributeKeys)();
+        let selectorDirectiveName;
+        return {
+            [utils_1.Selectors.COMPONENT_OR_DIRECTIVE_SELECTOR_LITERAL](node) {
+                const nodeRawText = utils_1.ASTUtils.getRawText(node);
+                const bracketMatchResults = nodeRawText.match(/\[(.*?)\]/);
+                if (bracketMatchResults) {
+                    selectorDirectiveName = bracketMatchResults[1];
+                }
+                selectors = new Set((0, utils_1.withoutBracketsAndWhitespaces)(nodeRawText).split(','));
+            },
+            [utils_1.Selectors.INPUT_ALIAS](node) {
+                const propertyOrMethodDefinition = utils_1.ASTUtils.getNearestNodeFrom(node, utils_1.ASTUtils.isPropertyOrMethodDefinition);
+                if (!propertyOrMethodDefinition ||
+                    !utils_2.ASTUtils.isIdentifier(propertyOrMethodDefinition.key)) {
+                    return;
+                }
+                const aliasName = utils_1.ASTUtils.getRawText(node);
+                const propertyName = utils_1.ASTUtils.getRawText(propertyOrMethodDefinition.key);
+                if (allowedNames.includes(aliasName) ||
+                    (ariaAttributeKeys.has(aliasName) &&
+                        propertyName === (0, utils_1.kebabToCamelCase)(aliasName))) {
+                    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) => fixer.removeRange(rangeToRemove),
+                    });
+                }
+                else if (!isAliasNameAllowed(selectors, propertyName, aliasName, selectorDirectiveName)) {
+                    context.report({
+                        node,
+                        messageId: 'noInputRename',
+                        suggest: [
+                            {
+                                messageId: 'suggestRemoveAliasName',
+                                fix: (fixer) => fixer.removeRange(rangeToRemove),
+                            },
+                            {
+                                messageId: 'suggestReplaceOriginalNameWithAliasName',
+                                fix: (fixer) => [
+                                    fixer.removeRange(rangeToRemove),
+                                    fixer.replaceText(propertyOrMethodDefinition.key, aliasName.includes('-') ? `'${aliasName}'` : aliasName),
+                                ],
+                            },
+                        ],
+                    });
+                }
+            },
+            [utils_1.Selectors.INPUTS_METADATA_PROPERTY_LITERAL](node) {
+                const ancestorMaybeHostDirectiveAPI = node.parent?.parent?.parent?.parent?.parent;
+                if (ancestorMaybeHostDirectiveAPI &&
+                    utils_1.ASTUtils.isProperty(ancestorMaybeHostDirectiveAPI)) {
+                    /**
+                     * Angular v15 introduced the directive composition API: https://angular.dev/guide/directives/directive-composition-api
+                     * Renaming host directive inputs using this API is not a bad practice and should not be reported
+                     */
+                    const hostDirectiveAPIPropertyName = 'hostDirectives';
+                    if ((utils_1.ASTUtils.isLiteral(ancestorMaybeHostDirectiveAPI.key) &&
+                        ancestorMaybeHostDirectiveAPI.key.value ===
+                            hostDirectiveAPIPropertyName) ||
+                        (utils_2.ASTUtils.isIdentifier(ancestorMaybeHostDirectiveAPI.key) &&
+                            ancestorMaybeHostDirectiveAPI.key.name ===
+                                hostDirectiveAPIPropertyName)) {
+                        return;
+                    }
+                }
+                const [propertyName, aliasName] = (0, utils_1.withoutBracketsAndWhitespaces)(utils_1.ASTUtils.getRawText(node)).split(':');
+                if (!aliasName ||
+                    allowedNames.includes(aliasName) ||
+                    (ariaAttributeKeys.has(aliasName) &&
+                        propertyName === (0, utils_1.kebabToCamelCase)(aliasName))) {
+                    return;
+                }
+                if (aliasName === propertyName) {
+                    context.report({
+                        node,
+                        messageId: 'noInputRename',
+                        fix: (fixer) => fixer.replaceText(node, utils_1.ASTUtils.getReplacementText(node, propertyName)),
+                    });
+                }
+                else if (!isAliasNameAllowed(selectors, propertyName, aliasName, selectorDirectiveName)) {
+                    context.report({
+                        node,
+                        messageId: 'noInputRename',
+                        suggest: [
+                            ['suggestRemoveAliasName', propertyName],
+                            ['suggestReplaceOriginalNameWithAliasName', aliasName],
+                        ].map(([messageId, name]) => ({
+                            messageId,
+                            fix: (fixer) => fixer.replaceText(node, utils_1.ASTUtils.getReplacementText(node, name)),
+                        })),
+                    });
+                }
+            },
+            'ClassDeclaration:exit'() {
+                selectors = new Set();
+            },
+        };
+    },
+});
+function composedName(selector, propertyName) {
+    return `${selector}${(0, utils_1.capitalize)(propertyName)}`;
+}
+function isAliasNameAllowed(selectors, propertyName, aliasName, selectorDirectiveName) {
+    return [...selectors].some((selector) => {
+        return (selector === aliasName ||
+            selectorDirectiveName === aliasName ||
+            composedName(selector, propertyName) === aliasName);
+    });
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Renaming inputs creates a confusing situation where the property has one name inside the component class (private name) and a different name in templates (public name). For example, with the @Input() decorator: '@Input(\"userName\") name: string' means you access 'this.name' in the component but bind with '[userName]' in templates. Similarly, with the signal-based input() function: 'userName = input<string>({ alias: \"name\" })' means you access 'this.userName()' internally but bind with '[name]' in templates. This dual naming makes the code harder to understand, complicates refactoring, and can cause bugs when developers forget which name to use in which context. Keep the internal and external names the same unless you have a strong reason for the mismatch.",
+};

package/dist/rules/no-inputs-metadata-property.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noInputsMetadataProperty';
+export declare const RULE_NAME = "no-inputs-metadata-property";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInputsMetadataProperty", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=no-inputs-metadata-property.d.ts.map

package/dist/rules/no-inputs-metadata-property.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-inputs-metadata-property.d.ts","sourceRoot":"","sources":["../../src/rules/no-inputs-metadata-property.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,0BAA0B,CAAC;AACpD,eAAO,MAAM,SAAS,gCAAgC,CAAC;;;;AAGvD,wBAoDG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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

@@ -0,0 +1,53 @@
+"use strict";
+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 create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-inputs-metadata-property';
+const METADATA_PROPERTY_NAME = 'inputs';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Disallows usage of the \`${METADATA_PROPERTY_NAME}\` metadata property`,
+            recommended: 'recommended',
+        },
+        schema: [],
+        messages: {
+            noInputsMetadataProperty: `Use \`@Input\` rather than the \`${METADATA_PROPERTY_NAME}\` metadata property`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [`${utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} ${utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME)}`](node) {
+                /**
+                 * Angular v15 introduced the directive composition API: https://angular.dev/guide/directives/directive-composition-api
+                 * Using host directive inputs using this API is not a bad practice and should not be reported
+                 */
+                const ancestorMayBeHostDirectiveAPI = node.parent?.parent?.parent;
+                if (ancestorMayBeHostDirectiveAPI &&
+                    utils_1.ASTUtils.isProperty(ancestorMayBeHostDirectiveAPI)) {
+                    const hostDirectiveAPIPropertyName = 'hostDirectives';
+                    if ((utils_1.ASTUtils.isLiteral(ancestorMayBeHostDirectiveAPI.key) &&
+                        ancestorMayBeHostDirectiveAPI.key.value ===
+                            hostDirectiveAPIPropertyName) ||
+                        (utils_2.ASTUtils.isIdentifier(ancestorMayBeHostDirectiveAPI.key) &&
+                            ancestorMayBeHostDirectiveAPI.key.name ===
+                                hostDirectiveAPIPropertyName)) {
+                        return;
+                    }
+                }
+                context.report({
+                    node,
+                    messageId: 'noInputsMetadataProperty',
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Using the 'inputs' metadata property (@Component({ inputs: ['name'] })) is discouraged in favor of modern alternatives like the signal-based input() function (introduced in Angular v17.1) or the @Input() decorator. Modern approaches offer several benefits: (1) they make it immediately clear which properties are part of the component's API when reading the class, (2) configuration happens in one place right next to the property, (3) they work better with IDE features like Find References and Rename Refactoring, (4) input() provides signal-based reactivity with built-in features like required inputs, transforms, and aliases, and (5) @Input() decorator offers similar features for non-signal inputs. The metadata property approach is a legacy pattern that obscures the component's interface and requires looking in two places (decorator metadata and class body) to understand the component's API. For new code, prefer input() for signal-based reactivity or @Input() for traditional inputs.",
+};

package/dist/rules/no-lifecycle-call.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noLifecycleCall';
+export declare const RULE_NAME = "no-lifecycle-call";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLifecycleCall", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=no-lifecycle-call.d.ts.map

package/dist/rules/no-lifecycle-call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-lifecycle-call.d.ts","sourceRoot":"","sources":["../../src/rules/no-lifecycle-call.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,iBAAiB,CAAC;AAC3C,eAAO,MAAM,SAAS,sBAAsB,CAAC;;;;AAE7C,wBAwCG;AAsBH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

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

@@ -0,0 +1,49 @@
+"use strict";
+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 create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-lifecycle-call';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallows explicit calls to lifecycle methods',
+        },
+        schema: [],
+        messages: {
+            noLifecycleCall: 'Avoid explicit calls to lifecycle methods',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const angularLifeCycleMethodsPattern = (0, utils_1.toPattern)([
+            ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,
+        ]);
+        return {
+            [`ClassDeclaration CallExpression > MemberExpression[property.name=${angularLifeCycleMethodsPattern}]`]: (node) => {
+                const classDeclaration = utils_1.ASTUtils.getNearestNodeFrom(node, utils_1.ASTUtils.isClassDeclaration);
+                if (!classDeclaration ||
+                    !utils_1.ASTUtils.getAngularClassDecorator(classDeclaration) ||
+                    (utils_1.ASTUtils.isSuper(node.object) && isSuperCallAllowed(node))) {
+                    return;
+                }
+                context.report({ node: node.parent, messageId: 'noLifecycleCall' });
+            },
+        };
+    },
+});
+function hasSameName({ property }, { key }) {
+    return (utils_2.ASTUtils.isIdentifier(property) &&
+        utils_2.ASTUtils.isIdentifier(key) &&
+        property.name === key.name);
+}
+function isSuperCallAllowed(node) {
+    const methodDefinition = utils_1.ASTUtils.getNearestNodeFrom(node, utils_1.ASTUtils.isMethodDefinition);
+    return Boolean(methodDefinition && hasSameName(node, methodDefinition));
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `Lifecycle hooks like ngOnInit(), ngOnDestroy(), and ngOnChanges() are designed to be called automatically by Angular at the appropriate times in a component's lifecycle. Calling them manually (e.g., 'this.ngOnInit()') breaks Angular's lifecycle management, can cause hooks to run multiple times or in the wrong order, and makes the code's execution flow harder to understand. The only exception is calling super.ngOnInit() in a derived class to ensure the parent class's initialization runs. If you need to share initialization logic, extract it into a separate method that both ngOnInit() and your other code can call.`,
+};

package/dist/rules/no-output-native.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noOutputNative';
+export declare const RULE_NAME = "no-output-native";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noOutputNative", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=no-output-native.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-output-native.d.ts","sourceRoot":"","sources":["../../src/rules/no-output-native.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAC1C,eAAO,MAAM,SAAS,qBAAqB,CAAC;;;;AAE5C,wBA8CG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-output-native';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that output bindings, including aliases, are not named as standard DOM events',
+            recommended: 'recommended',
+        },
+        schema: [],
+        messages: {
+            noOutputNative: 'Output bindings, including aliases, should not be named as standard DOM events',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const nativeEventNames = (0, utils_1.getNativeEventNames)();
+        const selectors = [
+            utils_1.Selectors.OUTPUTS_METADATA_PROPERTY_LITERAL,
+            utils_1.Selectors.OUTPUT_ALIAS,
+            utils_1.Selectors.OUTPUT_PROPERTY_OR_GETTER,
+        ].join(',');
+        return {
+            [selectors](node) {
+                const [propertyName, aliasName] = utils_1.ASTUtils.getRawText(node)
+                    .replace(/\s/g, '')
+                    .split(':');
+                if (!nativeEventNames.has(propertyName) &&
+                    !nativeEventNames.has(aliasName)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'noOutputNative',
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `Naming an @Output() the same as a native DOM event (like 'click', 'change', or 'blur') creates ambiguous and confusing template bindings. For example, if a component has '@Output() click', the template '(click)="handler()"' could be binding to either the component's custom output OR the native DOM click event, depending on the context. This ambiguity leads to bugs and makes code harder to understand. Instead, use descriptive names that clearly indicate these are custom component events, such as 'userSelected' or 'itemDeleted' instead of generic names like 'click' or 'select'.`,
+};

package/dist/rules/no-output-on-prefix.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noOutputOnPrefix';
+export declare const RULE_NAME = "no-output-on-prefix";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noOutputOnPrefix", [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=no-output-on-prefix.d.ts.map

package/dist/rules/no-output-on-prefix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-output-on-prefix.d.ts","sourceRoot":"","sources":["../../src/rules/no-output-on-prefix.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC;AAC5C,eAAO,MAAM,SAAS,wBAAwB,CAAC;;;;AAI/C,wBA4CG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-output-on-prefix';
+const STYLE_GUIDE_LINK = 'https://angular.dev/guide/components/outputs#choosing-event-names';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Ensures that output bindings, including aliases, are not named "on", nor prefixed with it. See more at ${STYLE_GUIDE_LINK}`,
+            recommended: 'recommended',
+        },
+        schema: [],
+        messages: {
+            noOutputOnPrefix: `Output bindings, including aliases, should not be named "on", nor prefixed with it (${STYLE_GUIDE_LINK})`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const outputOnPattern = /^on(([^a-z])|(?=$))/;
+        const selectors = [
+            utils_1.Selectors.OUTPUTS_METADATA_PROPERTY_LITERAL,
+            utils_1.Selectors.OUTPUT_ALIAS,
+            utils_1.Selectors.OUTPUT_PROPERTY_OR_GETTER,
+        ].join(',');
+        return {
+            [selectors](node) {
+                const [propertyName, aliasName] = utils_1.ASTUtils.getRawText(node)
+                    .replace(/\s/g, '')
+                    .split(':');
+                if (!outputOnPattern.test(propertyName) &&
+                    !outputOnPattern.test(aliasName)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'noOutputOnPrefix',
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Angular's template syntax allows both '(eventName)' and 'on-eventName' for event bindings. If you prefix an output with 'on', this creates awkward template syntax like '(onUserClick)' or the even more redundant 'on-onUserClick'. This violates the principle of least surprise and makes templates harder to read. Instead, name outputs as simple actions or events (like 'userClick'), which Angular templates will bind as '(userClick)' or 'on-userClick'.",
+};

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

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noOutputRename' | 'suggestRemoveAliasName' | 'suggestReplaceOriginalNameWithAliasName';
+export declare const RULE_NAME = "no-output-rename";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;
+export declare const RULE_DOCS_EXTENSION: {
+    rationale: string;
+};
+//# sourceMappingURL=no-output-rename.d.ts.map

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

@@ -0,0 +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;;;;AAI5C,wBAgMG;AAmBH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}