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

package/dist/rules/prefer-on-push-component-change-detection.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 = 'prefer-on-push-component-change-detection';
+const METADATA_PROPERTY_NAME = 'changeDetection';
+const STRATEGY_ON_PUSH = 'ChangeDetectionStrategy.OnPush';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `Ensures component's \`${METADATA_PROPERTY_NAME}\` is set to \`${STRATEGY_ON_PUSH}\``,
+            recommended: false,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            preferOnPushComponentChangeDetection: `The component's \`${METADATA_PROPERTY_NAME}\` value should be set to \`${STRATEGY_ON_PUSH}\``,
+            suggestAddChangeDetectionOnPush: `Add \`${STRATEGY_ON_PUSH}\``,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const changeDetectionMetadataProperty = utils_1.Selectors.metadataProperty(METADATA_PROPERTY_NAME);
+        const withoutChangeDetectionDecorator = `${utils_1.Selectors.COMPONENT_CLASS_DECORATOR}:matches([expression.arguments.length=0], [expression.arguments.0.type='ObjectExpression']:not(:has(${changeDetectionMetadataProperty})))`;
+        const nonChangeDetectionOnPushProperty = `${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} > CallExpression > ObjectExpression > ${changeDetectionMetadataProperty}:matches([value.type='Identifier'][value.name='undefined'], [value.object.name='ChangeDetectionStrategy'][value.property.name!='OnPush'])`;
+        const selectors = [
+            withoutChangeDetectionDecorator,
+            nonChangeDetectionOnPushProperty,
+        ].join(',');
+        return {
+            [selectors](node) {
+                context.report({
+                    node: nodeToReport(node),
+                    messageId: 'preferOnPushComponentChangeDetection',
+                    suggest: [
+                        {
+                            messageId: 'suggestAddChangeDetectionOnPush',
+                            fix: (fixer) => {
+                                if (utils_1.ASTUtils.isProperty(node)) {
+                                    return [
+                                        utils_1.RuleFixes.getImportAddFix({
+                                            fixer,
+                                            importName: 'ChangeDetectionStrategy',
+                                            moduleName: '@angular/core',
+                                            node: node.parent.parent.parent.parent,
+                                        }),
+                                        utils_1.ASTUtils.isMemberExpression(node.value)
+                                            ? fixer.replaceText(node.value.property, 'OnPush')
+                                            : fixer.replaceText(node.value, STRATEGY_ON_PUSH),
+                                    ].filter(utils_1.isNotNullOrUndefined);
+                                }
+                                return [
+                                    utils_1.RuleFixes.getImportAddFix({
+                                        fixer,
+                                        importName: 'ChangeDetectionStrategy',
+                                        moduleName: '@angular/core',
+                                        node: node.parent,
+                                    }),
+                                    utils_1.RuleFixes.getDecoratorPropertyAddFix(node, fixer, `${METADATA_PROPERTY_NAME}: ${STRATEGY_ON_PUSH}`),
+                                ].filter(utils_1.isNotNullOrUndefined);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});
+function nodeToReport(node) {
+    if (!utils_1.ASTUtils.isProperty(node)) {
+        return node;
+    }
+    return utils_1.ASTUtils.isMemberExpression(node.value)
+        ? node.value.property
+        : node.value;
+}

package/dist/rules/prefer-output-readonly.js

@@ -0,0 +1,39 @@
+"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 = 'prefer-output-readonly';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer to declare `@Output` as `readonly` since they are not supposed to be reassigned',
+            recommended: false,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            preferOutputReadonly: 'Prefer to declare `@Output` as `readonly` since they are not supposed to be reassigned',
+            suggestAddReadonlyModifier: 'Add `readonly` modifier',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [`PropertyDefinition:not([readonly]) > ${utils_1.Selectors.OUTPUT_DECORATOR}`]({ parent: { key }, }) {
+                context.report({
+                    node: key,
+                    messageId: 'preferOutputReadonly',
+                    suggest: [
+                        {
+                            messageId: 'suggestAddReadonlyModifier',
+                            fix: (fixer) => fixer.insertTextBefore(key, 'readonly '),
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});

package/dist/rules/relative-url-prefix.js

@@ -0,0 +1,55 @@
+"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 = 'relative-url-prefix';
+const STYLE_GUIDE_LINK = 'https://angular.io/styleguide#style-05-04';
+const RELATIVE_URL_PREFIX_MATCHER = /^\.\.?\/.+/;
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `The ./ and ../ prefix is standard syntax for relative URLs; don't depend on Angular's current ability to do without that prefix. See more at ${STYLE_GUIDE_LINK}`,
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            relativeUrlPrefix: `The ./ and ../ prefix is standard syntax for relative URLs. (${STYLE_GUIDE_LINK})`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name='templateUrl']`]({ value, }) {
+                if (!isUrlInvalid(value))
+                    return;
+                context.report({
+                    node: value,
+                    messageId: 'relativeUrlPrefix',
+                });
+            },
+            [`${utils_1.Selectors.COMPONENT_CLASS_DECORATOR} Property[key.name='styleUrls']`]({ value, }) {
+                if (!utils_1.ASTUtils.isArrayExpression(value))
+                    return;
+                value.elements.filter(isUrlInvalid).forEach((element) => {
+                    if (!element) {
+                        return;
+                    }
+                    context.report({
+                        node: element,
+                        messageId: 'relativeUrlPrefix',
+                    });
+                });
+            },
+        };
+    },
+});
+function isUrlInvalid(node) {
+    if (!node) {
+        return false;
+    }
+    return (!utils_1.ASTUtils.isStringLiteral(node) ||
+        !RELATIVE_URL_PREFIX_MATCHER.test(node.value));
+}

package/dist/rules/require-localize-metadata.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const DEFAULT_OPTIONS = {
+    requireDescription: false,
+    requireMeaning: false,
+};
+const VALID_LOCALIZED_STRING_WITH_DESCRIPTION = new RegExp(/:(.*\|)?([\w\s]+){1}(@@.*)?:.+/);
+const VALID_LOCALIZED_STRING_WITH_MEANING = new RegExp(/:([\w\s]+\|)(.*)?(@@.*)?:.+/);
+const STYLE_GUIDE_LINK = 'https://angular.io/guide/i18n';
+const STYLE_GUIDE_LINK_COMMON_PREPARE = `${STYLE_GUIDE_LINK}-common-prepare`;
+const STYLE_GUIDE_LINK_METADATA_FOR_TRANSLATION = `${STYLE_GUIDE_LINK_COMMON_PREPARE}#i18n-metadata-for-translation`;
+exports.RULE_NAME = 'require-localize-metadata';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that $localize tagged messages contain helpful metadata to aid with translations.',
+            recommended: false,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    requireDescription: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.requireDescription,
+                    },
+                    requireMeaning: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.requireMeaning,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            requireLocalizeDescription: `$localize tagged messages should contain a description. See more at ${STYLE_GUIDE_LINK_METADATA_FOR_TRANSLATION}`,
+            requireLocalizeMeaning: `$localize tagged messages should contain a meaning. See more at ${STYLE_GUIDE_LINK_METADATA_FOR_TRANSLATION}`,
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context, [{ requireDescription, requireMeaning }]) {
+        return {
+            TaggedTemplateExpression(taggedTemplateExpression) {
+                if ((requireDescription || requireMeaning) &&
+                    utils_1.ASTUtils.isIdentifier(taggedTemplateExpression.tag)) {
+                    const identifierName = taggedTemplateExpression.tag.name;
+                    const templateElement = taggedTemplateExpression.quasi.quasis[0];
+                    if (identifierName === '$localize' && !!templateElement) {
+                        const templateElementRawValue = templateElement.value.raw;
+                        if (requireDescription &&
+                            !VALID_LOCALIZED_STRING_WITH_DESCRIPTION.test(templateElementRawValue)) {
+                            context.report({
+                                loc: templateElement.loc,
+                                messageId: 'requireLocalizeDescription',
+                            });
+                        }
+                        if (requireMeaning &&
+                            !VALID_LOCALIZED_STRING_WITH_MEANING.test(templateElementRawValue)) {
+                            context.report({
+                                loc: templateElement.loc,
+                                messageId: 'requireLocalizeMeaning',
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/sort-ngmodule-metadata-arrays.js

@@ -0,0 +1,63 @@
+"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 = 'sort-ngmodule-metadata-arrays';
+const DEFAULT_LOCALE = 'en-US';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures ASC alphabetical order for `NgModule` metadata arrays for easy visual scanning',
+            recommended: false,
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    locale: {
+                        type: 'string',
+                        description: 'A string with a BCP 47 language tag.',
+                        default: DEFAULT_LOCALE,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            sortNgmoduleMetadataArrays: '`NgModule` metadata arrays should be sorted in ASC alphabetical order',
+        },
+    },
+    defaultOptions: [
+        {
+            locale: DEFAULT_LOCALE,
+        },
+    ],
+    create(context, [{ locale }]) {
+        return {
+            [`${utils_1.Selectors.MODULE_CLASS_DECORATOR} Property[key.name!="deps"] > ArrayExpression`]({ elements, }) {
+                const unorderedNodes = elements
+                    .filter(utils_2.ASTUtils.isIdentifier)
+                    .map((current, index, list) => [current, list[index + 1]])
+                    .find(([current, next]) => {
+                    return next && current.name.localeCompare(next.name, locale) === 1;
+                });
+                if (!unorderedNodes)
+                    return;
+                const [unorderedNode, nextNode] = unorderedNodes;
+                context.report({
+                    node: nextNode,
+                    messageId: 'sortNgmoduleMetadataArrays',
+                    fix: (fixer) => [
+                        fixer.replaceText(unorderedNode, nextNode.name),
+                        fixer.replaceText(nextNode, unorderedNode.name),
+                    ],
+                });
+            },
+        };
+    },
+});

package/dist/rules/use-component-selector.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 = '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',
+            recommended: false,
+        },
+        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) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useComponentSelector',
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,48 @@
+"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 = '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}\``,
+            recommended: false,
+        },
+        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.getSourceCode();
+        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) => {
+                                var _a;
+                                const importDeclarations = (_a = utils_1.ASTUtils.getImportDeclarations(node, '@angular/core')) !== null && _a !== void 0 ? _a : [];
+                                return [
+                                    utils_1.RuleFixes.getNodeToCommaRemoveFix(sourceCode, node.parent.parent, fixer),
+                                    utils_1.RuleFixes.getImportRemoveFix(sourceCode, importDeclarations, 'ViewEncapsulation', fixer),
+                                ].filter(utils_1.isNotNullOrUndefined);
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,62 @@
+"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 = '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`,
+            recommended: false,
+        },
+        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) => {
+                            var _a;
+                            return utils_1.ASTUtils.isProperty(node)
+                                ? fixer.replaceText(node.value, `'${injector}'`)
+                                : (_a = utils_1.RuleFixes.getDecoratorPropertyAddFix(node, fixer, `${METADATA_PROPERTY_NAME}: '${injector}'`)) !== null && _a !== void 0 ? _a : [];
+                        },
+                        data: { injector },
+                    })),
+                });
+            },
+        };
+    },
+});

