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

package/dist/rules/label-has-associated-control.js

@@ -0,0 +1,103 @@
+"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");
+const is_child_node_of_1 = require("../utils/is-child-node-of");
+exports.RULE_NAME = 'label-has-associated-control';
+const DEFAULT_CONTROL_COMPONENTS = [
+    'input',
+    'meter',
+    'output',
+    'progress',
+    'select',
+    'textarea',
+];
+const DEFAULT_LABEL_COMPONENTS = [
+    { inputs: ['for', 'htmlFor'], selector: 'label' },
+];
+const DEFAULT_OPTIONS = {
+    controlComponents: DEFAULT_CONTROL_COMPONENTS,
+    labelComponents: DEFAULT_LABEL_COMPONENTS,
+};
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '[Accessibility] Ensures that a label element/component is associated with a form element',
+            recommended: false,
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    controlComponents: {
+                        items: { type: 'string' },
+                        type: 'array',
+                        uniqueItems: true,
+                    },
+                    labelComponents: {
+                        items: {
+                            additionalProperties: false,
+                            properties: {
+                                inputs: {
+                                    items: { type: 'string' },
+                                    type: 'array',
+                                    uniqueItems: true,
+                                },
+                                selector: { type: 'string' },
+                            },
+                            required: ['selector'],
+                            type: 'object',
+                        },
+                        type: 'array',
+                        uniqueItems: true,
+                    },
+                },
+                type: 'object',
+            },
+        ],
+        messages: {
+            labelHasAssociatedControl: 'A label component must be associated with a form element',
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context, [{ controlComponents, labelComponents }]) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        const allControlComponents = new Set([
+            ...DEFAULT_CONTROL_COMPONENTS,
+            ...(controlComponents !== null && controlComponents !== void 0 ? controlComponents : []),
+        ]);
+        const allLabelComponents = [
+            ...DEFAULT_LABEL_COMPONENTS,
+            ...(labelComponents !== null && labelComponents !== void 0 ? labelComponents : []),
+        ];
+        const labelSelectors = allLabelComponents.map(({ selector }) => selector);
+        const labelComponentsPattern = toPattern(labelSelectors);
+        return {
+            [`Element$1[name=${labelComponentsPattern}]`](node) {
+                var _a;
+                const element = allLabelComponents.find(({ selector }) => selector === node.name);
+                if (!element)
+                    return;
+                const attributesInputs = new Set([...node.attributes, ...node.inputs].map(({ name }) => name));
+                const hasInput = (_a = element.inputs) === null || _a === void 0 ? void 0 : _a.some((input) => attributesInputs.has(input));
+                if (hasInput || hasControlComponentIn(allControlComponents, node)) {
+                    return;
+                }
+                const loc = parserServices.convertNodeSourceSpanToLoc(node.sourceSpan);
+                context.report({
+                    loc,
+                    messageId: 'labelHasAssociatedControl',
+                });
+            },
+        };
+    },
+});
+function hasControlComponentIn(controlComponents, element) {
+    return Boolean([...controlComponents].some((controlComponent) => (0, is_child_node_of_1.isChildNodeOf)(element, controlComponent)));
+}
+function toPattern(value) {
+    return RegExp(`^(${value.join('|')})$`);
+}

package/dist/rules/mouse-events-have-key-events.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const get_dom_elements_1 = require("../utils/get-dom-elements");
+const to_pattern_1 = require("../utils/to-pattern");
+exports.RULE_NAME = 'mouse-events-have-key-events';
+const STYLE_GUIDE_LINK = 'https://www.w3.org/WAI/WCAG21/Understanding/keyboard';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `[Accessibility] Ensures that the mouse events \`${"mouseout" /* MouseEvents.MouseOut */}\` and \`${"mouseover" /* MouseEvents.MouseOver */}\` are accompanied by \`${"focus" /* KeyEvents.Focus */}\` and \`${"blur" /* KeyEvents.Blur */}\` events respectively. Coding for the keyboard is important for users with physical disabilities who cannot use a mouse, AT compatibility, and screenreader users. See more at ${STYLE_GUIDE_LINK}`,
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            mouseEventsHaveKeyEvents: `\`{{mouseEvent}}\` must be accompanied by \`{{keyEvent}}\` for accessibility (${STYLE_GUIDE_LINK})`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        const domElementsPattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()]);
+        const eventPairs = [
+            ["blur" /* KeyEvents.Blur */, "mouseout" /* MouseEvents.MouseOut */],
+            ["focus" /* KeyEvents.Focus */, "mouseover" /* MouseEvents.MouseOver */],
+        ];
+        return eventPairs.reduce((accumulator, [keyEvent, mouseEvent]) => (Object.assign(Object.assign({}, accumulator), { [`Element$1[name=${domElementsPattern}]:has(BoundEvent[name='${mouseEvent}']):not(:has(BoundEvent[name='${keyEvent}']))`]({ sourceSpan, }) {
+                const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
+                context.report({
+                    loc,
+                    messageId: 'mouseEventsHaveKeyEvents',
+                    data: { keyEvent, mouseEvent },
+                });
+            } })), {});
+    },
+});

