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

package/dist/rules/contextual-lifecycle.js

@@ -0,0 +1,58 @@
+"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 = 'contextual-lifecycle';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensures that lifecycle methods are used in a correct context',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            contextualLifecycle: `Angular will not invoke the \`{{methodName}}\` lifecycle method within \`@{{classDecoratorName}}()\` classes`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function checkContext({ parent }, decorator) {
+            const classDeclaration = parent;
+            const allowedMethods = utils_1.ASTUtils.ANGULAR_CLASS_DECORATOR_LIFECYCLE_METHOD_MAPPER.get(decorator);
+            const declaredMethods = utils_1.ASTUtils.getDeclaredMethods(classDeclaration);
+            for (const method of declaredMethods) {
+                const methodName = utils_1.ASTUtils.getMethodName(method);
+                if (!methodName ||
+                    !utils_1.ASTUtils.isAngularLifecycleMethod(methodName) ||
+                    (allowedMethods === null || allowedMethods === void 0 ? void 0 : allowedMethods.has(methodName))) {
+                    continue;
+                }
+                context.report({
+                    node: method.key,
+                    messageId: 'contextualLifecycle',
+                    data: { classDecoratorName: decorator, methodName },
+                });
+            }
+        }
+        return {
+            [utils_1.Selectors.COMPONENT_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.Component);
+            },
+            [utils_1.Selectors.DIRECTIVE_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.Directive);
+            },
+            [utils_1.Selectors.INJECTABLE_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.Injectable);
+            },
+            [utils_1.Selectors.MODULE_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.NgModule);
+            },
+            [utils_1.Selectors.PIPE_CLASS_DECORATOR](node) {
+                checkContext(node, utils_1.ASTUtils.AngularClassDecorators.Pipe);
+            },
+        };
+    },
+});

package/dist/rules/directive-class-suffix.js

