@angular-eslint/eslint-plugin 15.2.2-alpha.9 → 16.0.0-alpha.0

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

@@ -0,0 +1,175 @@
+"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");
+exports.RULE_NAME = 'no-input-rename';
+const STYLE_GUIDE_LINK = 'https://angular.io/guide/styleguide#style-05-13';
+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: 'error',
+        },
+        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;
+                }
+                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) ||
+                    (ariaAttributeKeys.has(aliasName) &&
+                        propertyName === (0, utils_1.kebabToCamelCase)(aliasName))) {
+                    return;
+                }
+                if (aliasName === propertyName) {
+                    context.report({
+                        node,
+                        messageId: 'noInputRename',
+                        fix: (fixer) => {
+                            if (node.parent && isAliasMetadataProperty) {
+                                return fixer.remove(node.parent);
+                            }
+                            return fixer.remove(node);
+                        },
+                    });
+                }
+                else if (!isAliasNameAllowed(selectors, propertyName, aliasName, selectorDirectiveName)) {
+                    context.report({
+                        node,
+                        messageId: 'noInputRename',
+                        suggest: [
+                            {
+                                messageId: 'suggestRemoveAliasName',
+                                fix: (fixer) => {
+                                    if (node.parent && isAliasMetadataProperty) {
+                                        return fixer.remove(node.parent);
+                                    }
+                                    return fixer.remove(node);
+                                },
+                            },
+                            {
+                                messageId: 'suggestReplaceOriginalNameWithAliasName',
+                                fix: (fixer) => [
+                                    fixer.remove(node),
+                                    fixer.replaceText(propertyOrMethodDefinition.key, aliasName.includes('-') ? `'${aliasName}'` : aliasName),
+                                ],
+                            },
+                        ],
+                    });
+                }
+            },
+            [utils_1.Selectors.INPUTS_METADATA_PROPERTY_LITERAL](node) {
+                var _a, _b, _c, _d;
+                const ancestorMaybeHostDirectiveAPI = (_d = (_c = (_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.parent;
+                if (ancestorMaybeHostDirectiveAPI &&
+                    utils_1.ASTUtils.isProperty(ancestorMaybeHostDirectiveAPI)) {
+                    /**
+                     * Angular v15 introduced the directive composition API: https://angular.io/guide/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);
+    });
+}

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

@@ -0,0 +1,52 @@
+"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");
+exports.RULE_NAME = 'no-inputs-metadata-property';
+const METADATA_PROPERTY_NAME = 'inputs';
+const STYLE_GUIDE_LINK = 'https://angular.io/styleguide#style-05-12';
+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. See more at ${STYLE_GUIDE_LINK}`,
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noInputsMetadataProperty: `Use \`@Input\` rather than the \`${METADATA_PROPERTY_NAME}\` metadata property (${STYLE_GUIDE_LINK})`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [`${utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} ${utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME)}`](node) {
+                var _a, _b;
+                /**
+                 * Angular v15 introduced the directive composition API: https://angular.io/guide/directive-composition-api
+                 * Using host directive inputs using this API is not a bad practice and should not be reported
+                 */
+                const ancestorMayBeHostDirectiveAPI = (_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.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',
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,47 @@
+"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");
+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',
+            recommended: false,
+        },
+        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));
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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: 'error',
+        },
+        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',
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.io/guide/styleguide#style-05-16';
+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: 'error',
+        },
+        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',
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,107 @@
+"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");
+exports.RULE_NAME = 'no-output-rename';
+const STYLE_GUIDE_LINK = 'https://angular.io/guide/styleguide#style-05-13';
+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: 'error',
+        },
+        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);
+                if (aliasName === propertyName) {
+                    context.report({
+                        node,
+                        messageId: 'noOutputRename',
+                        fix: (fixer) => fixer.remove(node),
+                    });
+                }
+                else if (!isAliasNameAllowed(selectors, propertyName, aliasName)) {
+                    context.report({
+                        node,
+                        messageId: 'noOutputRename',
+                        suggest: [
+                            {
+                                messageId: 'suggestRemoveAliasName',
+                                fix: (fixer) => fixer.remove(node),
+                            },
+                            {
+                                messageId: 'suggestReplaceOriginalNameWithAliasName',
+                                fix: (fixer) => [
+                                    fixer.remove(node),
+                                    fixer.replaceText(propertyOrMethodDefinition.key, aliasName.includes('-') ? `'${aliasName}'` : aliasName),
+                                ],
+                            },
+                        ],
+                    });
+                }
+            },
+            [utils_1.Selectors.OUTPUTS_METADATA_PROPERTY_LITERAL](node) {
+                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);
+    });
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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-outputs-metadata-property';
+const METADATA_PROPERTY_NAME = 'outputs';
+const STYLE_GUIDE_LINK = 'https://angular.io/styleguide#style-05-12';
+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. See more at ${STYLE_GUIDE_LINK}`,
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noOutputsMetadataProperty: `Use \`@Output\` rather than the \`${METADATA_PROPERTY_NAME}\` metadata property (${STYLE_GUIDE_LINK})`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [`${utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} ${utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME)}`](node) {
+                context.report({
+                    node,
+                    messageId: 'noOutputsMetadataProperty',
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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',
+            recommended: false,
+        },
+        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.getSourceCode();
+        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),
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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';
+const STYLE_GUIDE_LINK = 'https://angular.io/styleguide#style-05-12';
+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. See more at ${STYLE_GUIDE_LINK}.`,
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            noQueriesMetadataProperty: `Use @${utils_1.ASTUtils.AngularInnerClassDecorators.Output} rather than the \`${METADATA_PROPERTY_NAME}\` metadata property (${STYLE_GUIDE_LINK})`,
+        },
+    },
+    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',
+                });
+            },
+        };
+    },
+});

package/dist/rules/pipe-prefix.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.',
+            recommended: false,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    prefixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                        minimum: 1,
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            pipePrefix: '@Pipes should be prefixed by {{prefixes}}',
+        },
+    },
+    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, 'camelCase');
+                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),
+                        },
+                    });
+                }
+            },
+        };
+    },
+});