package/dist/rules/no-any.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'no-any';
+const ANY_TYPE_CAST_FUNCTION_NAME = '$any';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: `The use of "${ANY_TYPE_CAST_FUNCTION_NAME}" nullifies the compile-time benefits of Angular's type system`,
+            recommended: false,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            noAny: `Avoid using "${ANY_TYPE_CAST_FUNCTION_NAME}" in templates`,
+            suggestRemoveAny: `Remove ${ANY_TYPE_CAST_FUNCTION_NAME}`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        (0, utils_1.ensureTemplateParser)(context);
+        const sourceCode = context.getSourceCode();
+        return {
+            [`Call[receiver.name="${ANY_TYPE_CAST_FUNCTION_NAME}"]`]({ receiver, sourceSpan: { end, start }, }) {
+                if (!(receiver instanceof bundled_angular_compiler_1.PropertyRead)) {
+                    return;
+                }
+                if (!(
+                // this.$any() is also valid usage of the native Angular $any()
+                (receiver.receiver instanceof bundled_angular_compiler_1.ThisReceiver ||
+                    receiver.receiver instanceof bundled_angular_compiler_1.ImplicitReceiver))) {
+                    return;
+                }
+                const nameSpan = receiver.nameSpan;
+                context.report({
+                    messageId: 'noAny',
+                    loc: {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end),
+                    },
+                    suggest: [
+                        {
+                            messageId: 'suggestRemoveAny',
+                            fix: (fixer) => [
+                                fixer.removeRange([nameSpan.start, nameSpan.end + 1]),
+                                fixer.removeRange([end - 1, end]),
+                            ],
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-autofocus.js

@@ -0,0 +1,41 @@
+"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");
+const get_dom_elements_1 = require("../utils/get-dom-elements");
+const to_pattern_1 = require("../utils/to-pattern");
+exports.RULE_NAME = 'no-autofocus';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '[Accessibility] Ensures that the `autofocus` attribute is not used',
+            recommended: false,
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            noAutofocus: 'The `autofocus` attribute should not be used, as it reduces usability and accessibility for users',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        const elementNamePattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()]);
+        return {
+            [`Element$1[name=${elementNamePattern}] > :matches(BoundAttribute, TextAttribute)[name="autofocus"]`]({ sourceSpan, }) {
+                const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
+                context.report({
+                    loc,
+                    messageId: 'noAutofocus',
+                    fix: (fixer) => fixer.removeRange([
+                        sourceSpan.start.offset - 1,
+                        sourceSpan.end.offset,
+                    ]),
+                });
+            },
+        };
+    },
+});

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const get_nearest_node_from_1 = require("../utils/get-nearest-node-from");
+exports.RULE_NAME = 'no-call-expression';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallows calling expressions in templates, except for output handlers',
+            recommended: false,
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    allowList: {
+                        items: { type: 'string' },
+                        type: 'array',
+                        uniqueItems: true,
+                    },
+                },
+                type: 'object',
+            },
+        ],
+        messages: {
+            noCallExpression: 'Avoid calling expressions in templates',
+        },
+    },
+    defaultOptions: [{ allowList: [] }],
+    create(context, [{ allowList }]) {
+        (0, utils_1.ensureTemplateParser)(context);
+        const sourceCode = context.getSourceCode();
+        return {
+            'Call[receiver.name!="$any"]'(node) {
+                const isChildOfBoundEvent = Boolean((0, get_nearest_node_from_1.getNearestNodeFrom)(node, isBoundEvent));
+                if (isChildOfBoundEvent)
+                    return;
+                if (isCallNameInAllowList(node.receiver, allowList))
+                    return;
+                const { sourceSpan: { start, end }, } = node;
+                context.report({
+                    loc: {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end),
+                    },
+                    messageId: 'noCallExpression',
+                });
+            },
+        };
+    },
+});
+function isBoundEvent(node) {
+    return node instanceof bundled_angular_compiler_1.TmplAstBoundEvent;
+}
+function isASTWithName(ast) {
+    return !!ast.name;
+}
+function isCallNameInAllowList(ast, allowList) {
+    return (allowList &&
+        allowList.length > 0 &&
+        isASTWithName(ast) &&
+        allowList.indexOf(ast.name) > -1);
+}