package/dist/rules/use-lifecycle-interface.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 = 'use-lifecycle-interface';
+const STYLE_GUIDE_LINK = 'https://angular.io/styleguide#style-09-01';
+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}`,
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            useLifecycleInterface: `Lifecycle interface '{{interfaceName}}' should be implemented for method '{{methodName}}'. (${STYLE_GUIDE_LINK})`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const angularLifecycleMethodsPattern = (0, utils_1.toPattern)([
+            ...utils_1.ASTUtils.ANGULAR_LIFECYCLE_METHODS,
+        ]);
+        return {
+            [`MethodDefinition[key.name=${angularLifecycleMethodsPattern}]`]({ key, parent: { parent }, }) {
+                if (!utils_1.ASTUtils.getAngularClassDecorator(parent))
+                    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 },
+                });
+            },
+        };
+    },
+});

package/dist/rules/use-pipe-transform-interface.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 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: 'error',
+        },
+        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, }) {
+                var _a;
+                context.report({
+                    node: (_a = classDeclaration.id) !== null && _a !== void 0 ? _a : 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);
+                    },
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,26 @@
+"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 }) {
+        return {
+            meta: Object.assign(Object.assign({}, meta), {
+                docs: Object.assign(Object.assign({}, meta.docs), {
+                    url: urlCreator(name),
+                }),
+            }),
+            defaultOptions,
+            create(context) {
+                const optionsWithDefault = utils_1.ESLintUtils.applyDefault(defaultOptions, 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin",
-  "version": "15.2.2-alpha.9+449bb7a",
+  "version": "16.0.0-alpha.1",
   "description": "ESLint plugin for Angular applications, following angular.io/styleguide",
   "license": "MIT",
   "main": "dist/index.js",
@@ -17,12 +17,12 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@angular-eslint/utils": "15.2.2-alpha.9+449bb7a",
-    "@typescript-eslint/utils": "5.51.0"
+    "@angular-eslint/utils": "16.0.0-alpha.1",
+    "@typescript-eslint/utils": "5.59.2"
   },
   "peerDependencies": {
     "eslint": "^7.20.0 || ^8.0.0",
     "typescript": "*"
   },
-  "gitHead": "449bb7ae1934072c00a39ffb2fe8973a39da9df4"
+  "gitHead": "ffcbae10749bc12760a9d442d4293179c6c19042"
 }

package/dist/configs/base.json

@@ -1,4 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "plugins": ["@typescript-eslint", "@angular-eslint"]
-}

package/dist/configs/ng-cli-compat--formatting-add-on.json

@@ -1,51 +0,0 @@
-{
-  "plugins": ["eslint-plugin-jsdoc"],
-  "rules": {
-    "arrow-body-style": "error",
-    "arrow-parens": "off",
-    "comma-dangle": "off",
-    "curly": "error",
-    "eol-last": "error",
-    "jsdoc/check-alignment": "error",
-    "max-len": [
-      "error",
-      {
-        "code": 140
-      }
-    ],
-    "new-parens": "error",
-    "no-multiple-empty-lines": "off",
-    "no-trailing-spaces": "error",
-    "quote-props": ["error", "as-needed"],
-    "space-before-function-paren": [
-      "error",
-      {
-        "anonymous": "never",
-        "asyncArrow": "always",
-        "named": "never"
-      }
-    ],
-
-    "@typescript-eslint/member-delimiter-style": [
-      "error",
-      {
-        "multiline": {
-          "delimiter": "semi",
-          "requireLast": true
-        },
-        "singleline": {
-          "delimiter": "semi",
-          "requireLast": false
-        }
-      }
-    ],
-    "quotes": "off",
-    "@typescript-eslint/quotes": [
-      "error",
-      "single",
-      { "allowTemplateLiterals": true }
-    ],
-    "@typescript-eslint/semi": ["error", "always"],
-    "@typescript-eslint/type-annotation-spacing": "error"
-  }
-}