@angular-eslint/eslint-plugin-template 15.2.2-alpha.25 → 15.2.2-alpha.26

package/dist/rules/alt-text.js

@@ -0,0 +1,131 @@
+"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_attribute_value_1 = require("../utils/get-attribute-value");
+exports.RULE_NAME = 'alt-text';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '[Accessibility] Enforces alternate text for elements which require the alt, aria-label, aria-labelledby attributes.',
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            altText: '<{{element}}/> element must have a text alternative.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        return {
+            'Element$1[name=/^(img|area|object|input)$/]'(node) {
+                const isValid = isValidNode(node);
+                if (!isValid) {
+                    const loc = parserServices.convertElementSourceSpanToLoc(context, node);
+                    context.report({
+                        loc,
+                        messageId: 'altText',
+                        data: {
+                            element: node.name,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+function isValidNode(node) {
+    if (node.name === 'img') {
+        return isValidImgNode(node);
+    }
+    else if (node.name === 'object') {
+        return isValidObjectNode(node);
+    }
+    else if (node.name === 'area') {
+        return isValidAreaNode(node);
+    }
+    else {
+        return isValidInputNode(node);
+    }
+}
+/**
+ * In this case, we check that the `<img>` element has an `alt` attribute or `attr.alt` binding.
+ */
+function isValidImgNode(node) {
+    return (node.attributes.some(({ name }) => isAlt(name)) ||
+        node.inputs.some(({ name }) => isAlt(name)));
+}
+/**
+ * In this case, we check that the `<object>` element has a `title` or `aria-label` attribute.
+ * Otherwise, we check for the presence of `attr.title` or `attr.aria-label` bindings.
+ */
+function isValidObjectNode(node) {
+    let hasTitleAttribute = false, hasAriaLabelAttribute = false;
+    for (const attribute of node.attributes) {
+        hasTitleAttribute = attribute.name === 'title';
+        hasAriaLabelAttribute = isAriaLabel(attribute.name);
+    }
+    // Note that we return "early" before looping through `element.inputs`.
+    // Because if the element has an attribute, then we don't need to iterate
+    // over the inputs unnecessarily.
+    if (hasTitleAttribute || hasAriaLabelAttribute) {
+        return true;
+    }
+    let hasTitleBinding = false, hasAriaLabelBinding = false;
+    for (const input of node.inputs) {
+        hasTitleBinding = input.name === 'title';
+        hasAriaLabelBinding = isAriaLabel(input.name);
+    }
+    if (hasTitleBinding || hasAriaLabelBinding) {
+        return true;
+    }
+    return (node.children.length > 0 &&
+        !!node.children[0].value);
+}
+/**
+ * In this case, we check that the `<area>` element has an `alt` or `aria-label` attribute.
+ * Otherwise, we check for the presence of `attr.alt` or `attr.aria-label` bindings.
+ */
+function isValidAreaNode(node) {
+    let hasAltAttribute = false, hasAriaLabelAttribute = false;
+    for (const attribute of node.attributes) {
+        hasAltAttribute = isAlt(attribute.name);
+        hasAriaLabelAttribute = isAriaLabel(attribute.name);
+    }
+    // Note that we return "early" before looping through `element.inputs`.
+    // Because if the element has an attribute, then we don't need to iterate
+    // over the inputs unnecessarily.
+    if (hasAltAttribute || hasAriaLabelAttribute) {
+        return true;
+    }
+    let hasAltBinding = false, hasAriaLabelBinding = false;
+    for (const input of node.inputs) {
+        hasAltBinding = isAlt(input.name);
+        hasAriaLabelBinding = isAriaLabel(input.name);
+    }
+    return hasAltBinding || hasAriaLabelBinding;
+}
+/**
+ * In this case, we check that the `<input>` element has an `alt` or `aria-label` attribute.
+ * Otherwise, we check for the presence of `attr.alt` or `attr.aria-label` bindings.
+ */
+function isValidInputNode(node) {
+    const type = (0, get_attribute_value_1.getAttributeValue)(node, 'type');
+    // We are only interested in the `<input type="image">` elements.
+    if (type !== 'image') {
+        return true;
+    }
+    else {
+        return isValidAreaNode(node);
+    }
+}
+function isAriaLabel(name) {
+    return name === 'aria-label' || name === 'aria-labelledby';
+}
+function isAlt(name) {
+    return name === 'alt';
+}

package/dist/rules/attributes-order.js

@@ -0,0 +1,233 @@
+"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 = 'attributes-order';
+const DEFAULT_ORDER = [
+    "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */,
+    "TEMPLATE_REFERENCE" /* OrderType.TemplateReferenceVariable */,
+    "ATTRIBUTE_BINDING" /* OrderType.AttributeBinding */,
+    "INPUT_BINDING" /* OrderType.InputBinding */,
+    "TWO_WAY_BINDING" /* OrderType.TwoWayBinding */,
+    "OUTPUT_BINDING" /* OrderType.OutputBinding */,
+];
+const DEFAULT_OPTIONS = {
+    alphabetical: false,
+    order: [...DEFAULT_ORDER],
+};
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Ensures that HTML attributes and Angular bindings are sorted based on an expected order',
+            recommended: false,
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    alphabetical: {
+                        type: 'boolean',
+                        default: DEFAULT_OPTIONS.alphabetical,
+                    },
+                    order: {
+                        type: 'array',
+                        items: {
+                            enum: DEFAULT_OPTIONS.order,
+                        },
+                        default: DEFAULT_OPTIONS.order,
+                        minItems: DEFAULT_OPTIONS.order.length,
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            attributesOrder: `The element's attributes/bindings did not match the expected order: expected {{expected}} instead of {{actual}}`,
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context, [{ alphabetical, order }]) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        function getLocation(attr) {
+            const loc = parserServices.convertNodeSourceSpanToLoc(attr.sourceSpan);
+            switch (attr.orderType) {
+                case "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */:
+                    return {
+                        start: {
+                            line: loc.start.line,
+                            column: loc.start.column - 1,
+                        },
+                        end: {
+                            line: loc.end.line,
+                            column: loc.end.column + 1,
+                        },
+                    };
+                default:
+                    return loc;
+            }
+        }
+        return {
+            Element$1(node) {
+                var _a;
+                const { attributes, inputs, outputs, references } = node;
+                const { extractedBananaBoxes, extractedInputs, extractedOutputs } = normalizeInputsOutputs(inputs.map(toInputBindingOrderType), outputs.map(toOutputBindingOrderType));
+                const allAttributes = [
+                    ...extractTemplateAttrs(node),
+                    ...attributes.map(toAttributeBindingOrderType),
+                    ...references.map(toTemplateReferenceVariableOrderType),
+                    ...extractedBananaBoxes,
+                    ...extractedInputs,
+                    ...extractedOutputs,
+                ];
+                if (allAttributes.length < 2) {
+                    return;
+                }
+                const sortedAttributes = [...allAttributes].sort(byLocation);
+                const expectedAttributes = [...allAttributes].sort(byOrder(order, alphabetical));
+                let errorRange;
+                for (let i = 0; i < sortedAttributes.length; i++) {
+                    if (sortedAttributes[i] !== expectedAttributes[i]) {
+                        errorRange = [(_a = errorRange === null || errorRange === void 0 ? void 0 : errorRange[0]) !== null && _a !== void 0 ? _a : i, i];
+                    }
+                }
+                if (errorRange) {
+                    const [startIndex, endIndex] = errorRange;
+                    const sourceCode = context.getSourceCode();
+                    const { start } = getLocation(sortedAttributes[startIndex]);
+                    const { end } = getLocation(sortedAttributes[endIndex]);
+                    const loc = { start, end };
+                    const range = [
+                        getStartPos(sortedAttributes[startIndex]),
+                        getEndPos(sortedAttributes[endIndex]),
+                    ];
+                    let replacementText = '';
+                    let lastPos = range[0];
+                    for (let i = startIndex; i <= endIndex; i++) {
+                        const oldAttr = sortedAttributes[i];
+                        const oldStart = getStartPos(oldAttr);
+                        const oldEnd = getEndPos(oldAttr);
+                        const newAttr = expectedAttributes[i];
+                        const newStart = getStartPos(newAttr);
+                        const newEnd = getEndPos(newAttr);
+                        replacementText += sourceCode.text.slice(lastPos, oldStart);
+                        replacementText += sourceCode.text.slice(newStart, newEnd);
+                        lastPos = oldEnd;
+                    }
+                    context.report({
+                        loc,
+                        messageId: 'attributesOrder',
+                        data: {
+                            expected: expectedAttributes
+                                .slice(startIndex, endIndex + 1)
+                                .map((a) => `\`${getMessageName(a)}\``)
+                                .join(', '),
+                            actual: sortedAttributes
+                                .slice(startIndex, endIndex + 1)
+                                .map((a) => `\`${getMessageName(a)}\``)
+                                .join(', '),
+                        },
+                        fix: (fixer) => fixer.replaceTextRange(range, replacementText),
+                    });
+                }
+            },
+        };
+    },
+});
+function byLocation(one, other) {
+    return one.sourceSpan.start.line === other.sourceSpan.start.line
+        ? one.sourceSpan.start.col - other.sourceSpan.start.col
+        : one.sourceSpan.start.line - other.sourceSpan.start.line;
+}
+function byOrder(order, alphabetical) {
+    return function (one, other) {
+        const orderComparison = getOrderIndex(one, order) - getOrderIndex(other, order);
+        if (alphabetical && orderComparison === 0) {
+            return one.name > other.name ? 1 : -1;
+        }
+        return orderComparison;
+    };
+}
+function getOrderIndex(attr, order) {
+    return order.indexOf(attr.orderType);
+}
+function toAttributeBindingOrderType(attribute) {
+    return Object.assign(Object.assign({}, attribute), { orderType: "ATTRIBUTE_BINDING" /* OrderType.AttributeBinding */ });
+}
+function toInputBindingOrderType(input) {
+    return Object.assign(Object.assign({}, input), { orderType: "INPUT_BINDING" /* OrderType.InputBinding */ });
+}
+function toStructuralDirectiveOrderType(attributeOrInput) {
+    return Object.assign(Object.assign({}, attributeOrInput), { orderType: "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */ });
+}
+function toOutputBindingOrderType(output) {
+    return Object.assign(Object.assign({}, output), { orderType: "OUTPUT_BINDING" /* OrderType.OutputBinding */ });
+}
+function toTwoWayBindingOrderType(output) {
+    return Object.assign(Object.assign({}, output), { orderType: "TWO_WAY_BINDING" /* OrderType.TwoWayBinding */ });
+}
+function toTemplateReferenceVariableOrderType(reference) {
+    return Object.assign(Object.assign({}, reference), { orderType: "TEMPLATE_REFERENCE" /* OrderType.TemplateReferenceVariable */ });
+}
+function extractTemplateAttrs(node) {
+    return isTmplAstTemplate(node.parent)
+        ? node.parent.templateAttrs.map(toStructuralDirectiveOrderType)
+        : [];
+}
+function normalizeInputsOutputs(inputs, outputs) {
+    const extractedInputs = inputs
+        .filter((input) => !outputs.some((output) => isOnSameLocation(input, output)))
+        .map(toInputBindingOrderType);
+    const { extractedBananaBoxes, extractedOutputs } = outputs.reduce(({ extractedBananaBoxes, extractedOutputs }, output) => {
+        const boundInput = inputs.find((input) => isOnSameLocation(input, output));
+        return {
+            extractedBananaBoxes: extractedBananaBoxes.concat(boundInput ? toTwoWayBindingOrderType(boundInput) : []),
+            extractedOutputs: extractedOutputs.concat(boundInput ? [] : toOutputBindingOrderType(output)),
+        };
+    }, { extractedBananaBoxes: [], extractedOutputs: [] });
+    return { extractedBananaBoxes, extractedInputs, extractedOutputs };
+}
+function isTmplAstTemplate(node) {
+    return node instanceof bundled_angular_compiler_1.TmplAstTemplate;
+}
+function isOnSameLocation(input, output) {
+    return (input.sourceSpan.start === output.sourceSpan.start &&
+        input.sourceSpan.end === output.sourceSpan.end);
+}
+function getMessageName(expected) {
+    switch (expected.orderType) {
+        case "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */:
+            return `*${expected.name}`;
+        case "TEMPLATE_REFERENCE" /* OrderType.TemplateReferenceVariable */:
+            return `#${expected.name}`;
+        case "INPUT_BINDING" /* OrderType.InputBinding */:
+            return `[${expected.name}]`;
+        case "OUTPUT_BINDING" /* OrderType.OutputBinding */:
+            return `(${expected.name})`;
+        case "TWO_WAY_BINDING" /* OrderType.TwoWayBinding */:
+            return `[(${expected.name})]`;
+        default:
+            return expected.name;
+    }
+}
+function getStartPos(expected) {
+    switch (expected.orderType) {
+        case "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */:
+            return expected.sourceSpan.start.offset - 1;
+        default:
+            return expected.sourceSpan.start.offset;
+    }
+}
+function getEndPos(expected) {
+    switch (expected.orderType) {
+        case "STRUCTURAL_DIRECTIVE" /* OrderType.StructuralDirective */:
+            return expected.sourceSpan.end.offset + 1;
+        default:
+            return expected.sourceSpan.end.offset;
+    }
+}

package/dist/rules/banana-in-box.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 = 'banana-in-box';
+const INVALID_PATTERN = /\[(.*)\]/;
+const VALID_CLOSE_BOX = ')]';
+const VALID_OPEN_BOX = '[(';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that the two-way data binding syntax is correct',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            bananaInBox: 'Invalid binding syntax. Use [(expr)] instead',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        const sourceCode = context.getSourceCode();
+        return {
+            BoundEvent({ name, sourceSpan }) {
+                const matches = name.match(INVALID_PATTERN);
+                if (!matches)
+                    return;
+                const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
+                context.report({
+                    messageId: 'bananaInBox',
+                    loc,
+                    fix: (fixer) => {
+                        const [, textInTheBox] = matches;
+                        const textToReplace = `${VALID_OPEN_BOX}${textInTheBox}${VALID_CLOSE_BOX}`;
+                        const startIndex = sourceCode.getIndexFromLoc(loc.start);
+                        return fixer.replaceTextRange([startIndex, startIndex + name.length + 2], textToReplace);
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/button-has-type.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVALID_TYPE_DATA_KEY = 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 = 'button-has-type';
+exports.INVALID_TYPE_DATA_KEY = 'type';
+// https://www.w3.org/TR/html401/interact/forms.html#adef-type-BUTTON
+const VALID_BUTTON_TYPES = ['button', 'submit', 'reset'];
+const TYPE_ATTRIBUTE_NAME = 'type';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that a button has a valid type specified',
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            missingType: 'Type for <button> is missing',
+            invalidType: `"{{${exports.INVALID_TYPE_DATA_KEY}}}" can not be used as a type for <button>`,
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        return {
+            [`Element$1[name=button]`](element) {
+                if (!isTypeAttributePresentInElement(element)) {
+                    context.report({
+                        loc: parserServices.convertNodeSourceSpanToLoc(element.sourceSpan),
+                        messageId: 'missingType',
+                    });
+                }
+                const invalidTypeInfo = getInvalidButtonTypeIfPresent(element);
+                if (invalidTypeInfo != null) {
+                    context.report({
+                        loc: parserServices.convertNodeSourceSpanToLoc(invalidTypeInfo.sourceSpan),
+                        messageId: 'invalidType',
+                        data: {
+                            [exports.INVALID_TYPE_DATA_KEY]: invalidTypeInfo.value,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+function isTypeAttributePresentInElement({ inputs, attributes, }) {
+    return [...inputs, ...attributes].some(({ name }) => name === TYPE_ATTRIBUTE_NAME);
+}
+function getInvalidButtonTypeIfPresent(element) {
+    const invalidTextAttribute = element.attributes.find(({ name, value }) => name === TYPE_ATTRIBUTE_NAME && !VALID_BUTTON_TYPES.includes(value));
+    if (invalidTextAttribute) {
+        return {
+            sourceSpan: invalidTextAttribute.sourceSpan,
+            value: invalidTextAttribute.value,
+        };
+    }
+    for (const { name, value, sourceSpan } of element.inputs) {
+        // Intentionally ignore the property binding by looking for literal primitives only
+        // in order to avoid type-checking for the property, e.g. check that it's 'submit', 'button', etc.
+        if (name === TYPE_ATTRIBUTE_NAME &&
+            value instanceof bundled_angular_compiler_1.ASTWithSource &&
+            value.ast instanceof bundled_angular_compiler_1.LiteralPrimitive &&
+            !VALID_BUTTON_TYPES.includes(value.ast.value)) {
+            return {
+                value: value.ast.value,
+                sourceSpan,
+            };
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,57 @@
+"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 is_hidden_from_screen_reader_1 = require("../utils/is-hidden-from-screen-reader");
+const is_interactive_element_1 = require("../utils/is-interactive-element");
+const is_presentation_role_1 = require("../utils/is-presentation-role");
+exports.RULE_NAME = 'click-events-have-key-events';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '[Accessibility] Ensures that the click event is accompanied with at least one key event keyup, keydown or keypress.',
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            clickEventsHaveKeyEvents: 'click must be accompanied by either keyup, keydown or keypress event for accessibility.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            Element$1(node) {
+                if (!(0, get_dom_elements_1.getDomElements)().has(node.name)) {
+                    return;
+                }
+                if ((0, is_presentation_role_1.isPresentationRole)(node) ||
+                    (0, is_hidden_from_screen_reader_1.isHiddenFromScreenReader)(node) ||
+                    (0, is_interactive_element_1.isInteractiveElement)(node)) {
+                    return;
+                }
+                let hasClick = false, hasKeyEvent = false;
+                for (const output of node.outputs) {
+                    hasClick = hasClick || output.name === 'click';
+                    hasKeyEvent =
+                        hasKeyEvent ||
+                            output.name.startsWith('keyup') ||
+                            output.name.startsWith('keydown') ||
+                            output.name.startsWith('keypress');
+                }
+                if (!hasClick || hasKeyEvent) {
+                    return;
+                }
+                const parserServices = (0, utils_1.getTemplateParserServices)(context);
+                const loc = parserServices.convertNodeSourceSpanToLoc(node.sourceSpan);
+                context.report({
+                    loc,
+                    messageId: 'clickEventsHaveKeyEvents',
+                });
+            },
+        };
+    },
+});

package/dist/rules/conditional-complexity.js

@@ -0,0 +1,107 @@
+"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 = 'conditional-complexity';
+const DEFAULT_MAX_COMPLEXITY = 5;
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'The conditional complexity should not exceed a rational limit',
+            recommended: false,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    maxComplexity: {
+                        minimum: 1,
+                        type: 'number',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            conditionalComplexity: 'The conditional complexity {{totalComplexity}} exceeds the defined limit {{maxComplexity}}',
+        },
+    },
+    defaultOptions: [{ maxComplexity: DEFAULT_MAX_COMPLEXITY }],
+    create(context, [{ maxComplexity }]) {
+        (0, utils_1.ensureTemplateParser)(context);
+        const sourceCode = context.getSourceCode();
+        return {
+            BoundAttribute(node) {
+                if (!node.value.source || node.value.ast instanceof bundled_angular_compiler_1.Interpolation) {
+                    return;
+                }
+                const possibleBinary = extractPossibleBinaryOrConditionalFrom(getParser().parseBinding(node.value.source, '', 0).ast);
+                const totalComplexity = getTotalComplexity(possibleBinary);
+                if (totalComplexity <= maxComplexity) {
+                    return;
+                }
+                const { sourceSpan: { start, end }, } = node.value;
+                context.report({
+                    loc: {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end),
+                    },
+                    messageId: 'conditionalComplexity',
+                    data: { maxComplexity, totalComplexity },
+                });
+            },
+            Interpolation({ expressions }) {
+                for (const expression of expressions) {
+                    const totalComplexity = getTotalComplexity(expression);
+                    if (totalComplexity <= maxComplexity) {
+                        continue;
+                    }
+                    const { sourceSpan: { start, end }, } = expression;
+                    context.report({
+                        loc: {
+                            start: sourceCode.getLocFromIndex(start),
+                            end: sourceCode.getLocFromIndex(end),
+                        },
+                        messageId: 'conditionalComplexity',
+                        data: { maxComplexity, totalComplexity },
+                    });
+                }
+            },
+        };
+    },
+});
+function extractPossibleBinaryOrConditionalFrom(node) {
+    return node instanceof bundled_angular_compiler_1.BindingPipe ? node.exp : node;
+}
+let parser = null;
+// Instantiate the `Parser` class lazily only when this rule is applied.
+function getParser() {
+    return parser || (parser = new bundled_angular_compiler_1.Parser(new bundled_angular_compiler_1.Lexer()));
+}
+function getTotalComplexity(ast) {
+    const possibleBinaryOrConditional = extractPossibleBinaryOrConditionalFrom(ast);
+    if (!(possibleBinaryOrConditional instanceof bundled_angular_compiler_1.Binary ||
+        possibleBinaryOrConditional instanceof bundled_angular_compiler_1.Conditional)) {
+        return 0;
+    }
+    let total = 1;
+    if (possibleBinaryOrConditional instanceof bundled_angular_compiler_1.Binary) {
+        if (possibleBinaryOrConditional.left instanceof bundled_angular_compiler_1.Binary) {
+            total += getTotalComplexity(possibleBinaryOrConditional.left);
+        }
+        if (possibleBinaryOrConditional.right instanceof bundled_angular_compiler_1.Binary) {
+            total += getTotalComplexity(possibleBinaryOrConditional.right);
+        }
+    }
+    if (possibleBinaryOrConditional instanceof bundled_angular_compiler_1.Conditional) {
+        total +=
+            getTotalComplexity(possibleBinaryOrConditional.condition) +
+                getTotalComplexity(possibleBinaryOrConditional.trueExp) +
+                getTotalComplexity(possibleBinaryOrConditional.falseExp);
+    }
+    return total;
+}