package/dist/rules/no-distracting-elements.js

@@ -0,0 +1,36 @@
+"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-distracting-elements';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '[Accessibility] Enforces that no distracting elements are used',
+            recommended: false,
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            noDistractingElements: 'Do not use <{{element}}> elements as they can create visual accessibility issues and are deprecated',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        return {
+            'Element$1[name=/^(blink|marquee)$/]'({ name: element, sourceSpan, }) {
+                const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
+                context.report({
+                    loc,
+                    messageId: 'noDistractingElements',
+                    data: { element },
+                    fix: (fixer) => fixer.removeRange([sourceSpan.start.offset, sourceSpan.end.offset]),
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-duplicate-attributes.js

@@ -0,0 +1,97 @@
+"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");
+const get_original_attribute_name_1 = require("../utils/get-original-attribute-name");
+exports.RULE_NAME = 'no-duplicate-attributes';
+const DEFAULT_OPTIONS = {
+    allowTwoWayDataBinding: true,
+    ignore: [],
+};
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensures that there are no duplicate input properties or output event listeners',
+            recommended: false,
+        },
+        hasSuggestions: true,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowTwoWayDataBinding: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.allowTwoWayDataBinding,
+                        description: `Whether or not two-way data binding is allowed as an exception to the rule.`,
+                    },
+                    ignore: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        uniqueItems: true,
+                        default: DEFAULT_OPTIONS.ignore,
+                        description: `Input or output properties for which duplicate presence is allowed as an exception to the rule.`,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noDuplicateAttributes: 'Duplicate attribute `{{attributeName}}`',
+            suggestRemoveAttribute: 'Remove attribute `{{attributeName}}`',
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context, [{ allowTwoWayDataBinding, ignore }]) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        return {
+            Element$1({ inputs, outputs, attributes }) {
+                const duplicateInputsAndAttributes = findDuplicates([
+                    ...inputs,
+                    ...attributes,
+                ]);
+                const filteredOutputs = allowTwoWayDataBinding
+                    ? outputs.filter((output) => {
+                        return !inputs.some((input) => input.sourceSpan.start === output.sourceSpan.start &&
+                            input.sourceSpan.end === output.sourceSpan.end);
+                    })
+                    : outputs;
+                const duplicateOutputs = findDuplicates(filteredOutputs);
+                const allDuplicates = [
+                    ...duplicateInputsAndAttributes,
+                    ...duplicateOutputs,
+                ];
+                const filteredDuplicates = ignore && ignore.length > 0
+                    ? allDuplicates.filter((duplicate) => !ignore.includes((0, get_original_attribute_name_1.getOriginalAttributeName)(duplicate)))
+                    : allDuplicates;
+                filteredDuplicates.forEach((duplicate) => {
+                    const loc = parserServices.convertNodeSourceSpanToLoc(duplicate.sourceSpan);
+                    const data = {
+                        attributeName: (0, get_original_attribute_name_1.getOriginalAttributeName)(duplicate),
+                    };
+                    context.report({
+                        loc,
+                        messageId: 'noDuplicateAttributes',
+                        data,
+                        suggest: [
+                            {
+                                messageId: 'suggestRemoveAttribute',
+                                fix: (fixer) => fixer.removeRange([loc.start.column, loc.end.column + 1]),
+                                data,
+                            },
+                        ],
+                    });
+                });
+            },
+        };
+    },
+});
+function findDuplicates(elements) {
+    return elements.filter((element) => {
+        return elements.some((otherElement) => otherElement !== element &&
+            (0, get_original_attribute_name_1.getOriginalAttributeName)(otherElement) ===
+                (0, get_original_attribute_name_1.getOriginalAttributeName)(element));
+    });
+}

package/dist/rules/no-inline-styles.js

