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

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

@@ -0,0 +1,172 @@
+"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-output-rename';
+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 are not aliased',
+            recommended: 'recommended',
+        },
+        fixable: 'code',
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            noOutputRename: `Output bindings should not be aliased (${STYLE_GUIDE_LINK})`,
+            suggestRemoveAliasName: 'Remove alias name',
+            suggestReplaceOriginalNameWithAliasName: 'Remove alias name and use it as the original name',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        let selectors = new Set();
+        return {
+            [utils_1.Selectors.COMPONENT_OR_DIRECTIVE_SELECTOR_LITERAL](node) {
+                selectors = new Set((0, utils_1.withoutBracketsAndWhitespaces)(utils_1.ASTUtils.getRawText(node)).split(','));
+            },
+            [utils_1.Selectors.OUTPUT_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);
+                // 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.removeRange(rangeToRemove),
+                    });
+                }
+                else if (!isAliasNameAllowed(selectors, propertyName, aliasName)) {
+                    context.report({
+                        node,
+                        messageId: 'noOutputRename',
+                        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.OUTPUTS_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 outputs 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)
+                    return;
+                if (aliasName === propertyName) {
+                    context.report({
+                        node,
+                        messageId: 'noOutputRename',
+                        fix: (fixer) => fixer.replaceText(node, utils_1.ASTUtils.getReplacementText(node, propertyName)),
+                    });
+                }
+                else if (!isAliasNameAllowed(selectors, propertyName, aliasName)) {
+                    context.report({
+                        node,
+                        messageId: 'noOutputRename',
+                        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) {
+    return [...selectors].some((selector) => {
+        return (selector === aliasName ||
+            composedName(selector, propertyName) === aliasName);
+    });
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Renaming outputs creates a confusing situation where the output has one name inside the component class (private name) and a different name in templates (public name). For example, with the @Output() decorator: '@Output(\"userDeleted\") delete = new EventEmitter()' means you call 'this.delete.emit()' in the component but bind with '(userDeleted)' in templates. Similarly, with the output() function: 'userDeleted = output({ alias: \"delete\" })' means you call 'this.userDeleted.emit()' internally but bind with '(delete)' 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-outputs-metadata-property.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noOutputsMetadataProperty';
+export declare const RULE_NAME = "no-outputs-metadata-property";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noOutputsMetadataProperty", [], 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-outputs-metadata-property.d.ts.map

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

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

package/dist/rules/no-outputs-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-outputs-metadata-property';
+const METADATA_PROPERTY_NAME = 'outputs';
+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: {
+            noOutputsMetadataProperty: `Use \`@Output\` 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 outputs 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: 'noOutputsMetadataProperty',
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Using the 'outputs' metadata property (@Component({ outputs: ['change'] })) is discouraged in favor of modern alternatives like the output() function (introduced in Angular v17.3) or the @Output() decorator. Modern approaches offer several benefits: (1) they make it immediately clear which properties are event emitters 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) output() uses OutputEmitterRef which provides better type safety and a more modern API than EventEmitter, and (5) @Output() decorator remains valid for EventEmitter-based outputs. 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 public API. For new code, prefer output() for its improved type safety or @Output() for traditional EventEmitter-based outputs.",
+};

package/dist/rules/no-pipe-impure.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noPipeImpure' | 'suggestRemovePipeImpure';
+export declare const RULE_NAME = "no-pipe-impure";
+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-pipe-impure.d.ts.map

package/dist/rules/no-pipe-impure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-pipe-impure.d.ts","sourceRoot":"","sources":["../../src/rules/no-pipe-impure.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,yBAAyB,CAAC;AACpE,eAAO,MAAM,SAAS,mBAAmB,CAAC;;;;AAE1C,wBAuCG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

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

@@ -0,0 +1,42 @@
+"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-pipe-impure';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallows the declaration of impure pipes',
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            noPipeImpure: 'Impure pipes should be avoided because they are invoked on each change-detection cycle',
+            suggestRemovePipeImpure: 'Remove `pure` property',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            [`${utils_1.Selectors.PIPE_CLASS_DECORATOR} ${utils_1.Selectors.metadataProperty('pure')}:matches([value.value=false], [value.operator='!'][value.argument.value=true])`](node) {
+                context.report({
+                    node,
+                    messageId: 'noPipeImpure',
+                    suggest: [
+                        {
+                            messageId: 'suggestRemovePipeImpure',
+                            fix: (fixer) => utils_1.RuleFixes.getNodeToCommaRemoveFix(sourceCode, node, fixer),
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `Impure pipes are executed on every change detection cycle, regardless of whether their inputs have changed. In a typical Angular application, change detection runs very frequently (on every user interaction, timer, HTTP request, etc.). An impure pipe in a template with a list of 100 items might execute 100 times per change detection cycle, potentially thousands of times per second, causing severe performance problems. Pure pipes (the default) only re-execute when their input references change, making them much more efficient. Impure pipes should be avoided unless you have a specific need and understand the performance implications. In most cases, you can achieve the same result with a pure pipe and proper change detection strategy.`,
+};

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

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noQueriesMetadataProperty';
+export declare const RULE_NAME = "no-queries-metadata-property";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noQueriesMetadataProperty", [], 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-queries-metadata-property.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-queries-metadata-property.d.ts","sourceRoot":"","sources":["../../src/rules/no-queries-metadata-property.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,2BAA2B,CAAC;AACrD,eAAO,MAAM,SAAS,iCAAiC,CAAC;;;;AAIxD,wBAiCG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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

@@ -0,0 +1,38 @@
+"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-queries-metadata-property';
+const METADATA_PROPERTY_NAME = 'queries';
+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.`,
+        },
+        schema: [],
+        messages: {
+            noQueriesMetadataProperty: `Use @${utils_1.ASTUtils.AngularInnerClassDecorators.Output} rather than the \`${METADATA_PROPERTY_NAME}\` metadata property`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR](node) {
+                const propertyExpression = utils_1.ASTUtils.getDecoratorPropertyValue(node, METADATA_PROPERTY_NAME);
+                if (!propertyExpression) {
+                    return;
+                }
+                context.report({
+                    node: propertyExpression.parent,
+                    messageId: 'noQueriesMetadataProperty',
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Using the 'queries' metadata property (@Component({ queries: { child: new ViewChild('ref') } })) is discouraged in favor of decorator syntax (@ViewChild('ref')) because: (1) decorators make it immediately clear which properties are view/content queries when reading the class, (2) decorators allow configuration right next to the property declaration, (3) decorator syntax works better with IDE features and TypeScript type checking, and (4) the decorator approach is the standard modern Angular pattern. The metadata property approach is a legacy pattern that makes code harder to read and maintain.",
+};

package/dist/rules/no-uncalled-signals.d.ts

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

package/dist/rules/no-uncalled-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-uncalled-signals.d.ts","sourceRoot":"","sources":["../../src/rules/no-uncalled-signals.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EAGZ,MAAM,0BAA0B,CAAC;AAIlC,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,mBAAmB,GAAG,mBAAmB,CAAC;AACnE,eAAO,MAAM,SAAS,wBAAwB,CAAC;;;;AAmB/C,wBAiFG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const signals_1 = require("../utils/signals");
+exports.RULE_NAME = 'no-uncalled-signals';
+const CONDITIONAL_SELECTOR = [
+    utils_1.AST_NODE_TYPES.ConditionalExpression,
+    utils_1.AST_NODE_TYPES.DoWhileStatement,
+    utils_1.AST_NODE_TYPES.ForStatement,
+    utils_1.AST_NODE_TYPES.IfStatement,
+    utils_1.AST_NODE_TYPES.SwitchCase,
+    utils_1.AST_NODE_TYPES.WhileStatement,
+].join(',');
+const FUNCTION_MEMBER_EXPRESSION_SELECTOR = `MemberExpression[property.type=Identifier]:matches(${[
+    'arguments',
+    'caller',
+    'length',
+    'name',
+    'toString',
+].map((member) => `[property.name=${member}]`)})`;
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: "Warns user about unintentionally doing logic on the signal, rather than the signal's value",
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            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: [],
+    create(context) {
+        const services = utils_1.ESLintUtils.getParserServices(context);
+        function checkForUncalledSignal(node) {
+            const type = services.getTypeAtLocation(node);
+            const symbol = type.getSymbol();
+            let isSignal = symbol && signals_1.KNOWN_SIGNAL_TYPES.has(symbol.name);
+            // If the type is not a known signal type, but it has an alias
+            // symbol, then check if that alias symbol is a known signal type.
+            // The `Signal` type will fall under this category, because it is
+            // defined as a type alias. Other signal types like `InputSignal`
+            // won't match here, because they are defined as interfaces.
+            if (!isSignal && type.aliasSymbol) {
+                isSignal = signals_1.KNOWN_SIGNAL_TYPES.has(type.aliasSymbol.name);
+            }
+            if (isSignal) {
+                context.report({
+                    node,
+                    messageId: 'noUncalledSignals',
+                    suggest: [
+                        {
+                            messageId: 'suggestCallSignal',
+                            fix: (fixer) => fixer.insertTextAfter(node, '()'),
+                        },
+                    ],
+                });
+            }
+        }
+        return {
+            [CONDITIONAL_SELECTOR](node) {
+                if (node.test) {
+                    checkForUncalledSignal(node.test);
+                }
+            },
+            UnaryExpression(node) {
+                if (node.operator !== 'delete') {
+                    checkForUncalledSignal(node.argument);
+                }
+            },
+            LogicalExpression(node) {
+                checkForUncalledSignal(node.left);
+                checkForUncalledSignal(node.right);
+            },
+            BinaryExpression(node) {
+                checkForUncalledSignal(node.left);
+                checkForUncalledSignal(node.right);
+            },
+            [FUNCTION_MEMBER_EXPRESSION_SELECTOR](node) {
+                checkForUncalledSignal(node.object);
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Angular signals are functions that must be called to retrieve their value. A common mistake, especially for developers new to signals, is to use the signal itself in conditional or logical expressions without calling it first. For example, 'if (mySignal)' checks if the signal function exists (which is always true), not whether the signal's value is truthy. You need 'if (mySignal())' to check the value. This bug is easy to make because signals look like regular properties but behave like functions. The mistake leads to logic errors where conditions always evaluate incorrectly. This rule catches these mistakes by detecting when signals are used in conditionals, comparisons, or logical operations without being called.",
+};

package/dist/rules/pipe-prefix.d.ts

@@ -0,0 +1,15 @@
+export type Options = [
+    {
+        prefixes: string[];
+    }
+];
+export type MessageIds = 'pipePrefix' | 'selectorAfterPrefixFailure';
+export declare const RULE_NAME = "pipe-prefix";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, 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=pipe-prefix.d.ts.map

package/dist/rules/pipe-prefix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe-prefix.d.ts","sourceRoot":"","sources":["../../src/rules/pipe-prefix.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,YAAY,GAAG,4BAA4B,CAAC;AACrE,eAAO,MAAM,SAAS,gBAAgB,CAAC;;;;AAEvC,wBAoGG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/pipe-prefix.js

@@ -0,0 +1,92 @@
+"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 = 'pipe-prefix';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce consistent prefix for pipes.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    prefixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            pipePrefix: '@Pipes should be prefixed with {{prefixes}}',
+            selectorAfterPrefixFailure: '@Pipes should have a selector after the {{prefixes}} prefix',
+        },
+    },
+    defaultOptions: [
+        {
+            prefixes: [],
+        },
+    ],
+    create(context, [{ prefixes }]) {
+        function checkValidOption(prefixes) {
+            return Array.isArray(prefixes) && prefixes.length > 0;
+        }
+        return {
+            [utils_1.Selectors.PIPE_CLASS_DECORATOR](node) {
+                const nameSelector = utils_1.ASTUtils.getDecoratorPropertyValue(node, 'name');
+                if (!nameSelector) {
+                    return;
+                }
+                const isValidOption = checkValidOption(prefixes);
+                if (!isValidOption) {
+                    return;
+                }
+                const allowPrefixesExpression = prefixes.join('|');
+                const prefixValidator = utils_1.SelectorUtils.SelectorValidator.prefix(allowPrefixesExpression, utils_1.ASTUtils.OPTION_STYLE_CAMEL_CASE);
+                const selectorAfterPrefixValidator = utils_1.SelectorUtils.SelectorValidator.selectorAfterPrefix(allowPrefixesExpression);
+                let nameValue;
+                if (utils_1.ASTUtils.isStringLiteral(nameSelector)) {
+                    nameValue = nameSelector.value;
+                }
+                else if (utils_1.ASTUtils.isTemplateLiteral(nameSelector) &&
+                    nameSelector.quasis[0]) {
+                    nameValue = nameSelector.quasis[0].value.raw;
+                }
+                if (!nameValue) {
+                    return;
+                }
+                if (!prefixValidator.apply(this, [nameValue])) {
+                    context.report({
+                        node: nameSelector,
+                        messageId: 'pipePrefix',
+                        data: {
+                            prefixes: (0, utils_1.toHumanReadableText)(prefixes),
+                        },
+                    });
+                    return;
+                }
+                if (!selectorAfterPrefixValidator.apply(this, [nameValue])) {
+                    context.report({
+                        node: nameSelector,
+                        messageId: 'selectorAfterPrefixFailure',
+                        data: {
+                            prefixes: (0, utils_1.toHumanReadableText)(prefixes),
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Prefixing pipe names helps prevent naming collisions between pipes from different libraries or modules, and makes it clear which pipes belong to your application versus third-party libraries. For example, prefixing with 'app' creates pipe names like 'appCurrency' instead of just 'currency', avoiding conflicts with Angular's built-in pipes.",
+};

package/dist/rules/prefer-host-metadata-property.d.ts

@@ -0,0 +1,10 @@
+export type MessageIds = 'preferHostMetadataPropertyForBinding' | 'preferHostMetadataPropertyForListener';
+export declare const RULE_NAME = "prefer-host-metadata-property";
+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=prefer-host-metadata-property.d.ts.map

package/dist/rules/prefer-host-metadata-property.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-host-metadata-property.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-host-metadata-property.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,UAAU,GAClB,sCAAsC,GACtC,uCAAuC,CAAC;AAC5C,eAAO,MAAM,SAAS,kCAAkC,CAAC;;;;AAEzD,wBAiCG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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

@@ -0,0 +1,40 @@
+"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 = 'prefer-host-metadata-property';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Use `host` metadata property instead of `@HostBinding` and `HostListener`',
+        },
+        schema: [],
+        messages: {
+            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: [],
+    create(context) {
+        return {
+            [utils_1.Selectors.HOST_BINDING_DECORATOR]: (node) => {
+                context.report({
+                    node,
+                    messageId: 'preferHostMetadataPropertyForBinding',
+                });
+            },
+            [utils_1.Selectors.HOST_LISTENER_DECORATOR]: (node) => {
+                context.report({
+                    node,
+                    messageId: 'preferHostMetadataPropertyForListener',
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: 'Using the host metadata property in the @Component or @Directive decorator instead of separate @HostBinding and @HostListener decorators consolidates all host-related bindings in one place, making it easier to see all DOM interactions at a glance. The host property approach is generally more concise and keeps component metadata organized. With decorators, host bindings and listeners are scattered throughout the class on individual properties and methods, requiring developers to hunt through the file to understand all host interactions. The centralized host property makes this information immediately visible in the decorator metadata. This is particularly helpful during code reviews and when onboarding new team members who need to understand how a component interacts with its host element. Prior to Angular v20, the Angular team actually recommended using the decorators, partly because the decorators had better IDE support for typechecking. That is no longer the case and the Angular documentation clearly states that the host metadata should be used and that the decorators are purely still there for backwards compatibility.',
+};

package/dist/rules/prefer-inject.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'preferInject';
+export declare const RULE_NAME = "prefer-inject";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferInject", [], 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=prefer-inject.d.ts.map