@@ -0,0 +1,60 @@
+"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 = 'directive-class-suffix';
+const STYLE_GUIDE_LINK = 'https://angular.io/styleguide#style-02-03';
+const DEFAULT_SUFFIXES = ['Directive'];
+const VALIDATOR_SUFFIX = 'Validator';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Classes decorated with @Directive must have suffix "Directive" (or custom) in their name. See more at ${STYLE_GUIDE_LINK}`,
+            recommended: 'error',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    suffixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            directiveClassSuffix: `Directive class names should end with one of these suffixes: {{suffixes}} (${STYLE_GUIDE_LINK})`,
+        },
+    },
+    defaultOptions: [{ suffixes: DEFAULT_SUFFIXES }],
+    create(context, [{ suffixes }]) {
+        return {
+            [utils_1.Selectors.DIRECTIVE_CLASS_DECORATOR](node) {
+                var _a;
+                const selectorPropertyValue = utils_1.ASTUtils.getDecoratorPropertyValue(node, 'selector');
+                if (!selectorPropertyValue)
+                    return;
+                const classParent = node.parent;
+                const className = utils_1.ASTUtils.getClassName(classParent);
+                const declaredInterfaceNames = utils_1.ASTUtils.getDeclaredInterfaceNames(classParent);
+                const hasValidatorInterface = declaredInterfaceNames.some((interfaceName) => interfaceName.endsWith(VALIDATOR_SUFFIX));
+                const allSuffixes = suffixes.concat(hasValidatorInterface ? VALIDATOR_SUFFIX : []);
+                if (!className ||
+                    !allSuffixes.some((suffix) => className.endsWith(suffix))) {
+                    context.report({
+                        node: (_a = classParent.id) !== null && _a !== void 0 ? _a : classParent,
+                        messageId: 'directiveClassSuffix',
+                        data: { suffixes: (0, utils_1.toHumanReadableText)(allSuffixes) },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/directive-selector.js

@@ -0,0 +1,89 @@
+"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 = 'directive-selector';
+const STYLE_GUIDE_PREFIX_LINK = 'https://angular.io/guide/styleguide#style-02-08';
+const STYLE_GUIDE_STYLE_TYPE_LINK = 'https://angular.io/guide/styleguide#style-02-06';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Directive selectors should follow given naming rules. See more at ${STYLE_GUIDE_STYLE_TYPE_LINK} and ${STYLE_GUIDE_PREFIX_LINK}.`,
+            recommended: false,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    type: {
+                        oneOf: [
+                            { type: 'string' },
+                            {
+                                type: 'array',
+                                items: {
+                                    enum: [
+                                        utils_1.SelectorUtils.OPTION_TYPE_ELEMENT,
+                                        utils_1.SelectorUtils.OPTION_TYPE_ATTRIBUTE,
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                    prefix: {
+                        oneOf: [{ type: 'string' }, { type: 'array' }],
+                    },
+                    style: {
+                        type: 'string',
+                        enum: [
+                            utils_1.ASTUtils.OPTION_STYLE_CAMEL_CASE,
+                            utils_1.ASTUtils.OPTION_STYLE_KEBAB_CASE,
+                        ],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            prefixFailure: `The selector should start with one of these prefixes: {{prefix}} (${STYLE_GUIDE_PREFIX_LINK})`,
+            styleFailure: `The selector should be {{style}} (${STYLE_GUIDE_STYLE_TYPE_LINK})`,
+            typeFailure: `The selector should be used as an {{type}} (${STYLE_GUIDE_STYLE_TYPE_LINK})`,
+        },
+    },
+    defaultOptions: [
+        {
+            type: '',
+            prefix: '',
+            style: '',
+        },
+    ],
+    create(context, [{ type, prefix, style }]) {
+        return {
+            [utils_1.Selectors.DIRECTIVE_CLASS_DECORATOR](node) {
+                const rawSelectors = utils_1.ASTUtils.getDecoratorPropertyValue(node, 'selector');
+                if (!rawSelectors) {
+                    return;
+                }
+                const isValidOptions = utils_1.SelectorUtils.checkValidOptions(type, prefix, style);
+                if (!isValidOptions) {
+                    return;
+                }
+                const hasExpectedSelector = utils_1.SelectorUtils.checkSelector(rawSelectors, type, (0, utils_1.arrayify)(prefix), style);
+                if (hasExpectedSelector === null) {
+                    return;
+                }
+                if (!hasExpectedSelector.hasExpectedType) {
+                    utils_1.SelectorUtils.reportTypeError(rawSelectors, type, context);
+                }
+                else if (!hasExpectedSelector.hasExpectedStyle) {
+                    utils_1.SelectorUtils.reportStyleError(rawSelectors, style, context);
+                }
+                else if (!hasExpectedSelector.hasExpectedPrefix) {
+                    utils_1.SelectorUtils.reportPrefixError(rawSelectors, prefix, context);
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-attribute-decorator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-attribute-decorator';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `The @Attribute decorator is used to obtain a single value for an attribute. This is a much less common use-case than getting a stream of values (using @Input), so often the @Attribute decorator is mistakenly used when @Input was what was intended. This rule disallows usage of @Attribute decorator altogether in order to prevent these mistakes.`,
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            noAttributeDecorator: '@Attribute can only obtain a single value and is rarely what is required. Use @Input instead to retrieve a stream of values.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            'ClassDeclaration MethodDefinition[key.name="constructor"] Decorator[expression.callee.name="Attribute"]'(node) {
+                context.report({
+                    node,
+                    messageId: 'noAttributeDecorator',
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,71 @@
+"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-conflicting-lifecycle';
+const LIFECYCLE_INTERFACES = [
+    utils_1.ASTUtils.AngularLifecycleInterfaces.DoCheck,
+    utils_1.ASTUtils.AngularLifecycleInterfaces.OnChanges,
+];
+const LIFECYCLE_METHODS = [
+    utils_1.ASTUtils.AngularLifecycleMethods.ngDoCheck,
+    utils_1.ASTUtils.AngularLifecycleMethods.ngOnChanges,
+];
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that directives not implement conflicting lifecycle interfaces.',
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            noConflictingLifecycleInterface: `Implementing ${utils_1.ASTUtils.AngularLifecycleInterfaces.DoCheck} and ${utils_1.ASTUtils.AngularLifecycleInterfaces.OnChanges} in a class is not recommended`,
+            noConflictingLifecycleMethod: `Declaring ${utils_1.ASTUtils.AngularLifecycleMethods.ngDoCheck} and ${utils_1.ASTUtils.AngularLifecycleMethods.ngOnChanges} method in a class is not recommended`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const validateInterfaces = (node) => {
+            const declaredAngularLifecycleInterfaces = utils_1.ASTUtils.getDeclaredAngularLifecycleInterfaces(node);
+            const hasInterfaceConflictingLifecycle = LIFECYCLE_INTERFACES.every((lifecycleInterface) => declaredAngularLifecycleInterfaces.includes(lifecycleInterface));
+            if (!hasInterfaceConflictingLifecycle)
+                return;
+            const declaredInterfaces = utils_1.ASTUtils.getInterfaces(node);
+            const declaredAngularLifecycleInterfacesNodes = declaredInterfaces.filter((node) => {
+                const interfaceName = utils_1.ASTUtils.getInterfaceName(node);
+                return (interfaceName && utils_1.ASTUtils.isAngularLifecycleInterface(interfaceName));
+            });
+            for (const interFaceNode of declaredAngularLifecycleInterfacesNodes) {
+                context.report({
+                    node: interFaceNode,
+                    messageId: 'noConflictingLifecycleInterface',
+                });
+            }
+        };
+        const validateMethods = (node) => {
+            const declaredAngularLifecycleMethods = utils_1.ASTUtils.getDeclaredAngularLifecycleMethods(node);
+            const hasMethodConflictingLifecycle = LIFECYCLE_METHODS.every((lifecycleMethod) => declaredAngularLifecycleMethods.includes(lifecycleMethod));
+            if (!hasMethodConflictingLifecycle)
+                return;
+            const declaredMethods = utils_1.ASTUtils.getDeclaredMethods(node);
+            const declaredAngularLifecycleMethodNodes = declaredMethods.filter((node) => utils_2.ASTUtils.isIdentifier(node.key) &&
+                utils_1.ASTUtils.isAngularLifecycleMethod(node.key.name));
+            for (const method of declaredAngularLifecycleMethodNodes) {
+                context.report({
+                    node: method,
+                    messageId: 'noConflictingLifecycleMethod',
+                });
+            }
+        };
+        return {
+            ClassDeclaration(node) {
+                validateInterfaces(node);
+                validateMethods(node);
+            },
+        };
+    },
+});

package/dist/rules/no-empty-lifecycle-method.js

@@ -0,0 +1,66 @@
+"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-empty-lifecycle-method';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallows declaring empty lifecycle methods',
+            recommended: 'error',
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            noEmptyLifecycleMethod: 'Lifecycle methods should not be empty',
+            suggestRemoveLifecycleMethod: 'Remove lifecycle method',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        const angularLifecycleMethodsPattern = (0, utils_1.toPattern)([
+            ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,
+        ]);
+        return {
+            [`ClassDeclaration:has(Decorator[expression.callee.name=/^(Component|Directive|Injectable|NgModule|Pipe)$/]) > ClassBody > ${utils_1.Selectors.methodDefinition(angularLifecycleMethodsPattern)}[value.body.body.length=0]`](node) {
+                context.report({
+                    node,
+                    messageId: 'noEmptyLifecycleMethod',
+                    suggest: [
+                        {
+                            messageId: 'suggestRemoveLifecycleMethod',
+                            fix: (fixer) => {
+                                var _a;
+                                const importDeclarations = (_a = utils_1.ASTUtils.getImportDeclarations(node, '@angular/core')) !== null && _a !== void 0 ? _a : [];
+                                const interfaceName = utils_1.ASTUtils.getRawText(node).replace(/^ng+/, '');
+                                const text = sourceCode.getText();
+                                const totalInterfaceOccurrences = getTotalInterfaceOccurrences(text, interfaceName);
+                                const totalInterfaceOccurrencesSafeForRemoval = 2;
+                                return [
+                                    fixer.remove(node),
+                                    utils_1.RuleFixes.getImplementsRemoveFix(sourceCode, node.parent.parent, interfaceName, fixer),
+                                    totalInterfaceOccurrences <=
+                                        totalInterfaceOccurrencesSafeForRemoval
+                                        ? utils_1.RuleFixes.getImportRemoveFix(sourceCode, importDeclarations, interfaceName, fixer)
+                                        : null,
+                                ].filter(utils_1.isNotNullOrUndefined);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});
+function stripSpecialCharacters(text) {
+    return text.replace(/[\W]/g, '');
+}
+function getTotalInterfaceOccurrences(text, interfaceName) {
+    return text
+        .split(' ')
+        .filter((item) => stripSpecialCharacters(item) === interfaceName).length;
+}

package/dist/rules/no-forward-ref.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORWARD_REF = exports.RULE_NAME = void 0;
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-forward-ref';
+exports.FORWARD_REF = 'forwardRef';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Disallows usage of \`${exports.FORWARD_REF}\` references for DI`,
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            noForwardRef: `Avoid using \`${exports.FORWARD_REF}\``,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [`CallExpression[callee.type="Identifier"][callee.name="${exports.FORWARD_REF}"]`](node) {
+                context.report({
+                    node,
+                    messageId: 'noForwardRef',
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,68 @@
+"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-host-metadata-property';
+const DEFAULT_OPTIONS = { allowStatic: false };
+const METADATA_PROPERTY_NAME = 'host';
+const STYLE_GUIDE_LINK = 'https://angular.io/styleguide#style-06-03';
+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: [
+            {
+                type: 'object',
+                properties: {
+                    allowStatic: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.allowStatic,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noHostMetadataProperty: `Use @${utils_1.ASTUtils.AngularInnerClassDecorators.HostBinding} or @${utils_1.ASTUtils.AngularInnerClassDecorators.HostListener} rather than the \`${METADATA_PROPERTY_NAME}\` metadata property (${STYLE_GUIDE_LINK})`,
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context, [{ allowStatic }]) {
+        return {
+            [`${utils_1.Selectors.COMPONENT_OR_DIRECTIVE_CLASS_DECORATOR} Property[key.name="${METADATA_PROPERTY_NAME}"]`](node) {
+                const properties = allowStatic && utils_1.ASTUtils.isObjectExpression(node.value)
+                    ? node.value.properties.filter(isDynamic)
+                    : [node];
+                properties.forEach((property) => {
+                    context.report({
+                        node: property,
+                        messageId: 'noHostMetadataProperty',
+                    });
+                });
+            },
+        };
+    },
+});
+function startsWithLetter({ [0]: firstLetter }) {
+    return firstLetter.toLowerCase() !== firstLetter.toUpperCase();
+}
+function isEmptyStringValue(property) {
+    return (utils_1.ASTUtils.isStringLiteral(property.value) && property.value.value === '');
+}
+function isStatic(property) {
+    return (!property.computed &&
+        (utils_2.ASTUtils.isIdentifier(property.key) ||
+            (utils_1.ASTUtils.isStringLiteral(property.key) &&
+                startsWithLetter(property.key.value))));
+}
+function isDynamic(property) {
+    return (utils_1.ASTUtils.isProperty(property) &&
+        !isStatic(property) &&
+        !isEmptyStringValue(property));
+}

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

@@ -0,0 +1,105 @@
+"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-input-prefix';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that input bindings, including aliases, are not named or prefixed by the configured disallowed prefixes',
+            recommended: false,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    prefixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noInputPrefix: 'Input bindings, including aliases, should not be named, nor prefixed by {{prefixes}}',
+        },
+    },
+    defaultOptions: [{ prefixes: [] }],
+    create(context, [{ prefixes }]) {
+        return {
+            [utils_1.Selectors.INPUT_PROPERTY_OR_SETTER](node) {
+                const rawPropertyName = utils_1.ASTUtils.getRawText(node);
+                const hasDisallowedPrefix = prefixes.some((prefix) => isDisallowedPrefix(prefix, rawPropertyName));
+                // Direct violation on the property name
+                if (hasDisallowedPrefix) {
+                    context.report({
+                        node,
+                        messageId: 'noInputPrefix',
+                        data: {
+                            prefixes: (0, utils_1.toHumanReadableText)(prefixes),
+                        },
+                    });
+                }
+                // Check if decorator alias has a violation
+                let aliasProperty;
+                if (!node.parent) {
+                    return;
+                }
+                const inputDecorator = utils_1.ASTUtils.getDecorator(node.parent, 'Input');
+                if (inputDecorator &&
+                    utils_1.ASTUtils.isCallExpression(inputDecorator.expression)) {
+                    // Angular 16+ alias property syntax
+                    aliasProperty = utils_1.ASTUtils.getDecoratorPropertyValue(inputDecorator, 'alias');
+                    let aliasValue = '';
+                    let aliasArg;
+                    if (aliasProperty) {
+                        aliasValue = utils_1.ASTUtils.getRawText(aliasProperty);
+                    }
+                    else if (inputDecorator.expression.arguments.length > 0 &&
+                        (utils_1.ASTUtils.isLiteral(inputDecorator.expression.arguments[0]) ||
+                            utils_1.ASTUtils.isTemplateLiteral(inputDecorator.expression.arguments[0]))) {
+                        aliasArg = inputDecorator.expression.arguments[0];
+                        aliasValue = utils_1.ASTUtils.getRawText(aliasArg);
+                    }
+                    const hasDisallowedPrefix = prefixes.some((prefix) => isDisallowedPrefix(prefix, aliasValue));
+                    if (!hasDisallowedPrefix) {
+                        return;
+                    }
+                    return context.report({
+                        node: aliasProperty || aliasArg || node,
+                        messageId: 'noInputPrefix',
+                        data: {
+                            prefixes: (0, utils_1.toHumanReadableText)(prefixes),
+                        },
+                    });
+                }
+            },
+            [utils_1.Selectors.INPUTS_METADATA_PROPERTY_LITERAL](node) {
+                const [propertyName, aliasName] = utils_1.ASTUtils.getRawText(node)
+                    .replace(/\s/g, '')
+                    .split(':');
+                const hasDisallowedPrefix = prefixes.some((prefix) => isDisallowedPrefix(prefix, propertyName, aliasName));
+                if (!hasDisallowedPrefix) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'noInputPrefix',
+                    data: {
+                        prefixes: (0, utils_1.toHumanReadableText)(prefixes),
+                    },
+                });
+            },
+        };
+    },
+});
+function isDisallowedPrefix(prefix, propertyName, aliasName = '') {
+    const prefixPattern = new RegExp(`^${prefix}(([^a-z])|(?=$))`);
+    return prefixPattern.test(propertyName) || prefixPattern.test(aliasName);
+}