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

package/dist/rules/sort-lifecycle-methods.d.ts

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

package/dist/rules/sort-lifecycle-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-lifecycle-methods.d.ts","sourceRoot":"","sources":["../../src/rules/sort-lifecycle-methods.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,2BAA2B,CAAC;AACrD,eAAO,MAAM,SAAS,2BAA2B,CAAC;;;;AAElD,wBAyDG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/sort-lifecycle-methods.js

@@ -0,0 +1,45 @@
+"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 = 'sort-lifecycle-methods';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensures that lifecycle methods are declared in order of execution',
+        },
+        schema: [],
+        messages: {
+            lifecycleMethodsNotSorted: `Lifecycle Methods are not declared in order of execution`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const isBefore = (method1, method2) => {
+            const methodIndex1 = utils_1.ASTUtils.angularLifecycleMethodsOrdered.indexOf(utils_1.ASTUtils.getMethodName(method1));
+            const methodIndex2 = utils_1.ASTUtils.angularLifecycleMethodsOrdered.indexOf(utils_1.ASTUtils.getMethodName(method2));
+            return methodIndex1 < methodIndex2;
+        };
+        return {
+            [utils_1.Selectors.COMPONENT_CLASS_DECORATOR](node) {
+                const declaredMethods = utils_1.ASTUtils.getDeclaredMethods(node.parent);
+                const declaredLifeCycleMethods = declaredMethods.filter((method) => utils_1.ASTUtils.isAngularLifecycleMethod(utils_1.ASTUtils.getMethodName(method) ?? ''));
+                for (let i = 1; i < declaredLifeCycleMethods.length; ++i) {
+                    const before = isBefore(declaredLifeCycleMethods[i], declaredLifeCycleMethods[i - 1]);
+                    if (before) {
+                        context.report({
+                            node: declaredLifeCycleMethods[i].key,
+                            messageId: 'lifecycleMethodsNotSorted',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Organizing lifecycle methods in the order they execute (ngOnChanges, ngOnInit, ngDoCheck, ngAfterContentInit, ngAfterContentChecked, ngAfterViewInit, ngAfterViewChecked, ngOnDestroy) makes the component lifecycle easier to understand and follow. When methods appear in execution order, developers can mentally trace the component's lifecycle from initialization through destruction just by reading down the file. This natural ordering helps both when writing new code (you know where to add lifecycle logic) and when debugging (you can follow the execution path visually). Randomly ordered lifecycle methods force developers to jump around the file and mentally reconstruct the execution sequence. Consistent ordering is a simple organizational principle that significantly improves code readability.",
+};

package/dist/rules/use-component-selector.d.ts

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

package/dist/rules/use-component-selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-component-selector.d.ts","sourceRoot":"","sources":["../../src/rules/use-component-selector.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,sBAAsB,CAAC;AAChD,eAAO,MAAM,SAAS,2BAA2B,CAAC;;;;AAElD,wBAkCG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/use-component-selector.js

@@ -0,0 +1,41 @@
+"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 = 'use-component-selector';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Component selector must be declared',
+        },
+        schema: [],
+        messages: {
+            useComponentSelector: 'The selector of the component is mandatory',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [utils_1.Selectors.COMPONENT_CLASS_DECORATOR](node) {
+                const selector = utils_1.ASTUtils.getDecoratorPropertyValue(node, 'selector');
+                if (selector &&
+                    ((utils_1.ASTUtils.isStringLiteral(selector) && selector.value.length) ||
+                        utils_1.ASTUtils.isTemplateLiteral(selector) ||
+                        utils_2.ASTUtils.isIdentifier(selector))) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useComponentSelector',
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Every component should have a selector that defines how it's used in templates. Omitting the selector makes the component unusable in templates and can only be used with dynamic component loading or routing, which is rarely the intent. When debugging, components without selectors are harder to identify in the component tree and browser DevTools. If a component is truly only meant for dynamic loading (like a modal or route component), you can disable this rule for that component, but in most cases, every component should have a meaningful selector.",
+};

package/dist/rules/use-component-view-encapsulation.d.ts

@@ -0,0 +1,11 @@
+export type Options = [];
+export type MessageIds = 'useComponentViewEncapsulation' | 'suggestRemoveViewEncapsulationNone';
+export declare const RULE_NAME = "use-component-view-encapsulation";
+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=use-component-view-encapsulation.d.ts.map

package/dist/rules/use-component-view-encapsulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-component-view-encapsulation.d.ts","sourceRoot":"","sources":["../../src/rules/use-component-view-encapsulation.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAClB,+BAA+B,GAC/B,oCAAoC,CAAC;AACzC,eAAO,MAAM,SAAS,qCAAqC,CAAC;;;;AAG5D,wBAwDG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/use-component-view-encapsulation.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'use-component-view-encapsulation';
+const VIEW_ENCAPSULATION_NONE = 'ViewEncapsulation.None';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Disallows using \`${VIEW_ENCAPSULATION_NONE}\``,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            useComponentViewEncapsulation: `Using \`${VIEW_ENCAPSULATION_NONE}\` makes your styles global, which may have an unintended effect`,
+            suggestRemoveViewEncapsulationNone: `Remove \`${VIEW_ENCAPSULATION_NONE}\``,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} ${utils_1.Selectors.metadataProperty('encapsulation')} > MemberExpression[object.name='ViewEncapsulation'] > Identifier[name='None']`](node) {
+                context.report({
+                    node,
+                    messageId: 'useComponentViewEncapsulation',
+                    suggest: [
+                        {
+                            messageId: 'suggestRemoveViewEncapsulationNone',
+                            fix: (fixer) => {
+                                const importDeclarations = utils_1.ASTUtils.getImportDeclarations(node, '@angular/core') ?? [];
+                                return [
+                                    utils_1.RuleFixes.getNodeToCommaRemoveFix(sourceCode, node.parent.parent, fixer),
+                                    utils_1.RuleFixes.getImportRemoveFix(sourceCode, importDeclarations, 'ViewEncapsulation', fixer),
+                                ].filter(utils_1.isNotNullOrUndefined);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Setting encapsulation to ViewEncapsulation.None disables Angular's view encapsulation, making the component's styles global and affecting the entire application. This breaks component isolation and can cause unexpected styling conflicts throughout your app. When multiple components use ViewEncapsulation.None, their styles can interfere with each other in unpredictable ways, making it extremely difficult to reason about styling. A style intended for one component might accidentally affect completely unrelated components. This defeats one of Angular's key benefits: component style isolation. ViewEncapsulation.None is occasionally necessary for specific edge cases (like styling dynamically inserted content), but it should be avoided in normal component development. Use the default Emulated encapsulation, or ShadowDom for native Shadow DOM, to keep component styles properly isolated.",
+};

package/dist/rules/use-injectable-provided-in.d.ts

@@ -0,0 +1,13 @@
+export type Options = [{
+    readonly ignoreClassNamePattern?: string;
+}];
+export type MessageIds = 'useInjectableProvidedIn' | 'suggestInjector';
+export declare const RULE_NAME = "use-injectable-provided-in";
+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=use-injectable-provided-in.d.ts.map

package/dist/rules/use-injectable-provided-in.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-injectable-provided-in.d.ts","sourceRoot":"","sources":["../../src/rules/use-injectable-provided-in.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,CAAC;IAAE,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AACrE,MAAM,MAAM,UAAU,GAAG,yBAAyB,GAAG,iBAAiB,CAAC;AACvE,eAAO,MAAM,SAAS,+BAA+B,CAAC;;;;AAGtD,wBA2DG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/use-injectable-provided-in.js

@@ -0,0 +1,63 @@
+"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 = 'use-injectable-provided-in';
+const METADATA_PROPERTY_NAME = 'providedIn';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Using the \`${METADATA_PROPERTY_NAME}\` property makes \`Injectables\` tree-shakable`,
+        },
+        hasSuggestions: true,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignoreClassNamePattern: {
+                        type: 'string',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            useInjectableProvidedIn: `The \`${METADATA_PROPERTY_NAME}\` property is mandatory for \`Injectables\``,
+            suggestInjector: `Use \`${METADATA_PROPERTY_NAME}: '{{injector}}'\``,
+        },
+    },
+    defaultOptions: [{}],
+    create(context, [{ ignoreClassNamePattern }]) {
+        const injectableClassDecorator = `ClassDeclaration:not([id.name=${ignoreClassNamePattern}]):not(:has(TSClassImplements:matches([expression.property.name='HttpInterceptor'], [expression.name='HttpInterceptor']))) > Decorator[expression.callee.name="Injectable"]`;
+        const providedInMetadataProperty = utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME);
+        const withoutProvidedInDecorator = `${injectableClassDecorator}:matches([expression.arguments.length=0], [expression.arguments.0.type='ObjectExpression']:not(:has(${providedInMetadataProperty})))`;
+        const nullableProvidedInProperty = `${injectableClassDecorator} ${providedInMetadataProperty}:matches([value.type='Identifier'][value.name='undefined'], [value.type='Literal'][value.raw='null'])`;
+        const selectors = [
+            withoutProvidedInDecorator,
+            nullableProvidedInProperty,
+        ].join(',');
+        return {
+            [selectors](node) {
+                context.report({
+                    node: utils_1.ASTUtils.isProperty(node) ? node.value : node,
+                    messageId: 'useInjectableProvidedIn',
+                    suggest: ['any', 'platform', 'root'].map((injector) => ({
+                        messageId: 'suggestInjector',
+                        fix: (fixer) => {
+                            return utils_1.ASTUtils.isProperty(node)
+                                ? fixer.replaceText(node.value, `'${injector}'`)
+                                : (utils_1.RuleFixes.getDecoratorPropertyAddFix(node, fixer, `${METADATA_PROPERTY_NAME}: '${injector}'`) ?? []);
+                        },
+                        data: { injector },
+                    })),
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `Using 'providedIn' in the @Injectable() decorator (like '@Injectable({ providedIn: "root" })') enables tree-shaking, which means Angular can remove the service from your production bundle if it's never actually used. Without 'providedIn', services must be registered in a module's providers array, and Angular must include them in the bundle even if they're unused. This can significantly increase bundle size. Additionally, 'providedIn' makes services easier to use (no need to add them to module providers) and makes circular dependencies less likely. The 'providedIn' syntax is the modern, recommended way to provide services.`,
+};

package/dist/rules/use-lifecycle-interface.d.ts

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

package/dist/rules/use-lifecycle-interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-lifecycle-interface.d.ts","sourceRoot":"","sources":["../../src/rules/use-lifecycle-interface.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,uBAAuB,CAAC;AACjD,eAAO,MAAM,SAAS,4BAA4B,CAAC;;;;AAInD,wBAyEG;AAEH,eAAO,MAAM,mBAAmB;;CAE/B,CAAC"}

package/dist/rules/use-lifecycle-interface.js

@@ -0,0 +1,65 @@
+"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 = 'use-lifecycle-interface';
+const STYLE_GUIDE_LINK = 'https://angular.dev/style-guide#use-lifecycle-hook-interfaces';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Ensures that classes implement lifecycle interfaces corresponding to the declared lifecycle methods. See more at ${STYLE_GUIDE_LINK}`,
+        },
+        schema: [],
+        messages: {
+            useLifecycleInterface: `Lifecycle interface '{{interfaceName}}' should be implemented for method '{{methodName}}'. (${STYLE_GUIDE_LINK})`,
+        },
+        fixable: 'code',
+    },
+    defaultOptions: [],
+    create(context) {
+        const angularLifecycleMethodsPattern = (0, utils_1.toPattern)([
+            ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,
+        ]);
+        return {
+            [`MethodDefinition[key.name=${angularLifecycleMethodsPattern}]`](node) {
+                const { key, parent: { parent }, } = node;
+                if (!utils_1.ASTUtils.getAngularClassDecorator(parent))
+                    return;
+                // Do not report the method if it has the override keyword because it implies the base class is responsible for the implementation
+                if (node.override) {
+                    return;
+                }
+                const declaredLifecycleInterfaces = utils_1.ASTUtils.getDeclaredAngularLifecycleInterfaces(parent);
+                const methodName = key
+                    .name;
+                const interfaceName = utils_1.ASTUtils.getLifecycleInterfaceByMethodName(methodName);
+                const isMethodImplemented = declaredLifecycleInterfaces.includes(utils_1.ASTUtils.AngularLifecycleInterfaces[interfaceName]);
+                if (isMethodImplemented)
+                    return;
+                context.report({
+                    node: key,
+                    messageId: 'useLifecycleInterface',
+                    data: { interfaceName, methodName },
+                    fix: (fixer) => {
+                        const { implementsNodeReplace, implementsTextReplace } = utils_1.RuleFixes.getImplementsSchemaFixer(parent, interfaceName);
+                        return [
+                            utils_1.RuleFixes.getImportAddFix({
+                                fixer,
+                                importName: interfaceName,
+                                moduleName: '@angular/core',
+                                node: parent,
+                            }),
+                            fixer.insertTextAfter(implementsNodeReplace, implementsTextReplace),
+                        ].filter(utils_1.isNotNullOrUndefined);
+                    },
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `Implementing lifecycle interfaces (like OnInit, OnDestroy, AfterViewInit) provides TypeScript compile-time checking to ensure you've spelled the lifecycle method names correctly and used the right method signatures. For example, if you typo 'ngOnInit' as 'ngOninit', TypeScript will catch this error if your class implements OnInit. The interfaces also serve as self-documentation, making it immediately clear which lifecycle hooks a component uses. While Angular will still call correctly-named lifecycle methods even without the interface, using the interface leverages TypeScript's type safety to catch errors earlier in development.`,
+};

package/dist/rules/use-pipe-transform-interface.d.ts

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

package/dist/rules/use-pipe-transform-interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pipe-transform-interface.d.ts","sourceRoot":"","sources":["../../src/rules/use-pipe-transform-interface.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,2BAA2B,CAAC;AACrD,eAAO,MAAM,SAAS,iCAAiC,CAAC;;;;AAGxD,wBAgDG;AAEH,eAAO,MAAM,mBAAmB;;CAG/B,CAAC"}

package/dist/rules/use-pipe-transform-interface.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_DOCS_EXTENSION = exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'use-pipe-transform-interface';
+const PIPE_TRANSFORM = 'PipeTransform';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Ensures that \`Pipes\` implement \`${PIPE_TRANSFORM}\` interface`,
+            recommended: 'recommended',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            usePipeTransformInterface: `Pipes should implement \`${PIPE_TRANSFORM}\` interface`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [`ClassDeclaration:not(:has(TSClassImplements:matches([expression.name='${PIPE_TRANSFORM}'], [expression.property.name='${PIPE_TRANSFORM}']))) > Decorator[expression.callee.name='Pipe']`]({ parent: classDeclaration, }) {
+                context.report({
+                    node: classDeclaration.id ?? classDeclaration,
+                    messageId: 'usePipeTransformInterface',
+                    fix: (fixer) => {
+                        const { implementsNodeReplace, implementsTextReplace } = utils_1.RuleFixes.getImplementsSchemaFixer(classDeclaration, PIPE_TRANSFORM);
+                        return [
+                            utils_1.RuleFixes.getImportAddFix({
+                                compatibleWithTypeOnlyImport: true,
+                                fixer,
+                                importName: PIPE_TRANSFORM,
+                                moduleName: '@angular/core',
+                                node: classDeclaration,
+                            }),
+                            fixer.insertTextAfter(implementsNodeReplace, implementsTextReplace),
+                        ].filter(utils_1.isNotNullOrUndefined);
+                    },
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: "Implementing the PipeTransform interface provides TypeScript compile-time checking to ensure your pipe has the correct transform() method signature. Without the interface, typos in the method name or incorrect parameters won't be caught until runtime. The interface also serves as self-documentation and enables better IDE support like autocomplete and inline documentation. While Angular requires pipes to have a transform() method, using the PipeTransform interface leverages TypeScript's type system to catch implementation errors during development rather than at runtime.",
+};

package/dist/utils/create-eslint-rule.d.ts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export interface RuleDocs {
+    recommended?: string;
+}
+export declare const createESLintRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, RuleDocs>>) => ESLintUtils.RuleModule<MessageIds, Options, RuleDocs, ESLintUtils.RuleListener> & {
+    name: string;
+};
+//# sourceMappingURL=create-eslint-rule.d.ts.map

package/dist/utils/create-eslint-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-eslint-rule.d.ts","sourceRoot":"","sources":["../../src/utils/create-eslint-rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,MAAM,WAAW,QAAQ;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAiCD,eAAO,MAAM,gBAAgB;;CAG5B,CAAC"}

package/dist/utils/create-eslint-rule.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createESLintRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * We need to patch the RuleCreator in order to preserve the defaultOptions
+ * to use as part of documentation generation.
+ */
+const patchedRuleCreator = (urlCreator) => {
+    return function createRule({ name, meta, defaultOptions, create }) {
+        const resolvedDefaultOptions = (defaultOptions ?? []);
+        return {
+            name,
+            meta: Object.assign(Object.assign({}, meta), {
+                docs: Object.assign(Object.assign({}, meta.docs), {
+                    url: urlCreator(name),
+                }),
+            }),
+            defaultOptions: resolvedDefaultOptions,
+            create(context) {
+                const optionsWithDefault = utils_1.ESLintUtils.applyDefault(resolvedDefaultOptions, context.options);
+                return create(context, optionsWithDefault);
+            },
+        };
+    };
+};
+patchedRuleCreator.withoutDocs = utils_1.ESLintUtils.RuleCreator.withoutDocs;
+exports.createESLintRule = patchedRuleCreator((ruleName) => `https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin/docs/rules/${ruleName}.md`);

package/dist/utils/jsdoc.d.ts

@@ -0,0 +1,11 @@
+import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
+import ts from 'typescript';
+export type CallLikeNode = TSESTree.CallExpression | TSESTree.NewExpression | TSESTree.TaggedTemplateExpression;
+export declare function getCallLikeNode(node: TSESTree.Node): CallLikeNode | undefined;
+export declare function getSymbols(node: TSESTree.Identifier, services: ParserServicesWithTypeInformation, checker: ts.TypeChecker): (ts.Symbol | undefined)[];
+export declare function isNodeCalleeOfParent(node: TSESTree.Node): node is CallLikeNode;
+export declare function hasJsDocTag(symbols: (ts.Symbol | undefined)[], tagName: string): boolean;
+export declare function getCallLikeNodeSymbol(node: CallLikeNode, services: ParserServicesWithTypeInformation, checker: ts.TypeChecker): ts.Symbol | undefined;
+export declare function isDeclaration(node: TSESTree.Identifier): boolean;
+export declare function isInsideExportOrImport(node: TSESTree.Node): boolean;
+//# sourceMappingURL=jsdoc.d.ts.map

package/dist/utils/jsdoc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsdoc.d.ts","sourceRoot":"","sources":["../../src/utils/jsdoc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EACjC,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B,MAAM,MAAM,YAAY,GACpB,QAAQ,CAAC,cAAc,GACvB,QAAQ,CAAC,aAAa,GACtB,QAAQ,CAAC,wBAAwB,CAAC;AAEtC,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,YAAY,GAAG,SAAS,CAW7E;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,CAAC,UAAU,EACzB,QAAQ,EAAE,iCAAiC,EAC3C,OAAO,EAAE,EAAE,CAAC,WAAW,GACtB,CAAC,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAqB3B;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAClB,IAAI,IAAI,YAAY,CAYtB;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,CAAC,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,EAClC,OAAO,EAAE,MAAM,GACd,OAAO,CAIT;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,YAAY,EAClB,QAAQ,EAAE,iCAAiC,EAC3C,OAAO,EAAE,EAAE,CAAC,WAAW,GACtB,EAAE,CAAC,MAAM,GAAG,SAAS,CAMvB;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,GAAG,OAAO,CA2ChE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAuBnE"}