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

package/dist/rules/no-developer-preview.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils");
+const jsdoc_1 = require("../utils/jsdoc");
+exports.RULE_NAME = 'no-developer-preview';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Disallow using code which is marked as developer preview`,
+        },
+        schema: [],
+        messages: {
+            noDeveloperPreview: '`{{name}}` is in developer preview',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = (0, eslint_utils_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            Identifier: (node) => {
+                if ((0, jsdoc_1.isDeclaration)(node) || (0, jsdoc_1.isInsideExportOrImport)(node)) {
+                    return;
+                }
+                const symbols = (0, jsdoc_1.getSymbols)(node, services, checker);
+                if (!(0, jsdoc_1.hasJsDocTag)(symbols, 'developerPreview')) {
+                    return;
+                }
+                const { name } = node;
+                context.report({
+                    node,
+                    messageId: 'noDeveloperPreview',
+                    data: { name },
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `Angular's [developer preview APIs](https://angular.dev/reference/releases#developer-preview) are fully functional and polished, but not yet covered by Angular's [breaking change policy](https://angular.dev/reference/releases#breaking-change-policy-and-update-paths). These APIs may change even in patch releases, making them risky for production applications.`,
+};

package/dist/rules/no-duplicates-in-metadata-arrays.d.ts

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

package/dist/rules/no-duplicates-in-metadata-arrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-duplicates-in-metadata-arrays.d.ts","sourceRoot":"","sources":["../../src/rules/no-duplicates-in-metadata-arrays.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,8BAA8B,CAAC;AACxD,eAAO,MAAM,SAAS,qCAAqC,CAAC;;;;AAE5D,wBA4CG;AAoBH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/no-duplicates-in-metadata-arrays.js

@@ -0,0 +1,67 @@
+"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");
+const utils_2 = require("@typescript-eslint/utils");
+exports.RULE_NAME = 'no-duplicates-in-metadata-arrays';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that metadata arrays do not contain duplicate entries.',
+        },
+        schema: [],
+        messages: {
+            noDuplicatesInMetadataArrays: 'Entry is duplicated in metadata array',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const selectors = [
+            // https://angular.dev/api/core/NgModule
+            `${utils_1.Selectors.MODULE_CLASS_DECORATOR} Property[key.name=${(0, utils_1.toPattern)([
+                'providers',
+                'declarations',
+                'imports',
+                'exports',
+            ])}] > ArrayExpression`,
+            // https://angular.dev/api/core/Component
+            `${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name=${(0, utils_1.toPattern)([
+                'imports',
+            ])}] > ArrayExpression`,
+            // https://angular.dev/api/core/Directive
+            `${utils_1.Selectors.DIRECTIVE_CLASS_DECORATOR} Property[key.name=${(0, utils_1.toPattern)([
+                'providers',
+            ])}] > ArrayExpression`,
+        ].join(',');
+        return {
+            [selectors]({ elements }) {
+                getDuplicateItems(elements).forEach((duplicateImport) => {
+                    context.report({
+                        node: duplicateImport,
+                        messageId: 'noDuplicatesInMetadataArrays',
+                    });
+                });
+            },
+        };
+    },
+});
+function getDuplicateItems(elements) {
+    const items = elements.filter(utils_2.ASTUtils.isIdentifier);
+    const uniqueItemNames = new Set();
+    const duplicateItems = [];
+    items.forEach((item) => {
+        if (uniqueItemNames.has(item.name)) {
+            duplicateItems.push(item);
+        }
+        else {
+            uniqueItemNames.add(item.name);
+        }
+    });
+    return duplicateItems;
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: 'Duplicate entries in Angular metadata arrays like providers, imports, declarations, or exports serve no purpose and indicate a mistake. When the same provider is listed twice in a providers array, Angular will create it twice, potentially leading to unexpected behavior with singleton services. Duplicate imports or declarations simply waste bundle size and make the metadata harder to read. These duplicates typically occur from copy-paste errors, merge conflicts, or refactoring mistakes. Catching these duplicates early prevents subtle bugs and keeps module metadata clean and understandable.',
+};

package/dist/rules/no-empty-lifecycle-method.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'noEmptyLifecycleMethod' | 'suggestRemoveLifecycleMethod';
+export declare const RULE_NAME = "no-empty-lifecycle-method";
+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-empty-lifecycle-method.d.ts.map

package/dist/rules/no-empty-lifecycle-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-empty-lifecycle-method.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-lifecycle-method.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAClB,wBAAwB,GACxB,8BAA8B,CAAC;AACnC,eAAO,MAAM,SAAS,8BAA8B,CAAC;;;;AAErD,wBAsFG;AAYH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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