@@ -0,0 +1,104 @@
+"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");
+const DEFAULT_OPTIONS = {
+    allowNgStyle: false,
+    allowBindToStyle: false,
+};
+exports.RULE_NAME = 'no-inline-styles';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallows the use of inline styles in HTML templates',
+            recommended: false,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowNgStyle: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.allowNgStyle,
+                    },
+                    allowBindToStyle: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.allowBindToStyle,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noInlineStyles: '<{{element}}/> element should not have inline styles via style attribute. Please use classes instead.',
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context, [{ allowNgStyle, allowBindToStyle }]) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        return {
+            Element$1(node) {
+                let isInvalid = false;
+                if (!allowNgStyle && !allowBindToStyle) {
+                    isInvalid =
+                        isNodeHasStyleAttribute(node) ||
+                            isNodeHasNgStyleAttribute(node) ||
+                            isNodeHasBindingToStyleAttribute(node);
+                }
+                else {
+                    const ngStyle = allowNgStyle
+                        ? false
+                        : isNodeHasNgStyleAttribute(node);
+                    const bindToStyle = allowBindToStyle
+                        ? false
+                        : isNodeHasBindingToStyleAttribute(node);
+                    isInvalid = isNodeHasStyleAttribute(node) || ngStyle || bindToStyle;
+                }
+                if (isInvalid) {
+                    const loc = parserServices.convertElementSourceSpanToLoc(context, node);
+                    context.report({
+                        loc,
+                        messageId: 'noInlineStyles',
+                        data: {
+                            element: node.name,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+/**
+ *  Check that the any element for example `<img>` has a `style` attribute or `attr.style` binding.
+ */
+function isNodeHasStyleAttribute(node) {
+    return (node.attributes.some(({ name }) => isStyle(name)) ||
+        node.inputs.some(({ name }) => isStyle(name)));
+}
+/**
+ *  Check that the any element for example `<img>` has a `ngStyle` attribute binding.
+ */
+function isNodeHasNgStyleAttribute(node) {
+    return node.inputs.some(({ name }) => isNgStyle(name));
+}
+/**
+ *  Check that the any element for example `<img>` has a `[style.background-color]` attribute binding.
+ */
+function isNodeHasBindingToStyleAttribute(node) {
+    return node.inputs.some(({ keySpan }) => isStyleBound(keySpan));
+}
+/**
+ *  Check element is style
+ */
+function isStyle(name) {
+    return name === 'style';
+}
+function isNgStyle(name) {
+    return name === 'ngStyle';
+}
+function isStyleBound(keySpan) {
+    return (keySpan === null || keySpan === void 0 ? void 0 : keySpan.details) ? keySpan.details.includes('style.') : false;
+}

package/dist/rules/no-interpolation-in-attributes.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = exports.MESSAGE_ID = void 0;
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.MESSAGE_ID = 'noInterpolationInAttributes';
+exports.RULE_NAME = 'no-interpolation-in-attributes';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that property-binding is used instead of interpolation in attributes.',
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            [exports.MESSAGE_ID]: 'Use property binding [attribute]="value" instead of interpolation {{ value }} for an attribute.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        return {
+            ['BoundAttribute Interpolation'](interpolation) {
+                const { sourceSpan: { start, end }, } = interpolation;
+                context.report({
+                    loc: {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end),
+                    },
+                    messageId: exports.MESSAGE_ID,
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-negated-async.js

@@ -0,0 +1,60 @@
+"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-negated-async';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that async pipe results are not negated',
+            recommended: 'error',
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            noNegatedAsync: 'Async pipe results should not be negated. Use `(observable | async) === false`, `(observable | async) === null`, or `(observable | async) === undefined` to check its value instead',
+            suggestFalseComparison: 'Compare with `false`',
+            suggestNullComparison: 'Compare with `null`',
+            suggestUndefinedComparison: 'Compare with `undefined`',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        (0, utils_1.ensureTemplateParser)(context);
+        const sourceCode = context.getSourceCode();
+        return {
+            ':not(PrefixNot) > PrefixNot > BindingPipe[name="async"]'({ parent: { sourceSpan: { end, start }, }, }) {
+                context.report({
+                    messageId: 'noNegatedAsync',
+                    loc: {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end),
+                    },
+                    suggest: getSuggestionsSchema().map(({ messageId, textToInsert }) => ({
+                        messageId,
+                        fix: (fixer) => [
+                            fixer.removeRange([start, start + 1]),
+                            fixer.insertTextAfterRange([end, end], textToInsert),
+                        ],
+                    })),
+                });
+            },
+        };
+    },
+});
+exports.RULE_DOCS_EXTENSION = {
+    rationale: `Angular's async pipes emit null initially, prior to the observable emitting any values, or the promise resolving. This can cause negations, like *ngIf="!(myConditional | async)" to thrash the layout and cause expensive side-effects like firing off XHR requests for a component which should not be shown.`,
+};
+function getSuggestionsSchema() {
+    return [
+        { messageId: 'suggestFalseComparison', textToInsert: ' === false' },
+        { messageId: 'suggestNullComparison', textToInsert: ' === null' },
+        {
+            messageId: 'suggestUndefinedComparison',
+            textToInsert: ' === undefined',
+        },
+    ];
+}