@@ -0,0 +1,75 @@
+"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-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: 'recommended',
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            noEmptyLifecycleMethod: 'Lifecycle methods should not be empty',
+            suggestRemoveLifecycleMethod: 'Remove lifecycle method',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const angularDecoratorsPattern = (0, utils_1.toPattern)([
+            'Component',
+            'Directive',
+            'Injectable',
+            'NgModule',
+            'Pipe',
+        ]);
+        const angularLifecycleMethodsPattern = (0, utils_1.toPattern)([
+            ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,
+        ]);
+        return {
+            [`${utils_1.Selectors.decoratorDefinition(angularDecoratorsPattern)} > ClassBody > ${utils_1.Selectors.methodDefinition(angularLifecycleMethodsPattern)}[value.body.body.length=0]`](node) {
+                context.report({
+                    node,
+                    messageId: 'noEmptyLifecycleMethod',
+                    suggest: [
+                        {
+                            messageId: 'suggestRemoveLifecycleMethod',
+                            fix: (fixer) => {
+                                const importDeclarations = utils_1.ASTUtils.getImportDeclarations(node, '@angular/core') ?? [];
+                                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;
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: 'Empty lifecycle methods add noise to the codebase without providing any value. When a developer sees ngOnInit(), ngOnDestroy(), or other lifecycle hooks, they expect to find important initialization, cleanup, or other lifecycle-related logic. Finding an empty method wastes time during code review and maintenance. Empty lifecycle methods often remain after code has been refactored or removed, serving as dead code that clutters the component. They also require unnecessary imports of lifecycle interfaces (like OnInit, OnDestroy). Removing empty lifecycle methods makes components cleaner, easier to understand, and reduces the file size.',
+};

package/dist/rules/no-experimental.d.ts

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

package/dist/rules/no-experimental.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-experimental.d.ts","sourceRoot":"","sources":["../../src/rules/no-experimental.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAC1C,eAAO,MAAM,SAAS,oBAAoB,CAAC;;;;AAE3C,wBAsCG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/no-experimental.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils");
+const jsdoc_1 = require("../utils/jsdoc");
+exports.RULE_NAME = 'no-experimental';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Disallow using code which is marked as experimental`,
+        },
+        schema: [],
+        messages: {
+            noExperimental: '`{{name}}` is experimental',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = (0, eslint_utils_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            Identifier: (node) => {
+                if ((0, jsdoc_1.isDeclaration)(node) || (0, jsdoc_1.isInsideExportOrImport)(node)) {
+                    return;
+                }
+                const symbols = (0, jsdoc_1.getSymbols)(node, services, checker);
+                if (!(0, jsdoc_1.hasJsDocTag)(symbols, 'experimental')) {
+                    return;
+                }
+                const { name } = node;
+                context.report({
+                    node,
+                    messageId: 'noExperimental',
+                    data: { name },
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `Angular's [experimental APIs](https://angular.dev/reference/releases#experimental) are subject to significant changes or removal without notice and are not covered by Angular's [breaking change policy](https://angular.dev/reference/releases#breaking-change-policy-and-update-paths). These APIs may change even in patch releases, making them risky for production applications.`,
+};

package/dist/rules/no-forward-ref.d.ts

@@ -0,0 +1,12 @@
+export type Options = [];
+export type MessageIds = 'noForwardRef';
+export declare const RULE_NAME = "no-forward-ref";
+export declare const FORWARD_REF = "forwardRef";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noForwardRef", [], 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-forward-ref.d.ts.map

package/dist/rules/no-forward-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-forward-ref.d.ts","sourceRoot":"","sources":["../../src/rules/no-forward-ref.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,cAAc,CAAC;AACxC,eAAO,MAAM,SAAS,mBAAmB,CAAC;AAE1C,eAAO,MAAM,WAAW,eAAe,CAAC;;;;AAExC,wBAyBG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = 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`,
+        },
+        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',
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "The forwardRef() function is a workaround for circular dependencies in Angular's dependency injection system, but it obscures the dependency graph and can make code harder to understand and maintain. When forwardRef() is used, it's often a sign of poor architecture, such as circular dependencies between components or services that could be resolved through better abstraction. Modern Angular and TypeScript have reduced the need for forwardRef() in most cases. Instead, consider restructuring your code to eliminate circular dependencies, using interfaces for dependency injection, or moving shared logic into a separate service.",
+};

package/dist/rules/no-implicit-take-until-destroyed.d.ts

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

package/dist/rules/no-implicit-take-until-destroyed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-implicit-take-until-destroyed.d.ts","sourceRoot":"","sources":["../../src/rules/no-implicit-take-until-destroyed.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,8BAA8B,CAAC;AACxD,eAAO,MAAM,SAAS,qCAAqC,CAAC;;;;AAO5D,wBAgCG;AAqEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/no-implicit-take-until-destroyed.js

@@ -0,0 +1,83 @@
+"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-implicit-take-until-destroyed';
+const RXJS_INTEROP_LINK = 'https://angular.dev/ecosystem/rxjs-interop/take-until-destroyed';
+const DEPENDENCY_INJECTION_CONTEXT = 'https://angular.dev/guide/di/dependency-injection-context';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: `Ensures that \`takeUntilDestroyed()\` is called with an explicit \`DestroyRef\` when used outside of an injection context`,
+        },
+        schema: [],
+        messages: {
+            noImplicitTakeUntilDestroyed: `\`takeUntilDestroyed()\` must be called with an explicit \`DestroyRef\` parameter when used outside of an injection context. See more at ${DEPENDENCY_INJECTION_CONTEXT} and ${RXJS_INTEROP_LINK}`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== utils_2.AST_NODE_TYPES.Identifier ||
+                    node.callee.name !== 'takeUntilDestroyed' ||
+                    node.arguments.length > 0 ||
+                    isInInjectionContext(node)) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'noImplicitTakeUntilDestroyed',
+                });
+            },
+        };
+    },
+});
+function isInInjectionContext(node) {
+    let current = node;
+    while (current) {
+        if (isInFactoryFunction(current)) {
+            return true;
+        }
+        if (utils_1.ASTUtils.isPropertyDefinition(current) ||
+            isConstructorMethod(current)) {
+            const classDeclaration = utils_1.ASTUtils.getNearestNodeFrom(current, utils_1.ASTUtils.isClassDeclaration);
+            if (!classDeclaration) {
+                current = current.parent;
+                continue;
+            }
+            const decorator = utils_1.ASTUtils.getAngularClassDecorator(classDeclaration);
+            if (decorator && decorator !== 'NgModule') {
+                return true;
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function isConstructorMethod(node) {
+    return (node.type === utils_2.AST_NODE_TYPES.MethodDefinition && node.kind === 'constructor');
+}
+function isInFactoryFunction(node) {
+    if (node.type !== utils_2.AST_NODE_TYPES.ArrowFunctionExpression &&
+        node.type !== utils_2.AST_NODE_TYPES.FunctionExpression) {
+        return false;
+    }
+    const parent = node.parent;
+    if (!utils_1.ASTUtils.isProperty(parent)) {
+        return false;
+    }
+    const key = parent.key;
+    if (key.type === utils_2.AST_NODE_TYPES.Identifier &&
+        ['factory', 'useFactory'].includes(key.name)) {
+        return true;
+    }
+    return false;
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `The \`takeUntilDestroyed()\` operator can automatically infer the current component's or directive's \`DestroyRef\` only when called within an injection context — specifically in constructors or field initializers of classes decorated with \`@Component\`, \`@Directive\`, \`@Injectable\`, or \`@Pipe\`, or in factory functions (\`useFactory\` in providers or \`factory\` in InjectionTokens). When used in lifecycle methods like \`ngOnInit()\` or \`ngAfterViewInit()\`, in regular methods, in constructors of plain classes not managed by Angular's DI system, or in \`@NgModule\` classes (which don't support the \`ngOnDestroy\` lifecycle), the injection context is not available, and \`takeUntilDestroyed()\` will throw a runtime error: "NG0203: inject() must be called from an injection context." To fix this, inject \`DestroyRef\` using \`inject(DestroyRef)\` and pass it explicitly: \`takeUntilDestroyed(this.destroyRef)\`.`,
+};

package/dist/rules/no-input-prefix.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-input-prefix.d.ts","sourceRoot":"","sources":["../../src/rules/no-input-prefix.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,OAAO,GAAG,CAAC;IAAE,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC;AACjE,MAAM,MAAM,UAAU,GAAG,eAAe,CAAC;AACzC,eAAO,MAAM,SAAS,oBAAoB,CAAC;;;;AAE3C,wBAwIG;AAWH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const utils_2 = require("@typescript-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-input-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',
+        },
+        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);
+                // The child that matched was just a literal initializer of a property definition
+                if (node.parent?.type === utils_2.TSESTree.AST_NODE_TYPES.PropertyDefinition) {
+                    const initializingValue = node.parent.value;
+                    if (initializingValue?.type === utils_2.TSESTree.AST_NODE_TYPES.Literal &&
+                        rawPropertyName === utils_1.ASTUtils.getRawText(initializingValue) &&
+                        node.range[0] === initializingValue.range[0] &&
+                        node.range[1] === initializingValue.range[1]) {
+                        return;
+                    }
+                }
+                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);
+}
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "In HTML and Angular templates, attributes don't use prefixes like 'is' or 'has', so input properties shouldn't either. For example, prefer '@Input() disabled' over '@Input() isDisabled', so it's used in templates as '[disabled]=\"true\"' rather than '[isDisabled]=\"true\"'. This creates a more natural, HTML-like API for your components and follows Angular's style guide. The component class can still use prefixed names internally, but the input binding name (the public API) should follow HTML conventions.",
+};

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

@@ -0,0 +1,13 @@
+export type Options = [{
+    readonly allowedNames?: readonly string[];
+}];
+export type MessageIds = 'noInputRename' | 'suggestRemoveAliasName' | 'suggestReplaceOriginalNameWithAliasName';
+export declare const RULE_NAME = "no-input-rename";
+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=no-input-rename.d.ts.map

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

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